public static ConstructorCallExpression ctorX(ClassNode type, Expression args) { return new ConstructorCallExpression(type, args); }
public static ConstructorCallExpression ctorX(ClassNode type) { return new ConstructorCallExpression(type, ArgumentListExpression.EMPTY_ARGUMENTS); }
protected void addDefaultParameterConstructors(final ClassNode node) { List methods = new ArrayList(node.getDeclaredConstructors()); addDefaultParameters(methods, new DefaultArgsAction() { public void call(ArgumentListExpression arguments, Parameter[] newParams, MethodNode method) { ConstructorNode ctor = (ConstructorNode) method; ConstructorCallExpression expression = new ConstructorCallExpression(ClassNode.THIS, arguments); Statement code = new ExpressionStatement(expression); addConstructor(newParams, ctor, code, node); } }); }
public void call(ArgumentListExpression arguments, Parameter[] newParams, MethodNode method) { ConstructorNode ctor = (ConstructorNode) method; ConstructorCallExpression expression = new ConstructorCallExpression(ClassNode.THIS, arguments); Statement code = new ExpressionStatement(expression); addConstructor(newParams, ctor, code, node); } });
protected Expression specialConstructorCallExpression(AST methodCallNode, ClassNode special) { AST node = methodCallNode.getFirstChild(); Expression arguments = arguments(node); ConstructorCallExpression expression = new ConstructorCallExpression(special, arguments); configureAST(expression, methodCallNode); return expression; }
DeclarationExpression declarationExpression = new DeclarationExpression(localVariable, Token.newSymbol(Types.EQUAL, -1, -1), new ConstructorCallExpression(ClassHelper.makeReference(), param.getInitialExpression()));
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(ConstructorCallExpression expr) { ConstructorCallExpression result = new ConstructorCallExpression( expr.getType(), replaceExpr(expr.getArguments())); result.setSourcePosition(expr); replaceVisitedExpressionWith(result); }
@Override public void visitConstructorCallExpression(ConstructorCallExpression expr) { ConstructorCallExpression conversion = new ConstructorCallExpression( expr.getType(), convert(expr.getArguments())); conversion.setSourcePosition(expr); result = record(conversion); }
public static boolean copyStatementsWithSuperAdjustment(ClosureExpression pre, BlockStatement body) { Statement preCode = pre.getCode(); boolean changed = false; if (preCode instanceof BlockStatement) { BlockStatement block = (BlockStatement) preCode; List<Statement> statements = block.getStatements(); for (int i = 0; i < statements.size(); i++) { Statement statement = statements.get(i); // adjust the first statement if it's a super call if (i == 0 && statement instanceof ExpressionStatement) { ExpressionStatement es = (ExpressionStatement) statement; Expression preExp = es.getExpression(); if (preExp instanceof MethodCallExpression) { MethodCallExpression mce = (MethodCallExpression) preExp; String name = mce.getMethodAsString(); if ("super".equals(name)) { es.setExpression(new ConstructorCallExpression(ClassNode.SUPER, mce.getArguments())); changed = true; } } } body.addStatement(statement); } } return changed; }
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); } }
new VariableExpression(SpockNames.VALUE_RECORDER, nodeCache.ValueRecorder), Token.newSymbol(Types.ASSIGN, -1, -1), new ConstructorCallExpression( nodeCache.ValueRecorder, ArgumentListExpression.EMPTY_ARGUMENTS)))); new VariableExpression(SpockNames.ERROR_COLLECTOR, nodeCache.ErrorCollector), Token.newSymbol(Types.ASSIGN, -1, -1), new ConstructorCallExpression( nodeCache.ErrorCollector, new ArgumentListExpression(Collections.<Expression>singletonList(new ConstantExpression(enableErrorCollector, true)))))));
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; }
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; }
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; }
private void createBuilder() { // ExpressionStatements w/ label have wrong source position, // but source position of the contained expression is OK Expression expr = stat.getExpression(); builderExpr = new ConstructorCallExpression( resources.getAstNodeCache().InteractionBuilder, new ArgumentListExpression( Arrays.<Expression> asList( new ConstantExpression(expr.getLineNumber()), new ConstantExpression(expr.getColumnNumber()), new ConstantExpression(resources.getSourceText(expr))))); }
cce = new ConstructorCallExpression(ClassNode.SUPER, new ArgumentListExpression(args)); BlockStatement code = new BlockStatement(); code.addStatement(new ExpressionStatement(cce));
public Expression transformRangeExpression(RangeExpression range) { final ClassNode inferred = range.getNodeMetaData(StaticTypesMarker.INFERRED_TYPE); if (INTRANGE_TYPE.equals(inferred)) { ArgumentListExpression bounds = new ArgumentListExpression(new ConstantExpression(range.isInclusive(),true),range.getFrom(), range.getTo()); ConstructorCallExpression cce = new ConstructorCallExpression(INTRANGE_TYPE, bounds); cce.setSourcePosition(range); cce.putNodeMetaData(StaticTypesMarker.DIRECT_METHOD_CALL_TARGET, INTRANGE_CTOR); cce.putNodeMetaData(StaticTypesMarker.INFERRED_TYPE, INTRANGE_TYPE); return transformer.transform(cce); } return transformer.superTransform(range); } }
ConstructorCallExpression cce = getFirstIfSpecialConstructorCall(block); if (cce == null) { cce = new ConstructorCallExpression(ClassNode.SUPER, new TupleExpression()); block.getStatements().add(0, new ExpressionStatement(cce));
ConstructorCallExpression ret = new ConstructorCallExpression(type, arguments); if (innerClass != null) { ret.setType(innerClass);