@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); }
public void visitArrayExpression(ArrayExpression expression) { MethodVisitor mv = controller.getMethodVisitor(); ClassNode elementType = expression.getElementType(); String arrayTypeName = BytecodeHelper.getClassInternalName(elementType); List sizeExpression = expression.getSizeExpression(); size = expression.getExpressions().size(); BytecodeHelper.pushConstant(mv, size); arrayTypeName = BytecodeHelper.getTypeDescription(expression.getType()); mv.visitMultiANewArrayInsn(arrayTypeName, dimensions); } else if (ClassHelper.isPrimitiveType(elementType)) { mv.visitInsn(DUP); BytecodeHelper.pushConstant(mv, i); Expression elementExpression = expression.getExpression(i); if (elementExpression == null) { ConstantExpression.NULL.visit(this); controller.getOperandStack().push(expression.getType());
public ArrayExpression(ClassNode elementType, List<Expression> expressions, List<Expression> sizeExpression) { //expect to get the elementType super.setType(makeArray(elementType, sizeExpression)); if (expressions == null) expressions = Collections.emptyList(); this.elementType = elementType; this.expressions = expressions; this.sizeExpression = sizeExpression; for (Object item : expressions) { if (item != null && !(item instanceof Expression)) { throw new ClassCastException("Item: " + item + " is not an Expression"); } } if (sizeExpression != null) { for (Object item : sizeExpression) { if (!(item instanceof Expression)) { throw new ClassCastException("Item: " + item + " is not an Expression"); } } } }
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; }
@Override @SuppressWarnings("unchecked") public void visitArrayExpression(ArrayExpression expr) { replaceAllExprs(expr.getExpressions()); replaceAllExprs(expr.getSizeExpression()); }
private static Expression zeroLengthObjectArray() { return new ArrayExpression(ClassHelper.OBJECT_TYPE, null, Collections.singletonList((Expression) constX(0))); }
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()); }
public void visitArrayExpression(ArrayExpression expression) { visitNode(expression); visitNode(expression.getElementType()); super.visitArrayExpression(expression); }
@Override public void run() { loc(exp); literal(exp.getElementType()); visit(exp.getSizeExpression()); } });
private Expression transformArrayConstructor(final ListExpression expr, final MethodNode target) { ArrayExpression aex = new ArrayExpression(target.getDeclaringClass().getComponentType(), transformArguments(expr)); aex.setSourcePosition(expr); return aex; }
if (rightExpression instanceof ListExpression && lhsType.isArray()) { ListExpression list = (ListExpression) rightExpression; ArrayExpression array = new ArrayExpression(lhsType.getComponentType(), list.getExpressions()); array.setSourcePosition(list); array.visit(acg); } else if (rightExpression instanceof EmptyExpression) { rhsType = leftExpression.getType();
/** * Return the List of VariableExpression objects referenced by the specified DeclarationExpression. * @param declarationExpression - the DeclarationExpression * @return the List of VariableExpression objects */ public static List<Expression> getVariableExpressions(DeclarationExpression declarationExpression) { Expression leftExpression = declarationExpression.getLeftExpression(); // !important: performance enhancement if (leftExpression instanceof ArrayExpression) { List<Expression> expressions = ((ArrayExpression) leftExpression).getExpressions(); return expressions.isEmpty() ? Arrays.asList(leftExpression) : expressions; } else if (leftExpression instanceof ListExpression) { List<Expression> expressions = ((ListExpression) leftExpression).getExpressions(); return expressions.isEmpty() ? Arrays.asList(leftExpression) : expressions; } else if (leftExpression instanceof TupleExpression) { List<Expression> expressions = ((TupleExpression) leftExpression).getExpressions(); return expressions.isEmpty() ? Arrays.asList(leftExpression) : expressions; } else if (leftExpression instanceof VariableExpression) { return Arrays.asList(leftExpression); } // todo: write warning return Collections.emptyList(); }
@Override public void visitArrayExpression(final ArrayExpression exp) { if (exp.getSizeExpression() != null) { // array instanation like new String[1][2][3] makeNode("newArray", new Runnable() { @Override public void run() { loc(exp); literal(exp.getElementType()); visit(exp.getSizeExpression()); } }); } else { throw new UnsupportedOperationException(exp.getText()); } }
@Override public void visitArrayExpression(ArrayExpression expression) { super.visitArrayExpression(expression); addToCache(expression.getType()); } @Override
public void visitArrayExpression(ArrayExpression expression) { visitListOfExpressions(expression.getExpressions()); visitListOfExpressions(expression.getSizeExpression()); }
/** * 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) )); }
lastParams.add(argumentList.get(i)); ArrayExpression array = new ArrayExpression( lastParaType.getComponentType(), lastParams ); array.visit(acg);
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); return ret; }
private static OffsetRange getArrayExpressionRange(ArrayExpression expression, BaseDocument doc, int cursorOffset) { return getRange(expression.getElementType(), doc, cursorOffset); }
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);