public void visitConstructorCallExpression(ConstructorCallExpression call) { call.getArguments().visit(this); }
@Override public void visitConstructorCallExpression(final ConstructorCallExpression cce) { if (!insideScriptBody || !cce.isUsingAnonymousInnerClass()) return; ConstructorCallExpression old = currentAIC; currentAIC = cce; Expression newArgs = transform(cce.getArguments()); if (cce.getArguments() instanceof TupleExpression && newArgs instanceof TupleExpression) { List<Expression> argList = ((TupleExpression) cce.getArguments()).getExpressions(); argList.clear(); argList.addAll(((TupleExpression) newArgs).getExpressions()); } currentAIC = old; }
public MapStyleConstructorCall( final StaticCompilationTransformer transformer, final ClassNode declaringClass, final MapExpression map, final ConstructorCallExpression originalCall) { this.staticCompilationTransformer = transformer; this.declaringClass = declaringClass; this.map = map; this.originalCall = originalCall; this.setSourcePosition(originalCall); this.copyNodeMetaData(originalCall); List<Expression> originalExpressions = originalCall.getArguments() instanceof TupleExpression ? ((TupleExpression)originalCall.getArguments()).getExpressions() : null; this.innerClassCall = originalExpressions != null && originalExpressions.size() == 2; }
public static Expression getArguments(Expression invocation) { if (invocation instanceof MethodCallExpression) return ((MethodCallExpression) invocation).getArguments(); if (invocation instanceof StaticMethodCallExpression) return ((StaticMethodCallExpression) invocation).getArguments(); if (invocation instanceof ConstructorCallExpression) return ((ConstructorCallExpression) invocation).getArguments(); return null; }
public void visitConstructorCallExpression(final ConstructorCallExpression call) { assertExpressionAuthorized(call); call.getArguments().visit(this); }
public void visitConstructorCallExpression(ConstructorCallExpression call) { if (!call.isSpecialCall()) return; type = call.getText(); call.getArguments().visit(this); type = null; }
@Override public void visitConstructorCallExpression(ConstructorCallExpression expr) { result = new ExpressionInfo( TextRegion.of(expr), TextPosition.startOf(expr), "<init>", convert(expr.getArguments())); }
protected Expression transformConstructorCallExpression(ConstructorCallExpression cce) { inSpecialConstructorCall = cce.isSpecialCall(); Expression expression = cce.getArguments(); if (expression instanceof TupleExpression) { TupleExpression tuple = (TupleExpression) expression; if (tuple.getExpressions().size() == 1) { expression = tuple.getExpression(0); if (expression instanceof NamedArgumentListExpression) { NamedArgumentListExpression namedArgs = (NamedArgumentListExpression) expression; List<MapEntryExpression> entryExpressions = namedArgs.getMapEntryExpressions(); for (int i = 0; i < entryExpressions.size(); i++) { entryExpressions.set(i, (MapEntryExpression) transformMapEntryExpression(entryExpressions.get(i), cce.getType())); } } } } Expression ret = cce.transformExpression(this); inSpecialConstructorCall = false; return ret; }
private void insertThis0ToSuperCall(final ConstructorCallExpression call, final ClassNode cn) { // calculate outer class which we need for this$0 ClassNode parent = classNode; int level = 0; for (; parent != null && parent != cn.getOuterClass(); parent = parent.getOuterClass()) { level++; } // if constructor call is not in outer class, don't pass 'this' implicitly. Return. if (parent == null) return; //add this parameter to node Expression argsExp = call.getArguments(); if (argsExp instanceof TupleExpression) { TupleExpression argsListExp = (TupleExpression) argsExp; Expression this0 = VariableExpression.THIS_EXPRESSION; for (int i = 0; i != level; ++i) this0 = new PropertyExpression(this0, "this$0"); argsListExp.getExpressions().add(0, this0); } } }
protected void writeNormalConstructorCall(ConstructorCallExpression call) { Expression arguments = call.getArguments(); if (arguments instanceof TupleExpression) { TupleExpression tupleExpression = (TupleExpression) arguments; int size = tupleExpression.getExpressions().size(); if (size == 0) { arguments = MethodCallExpression.NO_ARGUMENTS; } } Expression receiverClass = new ClassExpression(call.getType()); controller.getCallSiteWriter().makeCallSite( receiverClass, CallSiteWriter.CONSTRUCTOR, arguments, false, false, false, false); }
@Override protected void writeNormalConstructorCall(ConstructorCallExpression call) { makeCall(call, new ClassExpression(call.getType()), new ConstantExpression("<init>"), call.getArguments(), null, false, false, false); }
@Override public void visitConstructorCallExpression(ConstructorCallExpression expr) { ConstructorCallExpression conversion = new ConstructorCallExpression( expr.getType(), convert(expr.getArguments())); conversion.setSourcePosition(expr); result = record(conversion); }
@Override public void visitConstructorCallExpression(ConstructorCallExpression expr) { ConstructorCallExpression result = new ConstructorCallExpression( expr.getType(), replaceExpr(expr.getArguments())); result.setSourcePosition(expr); replaceVisitedExpressionWith(result); }
private boolean writeDirectConstructorCall(ConstructorCallExpression call) { if (!controller.isFastPath()) return false; StatementMeta meta = call.getNodeMetaData(StatementMeta.class); ConstructorNode cn = null; if (meta!=null) cn = (ConstructorNode) meta.target; if (cn==null) return false; String ownerDescriptor = prepareConstructorCall(cn); TupleExpression args = makeArgumentList(call.getArguments()); loadArguments(args.getExpressions(), cn.getParameters()); finnishConstructorCall(cn, ownerDescriptor, args.getExpressions().size()); return true; }
private void passThisReference(ConstructorCallExpression call) { ClassNode cn = call.getType().redirect(); if (!shouldHandleImplicitThisForInnerClass(cn)) return; boolean isInStaticContext = true; if (currentMethod != null) isInStaticContext = currentMethod.getVariableScope().isInStaticContext(); else if (currentField != null) isInStaticContext = currentField.isStatic(); else if (processingObjInitStatements) isInStaticContext = false; // if constructor call is not in static context, return if (isInStaticContext) { // constructor call is in static context and the inner class is non-static - 1st arg is supposed to be // passed as enclosing "this" instance // Expression args = call.getArguments(); if (args instanceof TupleExpression && ((TupleExpression) args).getExpressions().isEmpty()) { addError("No enclosing instance passed in constructor call of a non-static inner class", call); } return; } insertThis0ToSuperCall(call, cn); }
@Override public void visitConstructorCallExpression(final ConstructorCallExpression call) { super.visitConstructorCallExpression(call); MethodNode target = (MethodNode) call.getNodeMetaData(DIRECT_METHOD_CALL_TARGET); if (target==null && call.getLineNumber()>0) { addError("Target constructor for constructor call expression hasn't been set", call); } else { if (target==null) { // try to find a target ArgumentListExpression argumentListExpression = InvocationWriter.makeArgumentList(call.getArguments()); List<Expression> expressions = argumentListExpression.getExpressions(); ClassNode[] args = new ClassNode[expressions.size()]; for (int i = 0; i < args.length; i++) { args[i] = typeChooser.resolveType(expressions.get(i), classNode); } MethodNode constructor = findMethodOrFail(call, call.isSuperCall() ? classNode.getSuperClass() : classNode, "<init>", args); call.putNodeMetaData(DIRECT_METHOD_CALL_TARGET, constructor); target = constructor; } } if (target!=null) { memorizeInitialExpressions(target); } }
protected void inferDiamondType(final ConstructorCallExpression cce, final ClassNode lType) { // check if constructor call expression makes use of the diamond operator ClassNode node = cce.getType(); if (node.isUsingGenerics() && node.getGenericsTypes() != null && node.getGenericsTypes().length == 0) { ArgumentListExpression argumentListExpression = InvocationWriter.makeArgumentList(cce.getArguments()); if (argumentListExpression.getExpressions().isEmpty()) { adjustGenerics(lType, node); } else { ClassNode type = getType(argumentListExpression.getExpression(0)); if (type.isUsingGenerics()) { adjustGenerics(type, node); } } // store inferred type on CCE storeType(cce, node); } }
List<Expression> args = makeArgumentList(call.getArguments()).getExpressions(); Parameter[] params = cn.getParameters();
public boolean addGeneratedClosureConstructorCall(ConstructorCallExpression call) { ClassNode classNode = controller.getClassNode(); if (!classNode.declaresInterface(ClassHelper.GENERATED_CLOSURE_Type)) return false; AsmClassGenerator acg = controller.getAcg(); OperandStack operandStack = controller.getOperandStack(); MethodVisitor mv = controller.getMethodVisitor(); mv.visitVarInsn(ALOAD, 0); ClassNode callNode = classNode.getSuperClass(); TupleExpression arguments = (TupleExpression) call.getArguments(); if (arguments.getExpressions().size()!=2) throw new GroovyBugError("expected 2 arguments for closure constructor super call, but got"+arguments.getExpressions().size()); arguments.getExpression(0).visit(acg); operandStack.box(); arguments.getExpression(1).visit(acg); operandStack.box(); //TODO: replace with normal String, p not needed Parameter p = new Parameter(ClassHelper.OBJECT_TYPE,"_p"); String descriptor = BytecodeHelper.getMethodDescriptor(ClassHelper.VOID_TYPE, new Parameter[]{p,p}); mv.visitMethodInsn(INVOKESPECIAL, BytecodeHelper.getClassInternalName(callNode), "<init>", descriptor, false); operandStack.remove(2); return true; }
@Override public void writeSpecialConstructorCall(final ConstructorCallExpression call) { MethodNode mn = call.getNodeMetaData(StaticTypesMarker.DIRECT_METHOD_CALL_TARGET); if (mn==null) { super.writeSpecialConstructorCall(call); return; } controller.getCompileStack().pushInSpecialConstructorCall(); ConstructorNode cn; if (mn instanceof ConstructorNode) { cn = (ConstructorNode) mn; } else { cn = new ConstructorNode(mn.getModifiers(), mn.getParameters(), mn.getExceptions(), mn.getCode()); cn.setDeclaringClass(mn.getDeclaringClass()); } // load "this" controller.getMethodVisitor().visitVarInsn(ALOAD, 0); String ownerDescriptor = BytecodeHelper.getClassInternalName(cn.getDeclaringClass()); TupleExpression args = makeArgumentList(call.getArguments()); int before = controller.getOperandStack().getStackLength(); loadArguments(args.getExpressions(), cn.getParameters()); finnishConstructorCall(cn, ownerDescriptor, controller.getOperandStack().getStackLength() - before); // on a special call, there's no object on stack controller.getOperandStack().remove(1); controller.getCompileStack().pop(); }