Refine search
private Expression transformMethodCall(MethodCallExpression mce, Expression argsExp) { ClassNode classType; if (isNewMethodStyle(mce)) { classType = mce.getObjectExpression().getType(); } else { classType = findMatchingCandidateClass(mce); } if (classType != null) { Expression argsToUse = argsExp; if (classType.getOuterClass() != null && ((classType.getModifiers() & org.objectweb.asm.Opcodes.ACC_STATIC) == 0)) { if (!(argsExp instanceof ArgumentListExpression)) { addError("Non-static inner constructor arguments must be an argument list expression; pass 'this' pointer explicitely as first constructor argument otherwise.", mce); return mce; } final ArgumentListExpression argsListExp = (ArgumentListExpression) argsExp; final List<Expression> argExpList = argsListExp.getExpressions(); final VariableExpression thisVarExp = new VariableExpression("this"); final List<Expression> expressionsWithThis = new ArrayList<Expression>(argExpList.size() + 1); expressionsWithThis.add(thisVarExp); expressionsWithThis.addAll(argExpList); argsToUse = new ArgumentListExpression(expressionsWithThis); } return new ConstructorCallExpression(classType, argsToUse); } // set the args as they might have gotten Newify transformed GROOVY-3491 mce.setArguments(argsExp); return mce; }
public String getText() { String text = null; if (isSuperCall()) { text = "super "; } else if (isThisCall()) { text = "this "; } else { text = "new " + getType().getName(); } return text + arguments.getText(); }
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); } }
public boolean isSpecialCall() { return isThisCall() || isSuperCall(); }
public Expression transformExpression(ExpressionTransformer transformer) { Expression args = transformer.transform(arguments); ConstructorCallExpression ret = new ConstructorCallExpression(getType(), args); ret.setSourcePosition(this); ret.setUsingAnonymousInnerClass(isUsingAnonymousInnerClass()); ret.copyNodeMetaData(this); return ret; }
public void visitConstructorCallExpression(ConstructorCallExpression call) { if (!call.isSpecialCall()) return; type = call.getText(); call.getArguments().visit(this); type = null; }
Set<ASTNode> accessedMethods = (Set<ASTNode>) node.getNodeMetaData(StaticTypesMarker.PV_METHODS_ACCESS); if (accessedMethods==null) return; List<MethodNode> methods = new ArrayList<MethodNode>(node.getAllDeclaredMethods()); methods.addAll(node.getDeclaredConstructors()); Map<MethodNode, MethodNode> privateBridgeMethods = (Map<MethodNode, MethodNode>) node.getNodeMetaData(PRIVATE_BRIDGE_METHODS); if (privateBridgeMethods!=null) { args.add(new VariableExpression(parameter)); arguments = new ArgumentListExpression(args); newParams[0] = new Parameter(thatType.getPlainNodeReference(), "$that"); Expression cce = new ConstructorCallExpression(ClassNode.THIS, arguments); Statement body = new ExpressionStatement(cce); bridge = node.addConstructor(ACC_SYNTHETIC, newParams, ClassNode.EMPTY_ARRAY, body); newParams[0] = new Parameter(node.getPlainNodeReference(), "$that"); Expression receiver = method.isStatic()?new ClassExpression(node):new VariableExpression(newParams[0]); MethodCallExpression mce = new MethodCallExpression(receiver, method.getName(), arguments); mce.setMethodTarget(method);
protected ClassNode createStatementsClass() { ClassNode classNode = getScriptClassDummy(); if (classNode.getName().endsWith("package-info")) { return classNode; classNode.addMethod( new MethodNode( "main", ACC_PUBLIC | ACC_STATIC, ClassHelper.VOID_TYPE, new Parameter[] { new Parameter(ClassHelper.STRING_TYPE.makeArray(), "args")}, ClassNode.EMPTY_ARRAY, new ExpressionStatement( new MethodCallExpression( new ClassExpression(ClassHelper.make(InvokerHelper.class)), "runScript", new ArgumentListExpression( new ClassExpression(classNode), new VariableExpression("args")))))); if (classNode.getSuperClass().getDeclaredConstructor(SCRIPT_CONTEXT_CTOR) != null) { stmt = new ExpressionStatement( new ConstructorCallExpression(ClassNode.SUPER, new ArgumentListExpression( new VariableExpression("context"))));
ClassNode outerClass = controller.getOutermostClass(); MethodNode methodNode = controller.getMethodNode(); String name = classNode.getName() + "$" boolean staticMethodOrInStaticClass = controller.isStaticMethod() || classNode.isStaticClass(); removeInitialValues(localVariableParams); InnerClassNode answer = new InnerClassNode(classNode, name, mods, ClassHelper.CLOSURE_TYPE.getPlainNodeReference()); answer.setEnclosingMethod(controller.getMethodNode()); answer.setSynthetic(true); ClassNode.EMPTY_ARRAY, new ReturnStatement( new MethodCallExpression( VariableExpression.THIS_EXPRESSION, "doCall", new ArgumentListExpression(parameters)))); call.setSourcePosition(expression); block.addStatement( new ExpressionStatement( new ConstructorCallExpression( ClassNode.SUPER, conArgs)));
StaticTypesWriterController staticController = (StaticTypesWriterController) controller; if (origin instanceof MethodCallExpression) { ((MethodCallExpression) origin).setMethodTarget(null); ConstructorCallExpression cce = new ConstructorCallExpression(StaticCompilationVisitor.ARRAYLIST_CLASSNODE, ArgumentListExpression.EMPTY_ARGUMENTS); cce.setNodeMetaData(StaticTypesMarker.DIRECT_METHOD_CALL_TARGET, StaticCompilationVisitor.ARRAYLIST_CONSTRUCTOR); TemporaryVariableExpression result = new TemporaryVariableExpression(cce); result.visit(controller.getAcg()); VariableExpression iteratorAsVar = new VariableExpression(iterator); MethodCallExpression origMCE = (MethodCallExpression) origin; MethodCallExpression newMCE = new MethodCallExpression( iteratorAsVar, origMCE.getMethodAsString(), origMCE.getArguments() ); compileStack.removeVar(slot.getIndex()); ClassNode returnType = operandStack.getTopOperand(); if (ClassHelper.isPrimitiveType(returnType) && !ClassHelper.VOID_TYPE.equals(returnType)) { operandStack.box();
if (expr instanceof MethodCallExpression && candidate == null) { MethodCallExpression mce = (MethodCallExpression) expr; Expression args = transform(mce.getArguments()); if (isNewifyCandidate(mce)) { Expression transformed = transformMethodCall(mce, args); return transformed; Expression method = transform(mce.getMethod()); Expression object = transform(mce.getObjectExpression()); MethodCallExpression transformed = callX(object, method, args); transformed.setImplicitThis(mce.isImplicitThis()); } else if (expr instanceof ConstructorCallExpression) { ConstructorCallExpression cce = (ConstructorCallExpression) expr; if (cce.isUsingAnonymousInnerClass()) { cce.getType().visitContents(this);
return; ClassNode receiver = call.isThisCall() ? typeCheckingContext.getEnclosingClassNode() : call.isSuperCall() ? typeCheckingContext.getEnclosingClassNode().getSuperClass() : call.getType(); Expression arguments = call.getArguments(); if (args.length > 0 && typeCheckingContext.getEnclosingClosure() != null && argumentList.getExpression(0) instanceof VariableExpression && ((VariableExpression) argumentList.getExpression(0)).isThisExpression() && call.getType() instanceof InnerClassNode && call.getType().getOuterClass().equals(args[0]) && !call.getType().isStaticClass()) { args[0] = CLOSURE_TYPE;
private boolean shouldImplicitlyPassThisPara(ConstructorCallExpression cce) { boolean pass = false; ClassNode superCN = classNode.getSuperClass(); if (cce.isThisCall()) { pass = true; } else if (cce.isSuperCall()) { // if the super class is another non-static inner class in the same outer class hierarchy, implicit this // needs to be passed if (!superCN.isEnum() && !superCN.isInterface() && superCN instanceof InnerClassNode) { InnerClassNode superInnerCN = (InnerClassNode) superCN; if (!isStatic(superInnerCN) && classNode.getOuterClass().isDerivedFrom(superCN.getOuterClass())) { pass = true; } } } return pass; }
private Expression transformRegularConstructor(final ListExpression expr, final MethodNode target) { // can be replaced with a direct constructor call List<Expression> transformedArgs = transformArguments(expr); ConstructorCallExpression cce = new ConstructorCallExpression( target.getDeclaringClass(), new ArgumentListExpression(transformedArgs) ); cce.setSourcePosition(expr); cce.putNodeMetaData(DIRECT_METHOD_CALL_TARGET, target); return cce; }
configureAST(attributeExpression, node); Expression arguments = arguments(elist); MethodCallExpression expression = new MethodCallExpression(attributeExpression, "call", arguments); setTypeArgumentsOnMethodCallExpression(expression, typeArgumentList); configureAST(expression, methodCallNode); MethodCallExpression expression = new MethodCallExpression(objectExpression, name, arguments); expression.setSafe(safe); expression.setSpreadSafe(spreadSafe); expression.setImplicitThis(implicitThis); if (implicitThis && "this".equals(expression.getMethodAsString())) { ret = new ConstructorCallExpression(this.classNode, arguments);
private void createConstructor(final ClassNode classNode) { Parameter[] params = new Parameter[]{ new Parameter(MarkupTemplateEngine.MARKUPTEMPLATEENGINE_CLASSNODE, "engine"), new Parameter(ClassHelper.MAP_TYPE.getPlainNodeReference(), "model"), new Parameter(ClassHelper.MAP_TYPE.getPlainNodeReference(), "modelTypes"), new Parameter(TEMPLATECONFIG_CLASSNODE, "tplConfig") }; List<Expression> vars = new LinkedList<Expression>(); for (Parameter param : params) { vars.add(new VariableExpression(param)); } ExpressionStatement body = new ExpressionStatement( new ConstructorCallExpression(ClassNode.SUPER, new ArgumentListExpression(vars))); ConstructorNode ctor = new ConstructorNode(Opcodes.ACC_PUBLIC, params, ClassNode.EMPTY_ARRAY, body); classNode.addConstructor(ctor); } }
private Statement throwAssertionFailedError(AnnotationNode annotationNode) { ThrowStatement throwStatement = new ThrowStatement( new ConstructorCallExpression(ASSERTION_FAILED_ERROR_TYPE, new ArgumentListExpression( new ConstantExpression("Method is marked with @NotYetImplemented but passes unexpectedly")))); throwStatement.setSourcePosition(annotationNode); return throwStatement; } }
@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); } }
private Expression cloneDateExpr(Expression origDate) { return new ConstructorCallExpression(DATE_TYPE, new MethodCallExpression(origDate, "getTime", MethodCallExpression.NO_ARGUMENTS)); }
@Override public void writeInvokeConstructor(final ConstructorCallExpression call) { MethodNode mn = call.getNodeMetaData(StaticTypesMarker.DIRECT_METHOD_CALL_TARGET); if (mn == null) { super.writeInvokeConstructor(call); cn.setDeclaringClass(mn.getDeclaringClass()); TupleExpression args = makeArgumentList(call.getArguments()); if (cn.isPrivate()) { ClassNode classNode = controller.getClassNode(); if (declaringClass != classNode) { MethodNode bridge = null; if (call.getNodeMetaData(StaticTypesMarker.PV_METHODS_ACCESS) != null) { Map<MethodNode, MethodNode> bridgeMethods = declaringClass.getNodeMetaData(StaticCompilationMetadataKeys.PRIVATE_BRIDGE_METHODS); bridge = bridgeMethods != null ? bridgeMethods.get(cn) : null; ArgumentListExpression newArgs = new ArgumentListExpression(new ConstantExpression(null)); for (Expression arg: args) { newArgs.addExpression(arg); controller.getSourceUnit().addError(new SyntaxException("Cannot call private constructor for " + declaringClass.toString(false) + " from class " + classNode.toString(false), call.getLineNumber(), call.getColumnNumber(), mn.getLastLineNumber(), call.getLastColumnNumber()));