Refine search
public static ListExpression list2args(List args) { ListExpression result = new ListExpression(); for (Object o : args) { result.addExpression(new ConstantExpression(o)); } return result; }
private static List<String> getValueStringList(ListExpression listExpression) { List<String> list = new ArrayList<String>(); for (Expression itemExpr : listExpression.getExpressions()) { if (itemExpr instanceof ConstantExpression) { Object value = ((ConstantExpression) itemExpr).getValue(); if (value != null) list.add(value.toString()); } } return list; }
private static boolean isUndefinedMarkerList(ListExpression listExpression) { if (listExpression.getExpressions().size() != 1) return false; Expression itemExpr = listExpression.getExpression(0); if (itemExpr == null) return false; if (itemExpr instanceof ConstantExpression) { Object value = ((ConstantExpression) itemExpr).getValue(); if (value instanceof String && isUndefined((String)value)) return true; } else if (itemExpr instanceof ClassExpression && isUndefined(itemExpr.getType())) { return true; } return false; }
@Override @SuppressWarnings("unchecked") public void visitListExpression(ListExpression expr) { ListExpression conversion = new ListExpression( convertAll(expr.getExpressions())); conversion.setSourcePosition(expr); result = record(conversion); }
/** * Given a list of constants, transform each item in the list. * * @param origList the list to transform * @param attrType the target type * @return the transformed list or the original if nothing was changed */ public static Expression transformListOfConstants(ListExpression origList, ClassNode attrType) { ListExpression newList = new ListExpression(); boolean changed = false; for (Expression e : origList.getExpressions()) { try { Expression transformed = transformInlineConstants(e, attrType); newList.addExpression(transformed); if (transformed != e) changed = true; } catch(Exception ignored) { newList.addExpression(e); } } if (changed) { newList.setSourcePosition(origList); return newList; } return origList; }
public static ListExpression classList2args(List<String> args) { ListExpression result = new ListExpression(); for (Object o : args) { result.addExpression(new ClassExpression(ClassHelper.make(o.toString()))); } return result; }
args.addExpression(new ConstantExpression(field.getName())); args.addExpression(new ConstantExpression(value)); if (field.getInitialExpression() == null) { if ((enumClass.getModifiers() & Opcodes.ACC_ABSTRACT) != 0) { ListExpression oldArgs = (ListExpression) field.getInitialExpression(); List<MapEntryExpression> savedMapEntries = new ArrayList<MapEntryExpression>(); for (Expression exp : oldArgs.getExpressions()) { if (exp instanceof MapEntryExpression) { savedMapEntries.add((MapEntryExpression) exp);
private static boolean containsOnlyConstants(ListExpression list) { for (Expression exp : list.getExpressions()) { if (exp instanceof ConstantExpression) continue; return false; } return true; }
ListExpression le = new ListExpression(); le.addExpression(inner); init = le; } else { if (init instanceof ListExpression) { ((ListExpression) init).addExpression(inner); } else { ListExpression le = new ListExpression(); le.addExpression(init); le.addExpression(inner); init = le; if (init instanceof ListExpression && !((ListExpression) init).isWrapped()) { ListExpression le = new ListExpression(); le.addExpression(init); init = le;
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); if (expression instanceof ConstantExpression) { ConstantExpression ce = (ConstantExpression) expression; if (ClassHelper.STRING_TYPE.equals(ce.getType())) { String val = (String) ce.getValue(); if (val!=null && val.length()==1) { ConstantExpression result = new ConstantExpression(val.charAt(0),true); result.setSourcePosition(cast); return result;
public static void addListenerToProperty(SourceUnit source, AnnotationNode annotation, ClassNode declaringClass, FieldNode field) { Expression value = annotation.getMember(VALUE); Expression weak = annotation.getMember("weak"); boolean useWeakListener = false; if (weak != null && weak instanceof ConstantExpression && ((ConstantExpression) weak).isTrueExpression()) { useWeakListener = true; } if ((value instanceof ListExpression)) { for (Expression expr : ((ListExpression) value).getExpressions()) { processExpression(declaringClass, field.getName(), expr, useWeakListener); } annotation.setMember(VALUE, new ConstantExpression(EMPTY_STRING)); } else { processExpression(declaringClass, field.getName(), value, useWeakListener); annotation.setMember(VALUE, new ConstantExpression(EMPTY_STRING)); } }
private AnnotationNode createDataProviderAnnotation(Expression dataProviderExpr, int nextDataVariableIndex) { AnnotationNode ann = new AnnotationNode(resources.getAstNodeCache().DataProviderMetadata); ann.addMember(DataProviderMetadata.LINE, new ConstantExpression(dataProviderExpr.getLineNumber())); List<Expression> dataVariableNames = new ArrayList<>(); for (int i = nextDataVariableIndex; i < dataProcessorVars.size(); i++) dataVariableNames.add(new ConstantExpression(dataProcessorVars.get(i).getName())); ann.addMember(DataProviderMetadata.DATA_VARIABLES, new ListExpression(dataVariableNames)); return ann; }
ListExpression list = new ListExpression(); if (expr instanceof ClassExpression) { list.addExpression(expr); } else if (expr instanceof VariableExpression && searchSourceUnit) { VariableExpression ve = (VariableExpression) expr; ClassExpression found = classX(fromSourceUnit); found.setSourcePosition(ve); list.addExpression(found); } else { addError(BASE_BAD_PARAM_ERROR + "an unresolvable reference to '" + ve.getName() + "'.", expr); final List<Expression> expressions = list.getExpressions(); for (int i = 0; i < expressions.size(); i++) { Expression next = expressions.get(i);
public Expression transformExpression(ExpressionTransformer transformer) { Expression ret = new ListExpression(transformExpressions(getExpressions(), transformer)); ret.setSourcePosition(this); ret.copyNodeMetaData(this); return ret; }
protected Expression expressionList(AST node) { List<Expression> expressionList = new ArrayList<Expression>(); for (AST child = node.getFirstChild(); child != null; child = child.getNextSibling()) { expressionList.add(expression(child)); } if (expressionList.size() == 1) { return expressionList.get(0); } else { ListExpression listExpression = new ListExpression(expressionList); listExpression.setWrapped(true); configureAST(listExpression, node); return listExpression; } }
public void visitListExpression(ListExpression expression) { onLineNumber(expression,"ListExpression" ); int size = expression.getExpressions().size(); boolean containsSpreadExpression = containsSpreadExpression(expression); boolean containsOnlyConstants = !containsSpreadExpression && containsOnlyConstants(expression); mv.visitInsn(DUP); BytecodeHelper.pushConstant(mv, i); expression.getExpression(i).visit(this); operandStack.box(); mv.visitInsn(AASTORE); List<Expression> expressions = expression.getExpressions(); List<String> methods = new ArrayList(); MethodVisitor oldMv = mv; despreadList(expression.getExpressions(), false);
public static ListExpression listX(List<Expression> args) { return new ListExpression(args); }
public ListExpression(List<Expression> expressions) { this.expressions = expressions; //TODO: get the type's of the expressions to specify the // list type to List<X> if possible. setType(ClassHelper.LIST_TYPE); }
public static FieldNode addEnumConstant(ClassNode enumClass, String name, Expression init) { int modifiers = PUBLIC_FS | Opcodes.ACC_ENUM; if (init != null && !(init instanceof ListExpression)) { ListExpression list = new ListExpression(); list.addExpression(init); init = list; } FieldNode fn = new FieldNode(name, modifiers, enumClass.getPlainNodeReference(), enumClass, init); enumClass.addField(fn); return fn; } }
if (rightExpression instanceof ListExpression && lhsType.isArray()) { ListExpression list = (ListExpression) rightExpression; ArrayExpression array = new ArrayExpression(lhsType.getComponentType(), list.getExpressions()); array.setSourcePosition(list); array.visit(acg); MethodCallExpression call = new MethodCallExpression( rhsValueLoader, "getAt", new ArgumentListExpression(new ConstantExpression(i))); call.visit(acg); i++;