private Expression transformMethodCall(final MethodCallExpression exp) { String name = exp.getMethodAsString(); if (exp.isImplicitThis() && "include".equals(name)) { return tryTransformInclude(exp); } else if (exp.isImplicitThis() && name.startsWith(":")) { List<Expression> args; if (exp.getArguments() instanceof ArgumentListExpression) { args = ((ArgumentListExpression) exp.getArguments()).getExpressions(); } else { args = Collections.singletonList(exp.getArguments()); Expression newArguments = transform(new ArgumentListExpression(new ConstantExpression(name.substring(1)), new ArrayExpression(ClassHelper.OBJECT_TYPE, args))); MethodCallExpression call = new MethodCallExpression( new VariableExpression("this"), "methodMissing", newArguments reformatted.setSourcePosition(exp); ClosureExpression clos = new ClosureExpression(Parameter.EMPTY_ARRAY, new ExpressionStatement(reformatted)); clos.setVariableScope(new VariableScope()); MethodCallExpression stringOf = new MethodCallExpression(new VariableExpression("this"), "stringOf", clos);
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; }
private Expression unrecord(Expression expr) { if (!(expr instanceof MethodCallExpression)) return expr; MethodCallExpression methodExpr = (MethodCallExpression) expr; Expression targetExpr = methodExpr.getObjectExpression(); if (!(targetExpr instanceof VariableExpression)) return expr; VariableExpression var = (VariableExpression)targetExpr; if (!SpockNames.VALUE_RECORDER.equals(var.getName())) return expr; if(!ValueRecorder.RECORD.equals(methodExpr.getMethodAsString())) return expr; return ((ArgumentListExpression)methodExpr.getArguments()).getExpression(1); }
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; }
@Override @SuppressWarnings("unchecked") public void visitArgumentlistExpression(ArgumentListExpression expr) { ArgumentListExpression conversion = new ArgumentListExpression( convertAll(expr.getExpressions())); conversion.setSourcePosition(expr); result = recordNa(conversion); }
public Expression transformExpression(ExpressionTransformer transformer) { Expression ret = new ArgumentListExpression(transformExpressions(getExpressions(), transformer)); ret.setSourcePosition(this); ret.copyNodeMetaData(this); return ret; }
ClassNode enumRef = enumClass.getPlainNodeReference(); Parameter[] parameter = new Parameter[]{new Parameter(ClassHelper.OBJECT_TYPE.makeArray(), "para")}; MethodNode initMethod = new MethodNode("$INIT", PUBLIC_FS | Opcodes.ACC_SYNTHETIC, enumRef, parameter, ClassNode.EMPTY_ARRAY, null); initMethod.setSynthetic(true); ConstructorCallExpression cce = new ConstructorCallExpression( ClassNode.THIS, new ArgumentListExpression( new SpreadExpression(new VariableExpression("para")) code.addStatement(new ReturnStatement(cce)); initMethod.setCode(code); enumClass.addMethod(initMethod); ArgumentListExpression args = new ArgumentListExpression(); args.addExpression(new ConstantExpression(field.getName())); args.addExpression(new ConstantExpression(value)); if (field.getInitialExpression() == null) { if ((enumClass.getModifiers() & Opcodes.ACC_ABSTRACT) != 0) { args.addExpression(exp); args.getExpressions().add(2, new MapExpression(savedMapEntries)); new ExpressionStatement( new BinaryExpression( new FieldExpression(field),
final Expression objectExpression = call.getObjectExpression(); if (!implementsInterfaceOrIsSubclassOf(expressionType, Collection_TYPE) && !expressionType.isArray()) { addStaticTypeError("Spread operator can only be used on collection types", objectExpression); return; ClassNode listNode = LIST_TYPE.getPlainNodeReference(); listNode.setGenericsTypes(new GenericsType[]{new GenericsType(wrapTypeIfNecessary(subcallReturnType))}); storeType(call, listNode); if (callArguments instanceof ArgumentListExpression) { ArgumentListExpression list = (ArgumentListExpression) callArguments; nbOfArgs = list.getExpressions().size(); } else { && (call.isImplicitThis() || (objectExpression instanceof VariableExpression && ((VariableExpression) objectExpression).isThisExpression()))) { if (NUMBER_OPS.containsKey(name) && isNumberType(receiver) && argumentList.getExpressions().size() == 1 && isNumberType(getType(argumentList.getExpression(0)))) { ClassNode right = getType(argumentList.getExpression(0)); ClassNode resultType = getMathResultType(NUMBER_OPS.get(name), receiver, right, name); if (resultType != null) { List<Expression> argExpressions = argumentList.getExpressions(); Parameter[] parameters = mn.getParameters(); for (int i = 0; i < argExpressions.size() && i < parameters.length; i++) { Expression arg = argExpressions.get(i); ClassNode pType = parameters[i].getType();
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) { for (int j = 1; j < newParams.length; j++) { Parameter orig = methodParameters[j-1]; newParams[j] = new Parameter( correctToGenericsSpecRecurse(genericsSpec, orig.getOriginType(), methodSpecificGenerics), orig.getName() ); List<Expression> args = new LinkedList<Expression>(); for (Parameter parameter : methodParameters) { args.add(new VariableExpression(parameter)); arguments = new ArgumentListExpression(args); ExpressionStatement returnStatement = new ExpressionStatement(mce); bridge = node.addMethod( "access$"+i, access,
for (MethodNode methodNode : helperClassNode.getAllDeclaredMethods()) { String name = methodNode.getName(); Parameter[] helperMethodParams = methodNode.getParameters(); boolean isAbstract = methodNode.isAbstract(); if (!isAbstract && helperMethodParams.length > 0 && ((methodNode.getModifiers() & Opcodes.ACC_STATIC) == Opcodes.ACC_STATIC) && (!name.contains("$") || (methodNode.getModifiers() & Opcodes.ACC_SYNTHETIC) == 0)) { ArgumentListExpression argList = new ArgumentListExpression(); argList.addExpression(new VariableExpression("this")); Parameter[] origParams = new Parameter[helperMethodParams.length - 1]; Parameter[] params = new Parameter[helperMethodParams.length - 1]; System.arraycopy(methodNode.getParameters(), 1, params, 0, params.length); Map<String,ClassNode> methodGenericsSpec = new LinkedHashMap<String, ClassNode>(genericsSpec); MethodNode originalMethod = trait.getMethod(name, params); ClassNode originType = parameter.getOriginType(); ClassNode fixedType = correctToGenericsSpecRecurse(methodGenericsSpec, originType); Parameter newParam = new Parameter(fixedType, "arg" + i); List<AnnotationNode> copied = new LinkedList<AnnotationNode>(); List<AnnotationNode> notCopied = new LinkedList<AnnotationNode>(); GeneralUtils.copyAnnotatedNodeAnnotations(parameter, copied, notCopied); newParam.addAnnotations(copied); params[i - 1] = newParam; origParams[i-1] = parameter; argList.addExpression(new VariableExpression(params[i - 1])); MethodCallExpression staticInitCall = new MethodCallExpression( new ClassExpression(helperClassNode), Traits.STATIC_INIT_METHOD, new ArgumentListExpression(new ClassExpression(cNode))); MethodNode staticInitMethod = new MethodNode(
ClassNode outerClass = controller.getOutermostClass(); MethodNode methodNode = controller.getMethodNode(); String name = classNode.getName() + "$" boolean staticMethodOrInStaticClass = controller.isStaticMethod() || classNode.isStaticClass(); } else if (parameters.length == 0) { Parameter it = new Parameter(ClassHelper.OBJECT_TYPE, "it", ConstantExpression.NULL); parameters = new Parameter[]{it}; Variable ref = expression.getVariableScope().getDeclaredVariable("it"); if (ref!=null) it.setClosureSharedVariable(ref.isClosureSharedVariable()); removeInitialValues(localVariableParams); InnerClassNode answer = new InnerClassNode(classNode, name, mods, ClassHelper.CLOSURE_TYPE.getPlainNodeReference()); answer.setEnclosingMethod(controller.getMethodNode()); answer.setSynthetic(true); && parameters[0].getType() != null ClassNode.EMPTY_ARRAY, new ReturnStatement( new MethodCallExpression( VariableExpression.THIS_EXPRESSION, "doCall", new ArgumentListExpression(parameters)))); call.setSourcePosition(expression);
@SuppressWarnings("unchecked") private boolean makeGetPrivateFieldWithBridgeMethod(final Expression receiver, final ClassNode receiverType, final String fieldName, final boolean safe, final boolean implicitThis) { FieldNode field = receiverType.getField(fieldName); ClassNode outerClass = receiverType.getOuterClass(); if (field==null && implicitThis && outerClass !=null && !receiverType.isStaticClass()) { Expression pexp; if (controller.isInClosure()) { MethodCallExpression mce = new MethodCallExpression( new VariableExpression("this"), "getThisObject", ArgumentListExpression.EMPTY_ARGUMENTS ); mce.putNodeMetaData(StaticTypesMarker.INFERRED_TYPE, controller.getOutermostClass()); mce.setImplicitThis(true); mce.setMethodTarget(CLOSURE_GETTHISOBJECT_METHOD); pexp = new CastExpression(controller.getOutermostClass(),mce); if (methodNode!=null) { MethodCallExpression mce = new MethodCallExpression(receiver, methodNode.getName(), new ArgumentListExpression(field.isStatic()?new ConstantExpression(null):receiver)); mce.setMethodTarget(methodNode); mce.setSafe(safe);
private static void addMethods(ClassNode enumClass, FieldNode values) { List<MethodNode> methods = enumClass.getMethods(); ClassNode enumRef = enumClass.getPlainNodeReference(); MethodNode valuesMethod = new MethodNode("values", PUBLIC_FS, enumRef.makeArray(), Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, null); valuesMethod.setSynthetic(true); BlockStatement code = new BlockStatement(); MethodCallExpression cloneCall = new MethodCallExpression(new FieldExpression(values), "clone", MethodCallExpression.NO_ARGUMENTS); cloneCall.setMethodTarget(values.getType().getMethod("clone", Parameter.EMPTY_ARRAY)); code.addStatement(new ReturnStatement(cloneCall)); valuesMethod.setCode(code); BlockStatement ifStatement = new BlockStatement(); ifStatement.addStatement( new ExpressionStatement( new BinaryExpression(new VariableExpression("ordinal"), assign, new ConstantExpression(0)) new ExpressionStatement( new DeclarationExpression( new VariableExpression("ordinal"), Parameter stringParameter = new Parameter(ClassHelper.STRING_TYPE, "name"); MethodNode valueOfMethod = new MethodNode("valueOf", PS, enumRef, new Parameter[]{stringParameter}, ClassNode.EMPTY_ARRAY, null); ArgumentListExpression callArguments = new ArgumentListExpression(); callArguments.addExpression(new ClassExpression(enumClass)); callArguments.addExpression(new VariableExpression("name"));
final Set<String> knownFields) { if (field.isProtected()) { unit.addError(new SyntaxException("Cannot have protected field in a trait (" + trait.getName() + "#" + field.getName() + ")", field.getLineNumber(), field.getColumnNumber())); return; target = staticFieldHelper; mce = new MethodCallExpression( new ClassExpression(INVOKERHELPER_CLASSNODE), "invokeStaticMethod", new ArgumentListExpression( thisObject, new ConstantExpression(Traits.helperSetterName(field)), initCode.getExpression() mce = new MethodCallExpression( new CastExpression(createReceiverType(field.isStatic(), fieldHelper), thisObject), Traits.helperSetterName(field), ); mce.setImplicitThis(false);
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")))))); stmt = new ExpressionStatement( new ConstructorCallExpression(ClassNode.SUPER, new ArgumentListExpression( new ArgumentListExpression( new Parameter[] { new Parameter(ClassHelper.make(Binding.class), "context")}, ClassNode.EMPTY_ARRAY, stmt);
private Expression transformMethodCallExpression(final MethodCallExpression exp) { if (isTraitSuperPropertyExpression(exp.getObjectExpression())) { Expression objectExpression = exp.getObjectExpression(); ClassNode traitReceiver = ((PropertyExpression) objectExpression).getObjectExpression().getType(); getHelper(traitReceiver) ); 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)); MethodCallExpression result = new MethodCallExpression(
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)) { callGetModel, "get", new ArgumentListExpression(new ConstantExpression(varName)) ); mce.setSourcePosition(exp); new VariableExpression("this"), "tryEscape", new ArgumentListExpression(mce) ); yield.setImplicitThis(true);
private TryCatchStatement surroundWithTryCatch(Expression condition, Expression message, Expression executeAndVerify) { final TryCatchStatement tryCatchStatement = new TryCatchStatement( new ExpressionStatement(executeAndVerify), EmptyStatement.INSTANCE ); tryCatchStatement.addCatch( new CatchStatement( new Parameter(new ClassNode(Throwable.class), "throwable"), new ExpressionStatement( AstUtil.createDirectMethodCall( new ClassExpression(resources.getAstNodeCache().SpockRuntime), resources.getAstNodeCache().SpockRuntime_ConditionFailedWithException, new ArgumentListExpression(Arrays.asList( new VariableExpression(SpockNames.ERROR_COLLECTOR), new VariableExpression(SpockNames.VALUE_RECORDER), // recorder new ConstantExpression(resources.getSourceText(condition)), // text new ConstantExpression(condition.getLineNumber()), // line new ConstantExpression(condition.getColumnNumber()), // column message == null ? ConstantExpression.NULL : message, // message new VariableExpression("throwable") // throwable )) ) ) ) ); return tryCatchStatement; }
Parameter args = new Parameter(ClassHelper.OBJECT_TYPE, "args"); MethodCallExpression doCall1arg = new MethodCallExpression( new VariableExpression("this", closureClass), "doCall", new ArgumentListExpression(new VariableExpression(args)) ); doCall1arg.setImplicitThis(true); doCall1arg.setMethodTarget(doCallMethod); closureClass.addMethod( new MethodNode("call", Opcodes.ACC_PUBLIC, MethodCallExpression doCallNoArgs = new MethodCallExpression(new VariableExpression("this", closureClass), "doCall", new ArgumentListExpression(new ConstantExpression(null))); doCallNoArgs.setImplicitThis(true); doCallNoArgs.setMethodTarget(doCallMethod); closureClass.addMethod( new MethodNode("call", Opcodes.ACC_PUBLIC,
if (target.isProtected()) { lookupClassNode = controller.getClassNode(); while (lookupClassNode != null && !lookupClassNode.isDerivedFrom(target.getDeclaringClass())) { lookupClassNode = lookupClassNode.getOuterClass(); lookupClassNode = target.getDeclaringClass().redirect(); Map<MethodNode, MethodNode> bridges = lookupClassNode.getNodeMetaData(PRIVATE_BRIDGE_METHODS); } else if (thisClass != null) { ClassNode current = thisClass.getOuterClass(); fixedReceiver = new VariableExpression("thisObject", current); while (current instanceof InnerClassNode && !lookupClassNode.equals(current)) { ArgumentListExpression newArgs = new ArgumentListExpression(target.isStatic()?new ConstantExpression(null):fixedReceiver); for (Expression expression : args.getExpressions()) { newArgs.addExpression(expression);