private static Expression zeroLengthObjectArray() { return new ArrayExpression(ClassHelper.OBJECT_TYPE, null, Collections.singletonList((Expression) constX(0))); }
/** * Turns an argument list obtained from AstUtil.getArguments() into an Object[] array * suitable to be passed to InvokerHelper or SpockRuntime. The main challenge is * to handle SpreadExpression's correctly. */ public static Expression toArgumentArray(List<Expression> argList, IRewriteResources resources) { List<Expression> normalArgs = new ArrayList<>(); List<Expression> spreadArgs = new ArrayList<>(); List<Expression> spreadPositions = new ArrayList<>(); for (int i = 0; i < argList.size(); i++) { Expression arg = argList.get(i); if (arg instanceof SpreadExpression) { spreadArgs.add(((SpreadExpression) arg).getExpression()); spreadPositions.add(new ConstantExpression(i)); } else { normalArgs.add(arg); } } if (spreadArgs.isEmpty()) return new ArrayExpression(ClassHelper.OBJECT_TYPE, argList); return new MethodCallExpression( new ClassExpression(resources.getAstNodeCache().SpockRuntime), new ConstantExpression(SpockRuntime.DESPREAD_LIST), new ArgumentListExpression( new ArrayExpression(ClassHelper.OBJECT_TYPE, normalArgs), new ArrayExpression(ClassHelper.OBJECT_TYPE, spreadArgs), new ArrayExpression(ClassHelper.int_TYPE, spreadPositions) )); }
private Expression serialize(AnnotationNode an) { MapExpression map = new MapExpression(); for (String key : an.getMembers().keySet()) { map.addMapEntryExpression(new ConstantExpression(key), serialize(an.getMember(key))); } List<Expression> l = new ArrayList<Expression>(2); l.add(new ClassExpression(an.getClassNode())); l.add(map); return new ArrayExpression(ClassHelper.OBJECT_TYPE, l); } }
public static Expression cloneArrayOrCloneableExpr(Expression fieldExpr, ClassNode type) { Expression smce = callX( REFLECTION_INVOKER_TYPE, "invoke", args( fieldExpr, constX("clone"), new ArrayExpression(ClassHelper.OBJECT_TYPE.makeArray(), Collections.<Expression>emptyList()) ) ); return castX(type, smce); }
private Expression serialize(Expression e) { if (e instanceof AnnotationConstantExpression) { AnnotationConstantExpression ace = (AnnotationConstantExpression) e; return serialize((AnnotationNode) ace.getValue()); } else if (e instanceof ListExpression) { boolean annotationConstant = false; ListExpression le = (ListExpression) e; List<Expression> list = le.getExpressions(); List<Expression> newList = new ArrayList<Expression>(list.size()); for (Expression exp: list) { annotationConstant = annotationConstant || exp instanceof AnnotationConstantExpression; newList.add(serialize(exp)); } ClassNode type = ClassHelper.OBJECT_TYPE; if (annotationConstant) type = type.makeArray(); return new ArrayExpression(type, newList); } return e; }
public Expression transformExpression(ExpressionTransformer transformer) { List<Expression> exprList = transformExpressions(expressions, transformer); List<Expression> sizes = null; if (sizeExpression != null) sizes = transformExpressions(sizeExpression, transformer); Expression ret = new ArrayExpression(elementType, exprList, sizes); ret.setSourcePosition(this); ret.copyNodeMetaData(this); return ret; }
public void despreadList(List expressions, boolean wrap) { ArrayList spreadIndexes = new ArrayList(); ArrayList spreadExpressions = new ArrayList(); ArrayList normalArguments = new ArrayList(); for (int i = 0; i < expressions.size(); i++) { Object expr = expressions.get(i); if (!(expr instanceof SpreadExpression)) { normalArguments.add(expr); } else { spreadIndexes.add(new ConstantExpression(Integer.valueOf(i - spreadExpressions.size()),true)); spreadExpressions.add(((SpreadExpression) expr).getExpression()); } } //load normal arguments as array visitTupleExpression(new ArgumentListExpression(normalArguments), wrap); //load spread expressions as array (new TupleExpression(spreadExpressions)).visit(this); //load insertion index (new ArrayExpression(ClassHelper.int_TYPE, spreadIndexes, null)).visit(this); controller.getOperandStack().remove(1); despreadList.call(controller.getMethodVisitor()); }
private Expression transformArrayConstructor(final ListExpression expr, final MethodNode target) { ArrayExpression aex = new ArrayExpression(target.getDeclaringClass().getComponentType(), transformArguments(expr)); aex.setSourcePosition(expr); return aex; }
@SuppressWarnings("unchecked") private void createDataProcessorMethod() { if (dataProcessorVars.isEmpty()) return; dataProcessorStats.add( new ReturnStatement( new ArrayExpression( ClassHelper.OBJECT_TYPE, (List) dataProcessorVars))); BlockStatement blockStat = new BlockStatement(dataProcessorStats, new VariableScope()); new DataProcessorVariableRewriter().visitBlockStatement(blockStat); whereBlock.getParent().getParent().getAst().addMethod( new MethodNode( InternalIdentifiers.getDataProcessorName(whereBlock.getParent().getAst().getName()), Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC, ClassHelper.OBJECT_TYPE, dataProcessorParams.toArray(new Parameter[dataProcessorParams.size()]), ClassNode.EMPTY_ARRAY, blockStat)); }
@Override @SuppressWarnings("unchecked") public void visitArrayExpression(ArrayExpression expr) { ArrayExpression conversion = new ArrayExpression( expr.getElementType(), convertAll(expr.getExpressions()), convertAll(expr.getSizeExpression())); conversion.setSourcePosition(expr); result = record(conversion); }
lastParams.add(argumentList.get(i)); ArrayExpression array = new ArrayExpression( lastParaType.getComponentType(), lastParams
ArrayExpression ae = new ArrayExpression(ClassHelper.OBJECT_TYPE.makeArray(), outer); Statement code = new ReturnStatement(ae); helper.addMethod("value", ACC_PUBLIC + ACC_STATIC,
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"),
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; }
lastParams.add(argumentList.get(i)); ArrayExpression array = new ArrayExpression( lastParaType.getComponentType(), lastParams
ClassNode castType = cast.getType(); if (castType.isArray() && expression instanceof ListExpression) { ArrayExpression arrayExpression = new ArrayExpression(castType.getComponentType(), ((ListExpression) expression).getExpressions()); arrayExpression.setSourcePosition(cast); return transformer.transform(arrayExpression);
ArrayExpression arrayExpression = new ArrayExpression(type, null, size); configureAST(arrayExpression, constructorCallNode); return arrayExpression;
new BinaryExpression(new FieldExpression(values), assign, new ArrayExpression(enumClass, arrayInit))
if (target == StaticTypeCheckingVisitor.CLOSURE_CALL_VARGS) { ArrayExpression arr = new ArrayExpression(ClassHelper.OBJECT_TYPE, args.getExpressions()); return super.writeDirectMethodCall(target, implicitThis, receiver, new ArgumentListExpression(arr)); if (!tryBridgeMethod(target, receiver, implicitThis, args, classNode)) { ArrayExpression arr = new ArrayExpression(ClassHelper.OBJECT_TYPE, args.getExpressions()); MethodCallExpression mce = new MethodCallExpression( INVOKERHELER_RECEIVER,
if (rightExpression instanceof ListExpression && lhsType.isArray()) { ListExpression list = (ListExpression) rightExpression; ArrayExpression array = new ArrayExpression(lhsType.getComponentType(), list.getExpressions()); array.setSourcePosition(list); array.visit(acg);