public static StaticMethodCallExpression callX(ClassNode receiver, String methodName, Expression args) { return new StaticMethodCallExpression(receiver, methodName, args); }
private static Expression findStaticMethod(ClassNode staticImportType, String methodName, Expression args) { if (staticImportType.isPrimaryClassNode() || staticImportType.isResolved()) { if (staticImportType.hasPossibleStaticMethod(methodName, args)) { return new StaticMethodCallExpression(staticImportType, methodName, args); } } return null; }
public Expression transformExpression(ExpressionTransformer transformer) { Expression ret = new StaticMethodCallExpression(getOwnerType(), method, transformer.transform(arguments)); ret.setSourcePosition(this); ret.copyNodeMetaData(this); return ret; }
private Expression findStaticPropertyAccessor(ClassNode staticImportType, String propName) { String accessorName = getAccessorName(propName); Expression accessor = findStaticPropertyAccessorByFullName(staticImportType, accessorName); if (accessor == null && accessorName.startsWith("get")) { accessor = findStaticPropertyAccessorByFullName(staticImportType, "is" + accessorName.substring(3)); } if (accessor == null && hasStaticProperty(staticImportType, propName)) { // args will be replaced if (inLeftExpression) accessor = new StaticMethodCallExpression(staticImportType, accessorName, ArgumentListExpression.EMPTY_ARGUMENTS); else accessor = new PropertyExpression(new ClassExpression(staticImportType), propName); } return accessor; }
@Override public void visitStaticMethodCallExpression(StaticMethodCallExpression expr) { StaticMethodCallExpression result = new StaticMethodCallExpression( expr.getOwnerType(), expr.getMethod(), replaceExpr(expr.getArguments())); result.setType(expr.getType()); result.setSourcePosition(expr); replaceVisitedExpressionWith(result); }
@Override public void visitStaticMethodCallExpression(StaticMethodCallExpression expr) { StaticMethodCallExpression conversion = new StaticMethodCallExpression( expr.getOwnerType(), recordNa(expr.getMethod()), convert(expr.getArguments())); conversion.setSourcePosition(expr); conversion.setMetaMethod(expr.getMetaMethod()); result = record(conversion); }
expression = findStaticPropertyAccessorGivenArgs(importNode.getType(), getPropNameForAccessor(importNode.getFieldName()), args); if (expression != null) { return new StaticMethodCallExpression(importNode.getType(), importNode.getFieldName(), args); expression = findStaticPropertyAccessorGivenArgs(importClass, importMember, args); if (expression != null) { return new StaticMethodCallExpression(importClass, prefix(name) + capitalize(importMember), args); expression = findStaticPropertyAccessorGivenArgs(starImportType, getPropNameForAccessor(name), args); if (expression != null) { return new StaticMethodCallExpression(starImportType, name, args);
protected Expression transformBinaryExpression(BinaryExpression be) { int type = be.getOperation().getType(); boolean oldInLeftExpression; Expression right = transform(be.getRightExpression()); be.setRightExpression(right); Expression left; if (type == Types.EQUAL && be.getLeftExpression() instanceof VariableExpression) { oldInLeftExpression = inLeftExpression; inLeftExpression = true; left = transform(be.getLeftExpression()); inLeftExpression = oldInLeftExpression; if (left instanceof StaticMethodCallExpression) { StaticMethodCallExpression smce = (StaticMethodCallExpression) left; StaticMethodCallExpression result = new StaticMethodCallExpression(smce.getOwnerType(), smce.getMethod(), right); setSourcePosition(result, be); return result; } } else { left = transform(be.getLeftExpression()); } be.setLeftExpression(left); return be; }
new FieldExpression(field), assign, new StaticMethodCallExpression(enumBase, "$INIT", args)
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; }
(hasPossibleStaticMethod(currentClass, methodName, args, true)) || hasPossibleStaticProperty(currentClass, methodName)) { StaticMethodCallExpression smce = new StaticMethodCallExpression(currentClass, methodName, args); setSourcePosition(smce, mce); return smce; } else if (hasPossibleStaticMethod(currentClass.getOuterClass(), methodName, args, true) || hasPossibleStaticProperty(currentClass.getOuterClass(), methodName)) { StaticMethodCallExpression smce = new StaticMethodCallExpression(currentClass.getOuterClass(), methodName, args); setSourcePosition(smce, mce); return smce; StaticMethodCallExpression result = new StaticMethodCallExpression(currentClass, methodName, args); result.setSourcePosition(mce); return result;
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; }
public Expression transformExpression(ExpressionTransformer transformer) { Expression ret = new StaticMethodCallExpression(getOwnerType(), method, transformer.transform(arguments)); ret.setSourcePosition(this); return ret; }
private Expression findStaticMethod(ClassNode staticImportType, String methodName, Expression args) { if (staticImportType.isPrimaryClassNode() || staticImportType.isResolved()) { if (staticImportType.hasPossibleStaticMethod(methodName, args)) { return new StaticMethodCallExpression(staticImportType, methodName, args); } } return null; }
public Expression transformExpression(ExpressionTransformer transformer) { Expression ret = new StaticMethodCallExpression(getOwnerType(), method, transformer.transform(arguments)); ret.setSourcePosition(this); return ret; }
public Expression transformExpression(ExpressionTransformer transformer) { Expression ret = new StaticMethodCallExpression(getOwnerType(), method, transformer.transform(arguments)); ret.setSourcePosition(this); return ret; }
public Expression transformExpression(ExpressionTransformer transformer) { Expression ret = new StaticMethodCallExpression(getOwnerType(), method, transformer.transform(arguments)); ret.setSourcePosition(this); return ret; }
private Expression findStaticMethod(ClassNode staticImportType, String methodName, Expression args) { if (staticImportType.isPrimaryClassNode() || staticImportType.isResolved()) { if (staticImportType.hasPossibleStaticMethod(methodName, args)) { return new StaticMethodCallExpression(staticImportType, methodName, args); } } return null; }
private void createConstructorMap(ClassNode cNode, List<PropertyNode> list, List<String> knownImmutableClasses) { final BlockStatement body = new BlockStatement(); for (PropertyNode pNode : list) { body.addStatement(createConstructorStatement(cNode, pNode, knownImmutableClasses)); } // check for missing properties Expression checkArgs = new ArgumentListExpression(new VariableExpression("this"), new VariableExpression("args")); body.addStatement(new ExpressionStatement(new StaticMethodCallExpression(SELF_TYPE, "checkPropNames", checkArgs))); createConstructorMapCommon(cNode, body); }
@Override public void visitStaticMethodCallExpression(StaticMethodCallExpression expr) { StaticMethodCallExpression result = new StaticMethodCallExpression( expr.getOwnerType(), expr.getMethod(), replaceExpr(expr.getArguments())); result.setType(expr.getType()); result.setSourcePosition(expr); replaceVisitedExpressionWith(result); }