public ArgumentListExpression(Parameter[] parameters) { for (int i = 0; i < parameters.length; i++) { Parameter parameter = parameters[i]; addExpression(new VariableExpression(parameter)); } }
private ArgumentListExpression createArgumentList(final Expression origCallArgs) { ArgumentListExpression newArgs = new ArgumentListExpression(); newArgs.addExpression(new VariableExpression(weaved)); if (origCallArgs instanceof TupleExpression) { List<Expression> expressions = ((TupleExpression) origCallArgs).getExpressions(); for (Expression expression : expressions) { newArgs.addExpression(transform(expression)); } } else { newArgs.addExpression(origCallArgs); } return newArgs; } }
private Expression findStaticPropertyAccessorByFullName(ClassNode staticImportType, String accessorMethodName) { // anything will do as we only check size == 1 ArgumentListExpression dummyArgs = new ArgumentListExpression(); dummyArgs.addExpression(new EmptyExpression()); return findStaticMethod(staticImportType, accessorMethodName, (inLeftExpression ? dummyArgs : ArgumentListExpression.EMPTY_ARGUMENTS)); }
public static ArgumentListExpression makeArgumentList(Expression arguments) { ArgumentListExpression ae; if (arguments instanceof ArgumentListExpression) { ae = (ArgumentListExpression) arguments; } else if (arguments instanceof TupleExpression) { TupleExpression te = (TupleExpression) arguments; ae = new ArgumentListExpression(te.getExpressions()); } else { ae = new ArgumentListExpression(); ae.addExpression(arguments); } return ae; }
private int addExpression(Parameter[] newParams, ArgumentListExpression arguments, int index, Parameter parameter) { newParams[index++] = parameter; arguments.addExpression( new CastExpression( parameter.getType(), new VariableExpression(parameter.getName()) ) ); return index; }
private Expression copyLhsVariableExpressions(DeclarationExpression declExpr) { if (declExpr.isMultipleAssignmentDeclaration()) { ArgumentListExpression result = new ArgumentListExpression(); for (Expression expr : declExpr.getTupleExpression().getExpressions()) { result.addExpression(copyVarExpr((VariableExpression) expr)); } return result; } return copyVarExpr(declExpr.getVariableExpression()); }
@Override public Expression wrapLoggingMethodCall(Expression logVariable, String methodName, Expression originalExpression) { final MethodCallExpression condition; if (!"trace".equals(methodName)) { AttributeExpression logLevelExpression = new AttributeExpression( new ClassExpression(classNode(PRIORITY_NAME)), new ConstantExpression(methodName.toUpperCase(Locale.ENGLISH))); ArgumentListExpression args = new ArgumentListExpression(); args.addExpression(logLevelExpression); condition = new MethodCallExpression(logVariable, "isEnabledFor", args); } else { // log4j api is inconsistent, so trace requires special handling condition = new MethodCallExpression( logVariable, "is" + methodName.substring(0, 1).toUpperCase(Locale.ENGLISH) + methodName.substring(1) + "Enabled", ArgumentListExpression.EMPTY_ARGUMENTS); } condition.setImplicitThis(false); return new TernaryExpression( new BooleanExpression(condition), originalExpression, ConstantExpression.NULL); } }
@Override public Expression wrapLoggingMethodCall(Expression logVariable, String methodName, Expression originalExpression) { AttributeExpression logLevelExpression = new AttributeExpression( new ClassExpression(LEVEL_CLASSNODE), new ConstantExpression(methodName.toUpperCase(Locale.ENGLISH))); ArgumentListExpression args = new ArgumentListExpression(); args.addExpression(logLevelExpression); MethodCallExpression condition = new MethodCallExpression(logVariable, "isLoggable", args); condition.setImplicitThis(false); return new TernaryExpression( new BooleanExpression(condition), originalExpression, ConstantExpression.NULL); } }
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; }
private static Statement createDelegatingForwarder(final MethodNode forwarderMethod, final ClassNode next) { // generates --> next$Trait$Helper.method(this, arg1, arg2) TraitHelpersTuple helpers = Traits.findHelpers(next); ArgumentListExpression args = new ArgumentListExpression(); args.addExpression(new VariableExpression("this")); Parameter[] forwarderMethodParameters = forwarderMethod.getParameters(); for (final Parameter forwarderMethodParameter : forwarderMethodParameters) { args.addExpression(new VariableExpression(forwarderMethodParameter)); } StaticMethodCallExpression delegateCall = new StaticMethodCallExpression( helpers.getHelper(), forwarderMethod.getName(), args ); Statement result; if (ClassHelper.VOID_TYPE.equals(forwarderMethod.getReturnType())) { BlockStatement stmt = new BlockStatement(); stmt.addStatement(new ExpressionStatement(delegateCall)); stmt.addStatement(new ReturnStatement(new ConstantExpression(null))); result = stmt; } else { result = new ReturnStatement(delegateCall); } return result; }
ArgumentListExpression newArgs = new ArgumentListExpression(); Expression arguments = exp.getArguments(); newArgs.addExpression(new VariableExpression("this")); if (arguments instanceof TupleExpression) { List<Expression> expressions = ((TupleExpression) arguments).getExpressions(); for (Expression expression : expressions) { newArgs.addExpression(transform(expression)); newArgs.addExpression(transform(arguments));
if (!processDelegateParam(mNode, mapParam, args, propNames, fromParam)) return; } else { args.addExpression(varX(fromParam)); if (hasDuplicates(mNode, propNames, fromParam.getName())) return; genParams.add(fromParam);
private boolean processDelegateParam(MethodNode mNode, Parameter mapParam, ArgumentListExpression args, List<String> propNames, Parameter fromParam) { if (isInnerClass(fromParam.getType())) { if (mNode.isStatic()) { addError("Error during " + MY_TYPE_NAME + " processing. Delegate type '" + fromParam.getType().getNameWithoutPackage() + "' is an inner class which is not supported.", mNode); return false; } } Set<String> names = new HashSet<String>(); List<PropertyNode> props = getAllProperties(names, fromParam.getType(), true, false, false, true, false, true); for (String next : names) { if (hasDuplicates(mNode, propNames, next)) return false; } List<MapEntryExpression> entries = new ArrayList<MapEntryExpression>(); for (PropertyNode pNode : props) { String name = pNode.getName(); entries.add(new MapEntryExpression(constX(name), propX(varX(mapParam), name))); AnnotationNode namedParam = new AnnotationNode(NAMED_PARAM_TYPE); namedParam.addMember("value", constX(name)); namedParam.addMember("type", classX(pNode.getType())); mapParam.addAnnotation(namedParam); } Expression delegateMap = new MapExpression(entries); args.addExpression(castX(fromParam.getType(), delegateMap)); return true; }
private boolean processImplicitNamedParam(MethodNode mNode, Parameter mapParam, ArgumentListExpression args, List<String> propNames, Parameter fromParam) { boolean required = fromParam.hasInitialExpression(); String name = fromParam.getName(); if (hasDuplicates(mNode, propNames, name)) return false; AnnotationNode namedParam = new AnnotationNode(NAMED_PARAM_TYPE); namedParam.addMember("value", constX(name)); namedParam.addMember("type", classX(fromParam.getType())); namedParam.addMember("required", constX(required, true)); mapParam.addAnnotation(namedParam); args.addExpression(propX(varX(mapParam), name)); return true; }
} else { if (k > counter - j && parameter.hasInitialExpression()) { arguments.addExpression( new CastExpression( parameter.getType(),
private boolean processExplicitNamedParam(MethodNode mNode, Parameter mapParam, BlockStatement inner, ArgumentListExpression args, List<String> propNames, Parameter fromParam) { AnnotationNode namedParam = fromParam.getAnnotations(NAMED_PARAM_TYPE).get(0); boolean required = memberHasValue(namedParam, "required", true); if (getMemberStringValue(namedParam, "value") == null) { namedParam.addMember("value", constX(fromParam.getName())); } String name = getMemberStringValue(namedParam, "value"); if (getMemberValue(namedParam, "type") == null) { namedParam.addMember("type", classX(fromParam.getType())); } if (hasDuplicates(mNode, propNames, name)) return false; // TODO check specified type is assignable from declared param type? // ClassNode type = getMemberClassValue(namedParam, "type"); if (required) { if (fromParam.hasInitialExpression()) { addError("Error during " + MY_TYPE_NAME + " processing. A required parameter can't have an initial value.", mNode); return false; } inner.addStatement(new AssertStatement(boolX(callX(varX(mapParam), "containsKey", args(constX(name)))), plusX(new ConstantExpression("Missing required named argument '" + name + "'. Keys found: "), callX(varX(mapParam), "keySet")))); } args.addExpression(propX(varX(mapParam), name)); mapParam.addAnnotation(namedParam); fromParam.getAnnotations().remove(namedParam); return true; }
newArgs.addExpression(expression);
assertNodeType(VARIABLE_DEF, varDef); DeclarationExpression de = (DeclarationExpression) declarationExpression(varDef); alist.addExpression(de.getVariableExpression());
ArgumentListExpression newArgs = new ArgumentListExpression(new ConstantExpression(null)); for (Expression arg: args) { newArgs.addExpression(arg);
private static Statement createSuperFallback(MethodNode forwarderMethod, ClassNode returnType) { ArgumentListExpression args = new ArgumentListExpression(); Parameter[] forwarderMethodParameters = forwarderMethod.getParameters(); for (final Parameter forwarderMethodParameter : forwarderMethodParameters) { args.addExpression(new VariableExpression(forwarderMethodParameter)); } BinaryExpression instanceOfExpr = new BinaryExpression(new VariableExpression("this"), Token.newSymbol(Types.KEYWORD_INSTANCEOF, -1, -1), new ClassExpression(Traits.GENERATED_PROXY_CLASSNODE)); MethodCallExpression superCall = new MethodCallExpression( new VariableExpression("super"), forwarderMethod.getName(), args ); superCall.setImplicitThis(false); CastExpression proxyReceiver = new CastExpression(Traits.GENERATED_PROXY_CLASSNODE, new VariableExpression("this")); MethodCallExpression getProxy = new MethodCallExpression(proxyReceiver, "getProxyTarget", ArgumentListExpression.EMPTY_ARGUMENTS); getProxy.setImplicitThis(true); StaticMethodCallExpression proxyCall = new StaticMethodCallExpression( ClassHelper.make(InvokerHelper.class), "invokeMethod", new ArgumentListExpression(getProxy, new ConstantExpression(forwarderMethod.getName()), new ArrayExpression(ClassHelper.OBJECT_TYPE, args.getExpressions())) ); IfStatement stmt = new IfStatement( new BooleanExpression(instanceOfExpr), new ExpressionStatement(new CastExpression(returnType,proxyCall)), new ExpressionStatement(superCall) ); return stmt; }