Examples with ArgumentListExpression org.codehaus.groovy.ast.expr.ArgumentListExpression used on opensource projects

Example 81 with ArgumentListExpression

use of org.codehaus.groovy.ast.expr.ArgumentListExpression in project groovy-core by groovy.

the class TraitReceiverTransformer method transformSuperMethodCall.

private Expression transformSuperMethodCall(final MethodCallExpression call) {
    String method = call.getMethodAsString();
    if (method == null) {
        throwSuperError(call);
    }
    Expression arguments = transform(call.getArguments());
    ArgumentListExpression superCallArgs = new ArgumentListExpression();
    if (arguments instanceof ArgumentListExpression) {
        ArgumentListExpression list = (ArgumentListExpression) arguments;
        for (Expression expression : list) {
            superCallArgs.addExpression(expression);
        }
    } else {
        superCallArgs.addExpression(arguments);
    }
    MethodCallExpression transformed = new MethodCallExpression(weaved, Traits.getSuperTraitMethodName(traitClass, method), superCallArgs);
    transformed.setSourcePosition(call);
    transformed.setSafe(call.isSafe());
    transformed.setSpreadSafe(call.isSpreadSafe());
    transformed.setImplicitThis(false);
    return transformed;
}

Example 82 with ArgumentListExpression

use of org.codehaus.groovy.ast.expr.ArgumentListExpression in project groovy-core by groovy.

the class JavaStubGenerator method printSpecialConstructorArgs.

private void printSpecialConstructorArgs(PrintWriter out, ConstructorNode node, ConstructorCallExpression constrCall) {
    // Select a constructor from our class, or super-class which is legal to call,
    // then write out an invoke w/nulls using casts to avoid ambiguous crapo
    Parameter[] params = selectAccessibleConstructorFromSuper(node);
    if (params != null) {
        out.print("super (");
        for (int i = 0; i < params.length; i++) {
            printDefaultValue(out, params[i].getType());
            if (i + 1 < params.length) {
                out.print(", ");
            }
        }
        out.println(");");
        return;
    }
    // Otherwise try the older method based on the constructor's call expression
    Expression arguments = constrCall.getArguments();
    if (constrCall.isSuperCall()) {
        out.print("super(");
    } else {
        out.print("this(");
    }
    // Else try to render some arguments
    if (arguments instanceof ArgumentListExpression) {
        ArgumentListExpression argumentListExpression = (ArgumentListExpression) arguments;
        List<Expression> args = argumentListExpression.getExpressions();
        for (Expression arg : args) {
            if (arg instanceof ConstantExpression) {
                ConstantExpression expression = (ConstantExpression) arg;
                Object o = expression.getValue();
                if (o instanceof String) {
                    out.print("(String)null");
                } else {
                    out.print(expression.getText());
                }
            } else {
                ClassNode type = getConstructorArgumentType(arg, node);
                printDefaultValue(out, type);
            }
            if (arg != args.get(args.size() - 1)) {
                out.print(", ");
            }
        }
    }
    out.println(");");
}

Example 83 with ArgumentListExpression

use of org.codehaus.groovy.ast.expr.ArgumentListExpression in project groovy by apache.

the class MarkupBuilderCodeTransformer method transform.

@Override
public Expression transform(final Expression exp) {
    if (exp instanceof BinaryExpression) {
        return transformBinaryExpression((BinaryExpression) exp);
    }
    if (exp instanceof MethodCallExpression) {
        return transformMethodCall((MethodCallExpression) exp);
    }
    if (exp instanceof ClosureExpression) {
        ClosureExpression cl = (ClosureExpression) exp;
        cl.getCode().visit(this);
        return cl;
    }
    if (exp instanceof VariableExpression) {
        VariableExpression var = (VariableExpression) exp;
        if (var.getAccessedVariable() instanceof DynamicVariable) {
            MethodCallExpression callGetModel = new MethodCallExpression(new VariableExpression("this"), "getModel", ArgumentListExpression.EMPTY_ARGUMENTS);
            callGetModel.setImplicitThis(true);
            callGetModel.setSourcePosition(exp);
            String varName = var.getName();
            if ("model".equals(varName) || "unescaped".equals(varName)) {
                return callGetModel;
            }
            MethodCallExpression mce = new MethodCallExpression(callGetModel, "get", new ArgumentListExpression(new ConstantExpression(varName)));
            mce.setSourcePosition(exp);
            mce.setImplicitThis(false);
            MethodCallExpression yield = new MethodCallExpression(new VariableExpression("this"), "tryEscape", new ArgumentListExpression(mce));
            yield.setImplicitThis(true);
            yield.setSourcePosition(exp);
            yield.putNodeMetaData(TARGET_VARIABLE, varName);
            return autoEscape ? yield : mce;
        }
    }
    return super.transform(exp);
}

Example 84 with ArgumentListExpression

use of org.codehaus.groovy.ast.expr.ArgumentListExpression in project groovy by apache.

the class TemplateASTTransformer method createConstructor.

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);
}

Example 85 with ArgumentListExpression

use of org.codehaus.groovy.ast.expr.ArgumentListExpression in project groovy by apache.

the class EnumCompletionVisitor method transformConstructor.

/**
     * If constructor does not define a call to super, then transform constructor
     * to get String,int parameters at beginning and add call super(String,int).
     */
private void transformConstructor(ConstructorNode ctor, boolean isAic) {
    boolean chainedThisConstructorCall = false;
    ConstructorCallExpression cce = null;
    if (ctor.firstStatementIsSpecialConstructorCall()) {
        Statement code = ctor.getFirstStatement();
        cce = (ConstructorCallExpression) ((ExpressionStatement) code).getExpression();
        if (cce.isSuperCall())
            return;
        // must be call to this(...)
        chainedThisConstructorCall = true;
    }
    // we need to add parameters
    Parameter[] oldP = ctor.getParameters();
    Parameter[] newP = new Parameter[oldP.length + 2];
    String stringParameterName = getUniqueVariableName("__str", ctor.getCode());
    newP[0] = new Parameter(ClassHelper.STRING_TYPE, stringParameterName);
    String intParameterName = getUniqueVariableName("__int", ctor.getCode());
    newP[1] = new Parameter(ClassHelper.int_TYPE, intParameterName);
    System.arraycopy(oldP, 0, newP, 2, oldP.length);
    ctor.setParameters(newP);
    VariableExpression stringVariable = new VariableExpression(newP[0]);
    VariableExpression intVariable = new VariableExpression(newP[1]);
    if (chainedThisConstructorCall) {
        TupleExpression args = (TupleExpression) cce.getArguments();
        List<Expression> argsExprs = args.getExpressions();
        argsExprs.add(0, stringVariable);
        argsExprs.add(1, intVariable);
    } else {
        // add a super call
        List<Expression> args = new ArrayList<Expression>();
        args.add(stringVariable);
        args.add(intVariable);
        if (isAic) {
            for (Parameter parameter : oldP) {
                args.add(new VariableExpression(parameter.getName()));
            }
        }
        cce = new ConstructorCallExpression(ClassNode.SUPER, new ArgumentListExpression(args));
        BlockStatement code = new BlockStatement();
        code.addStatement(new ExpressionStatement(cce));
        Statement oldCode = ctor.getCode();
        if (oldCode != null)
            code.addStatement(oldCode);
        ctor.setCode(code);
    }
}