@Override @SuppressWarnings("unchecked") public void visitMapExpression(MapExpression expr) { replaceAllExprs(expr.getMapEntryExpressions()); }
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 MapExpression(List<MapEntryExpression> mapEntryExpressions) { this.mapEntryExpressions = mapEntryExpressions; //TODO: get the type's of the expressions to specify the // map type to Map<X> if possible. setType(ClassHelper.MAP_TYPE); }
public Expression transformExpression(ExpressionTransformer transformer) { Expression ret = new MapExpression(transformExpressions(getMapEntryExpressions(), transformer, MapEntryExpression.class)); ret.setSourcePosition(this); ret.copyNodeMetaData(this); return ret; }
@Override @SuppressWarnings("unchecked") public void visitMapExpression(MapExpression expr) { boolean namedArgumentListExpr = expr instanceof NamedArgumentListExpression; MapExpression conversion = namedArgumentListExpr ? new NamedArgumentListExpression( (List) convertAll(expr.getMapEntryExpressions())) : new MapExpression( (List) convertAll(expr.getMapEntryExpressions())); conversion.setSourcePosition(expr); result = namedArgumentListExpr ? recordNa(conversion) : record(conversion); }
public static MapExpression mapX(List<MapEntryExpression> expressions) { return new MapExpression(expressions); }
final MapExpression me = new MapExpression(); for (Expression expression : list.getExpressions()) { me.addMapEntryExpression((MapEntryExpression) transform(expression)); me.setSourcePosition(list); final CastExpression ce = new CastExpression(left.getType(), me); ce.setCoerce(true); final MapExpression me = new MapExpression(); me.addMapEntryExpression((MapEntryExpression) transform(be.getRightExpression())); me.setSourcePosition(be.getRightExpression()); final CastExpression ce = new CastExpression(left.getType(), me); ce.setSourcePosition(be);
@Override @Nonnull public MethodCallExpression transformStep(@Nonnull ModelASTStep step, @Nonnull MethodCallExpression methodCall) { if (step.getName().equals("timeout")) { ArgumentListExpression newArgs = new ArgumentListExpression(); TupleExpression oldArgs = (TupleExpression)methodCall.getArguments(); for (Expression expr : oldArgs.getExpressions()) { if (expr instanceof MapExpression) { MapExpression originalMap = (MapExpression) expr; MapExpression newMap = new MapExpression(); for (MapEntryExpression origEntry : originalMap.getMapEntryExpressions()) { if (origEntry.getKeyExpression() instanceof ConstantExpression && ((ConstantExpression) origEntry.getKeyExpression()).getValue().equals("time")) { newMap.addMapEntryExpression(constX("time"), constX(10)); } else { newMap.addMapEntryExpression(origEntry); } } newArgs.addExpression(newMap); } else { newArgs.addExpression(expr); } } methodCall.setArguments(newArgs); } return methodCall; } }
public void addMapEntryExpression(Expression keyExpression, Expression valueExpression) { addMapEntryExpression(new MapEntryExpression(keyExpression, valueExpression)); }
@Override public void visitMapExpression(final MapExpression exp) { if (exp.getMapEntryExpressions().size() > 125) { sourceUnit.addError(new SyntaxException("Map expressions can only contain up to 125 entries", exp.getLineNumber(), exp.getColumnNumber())); } else { makeNode("map", new Runnable() { @Override public void run() { for (MapEntryExpression e : exp.getMapEntryExpressions()) { visit(e.getKeyExpression()); visit(e.getValueExpression()); } } }); } }
throw new ASTRuntimeException(node, "\n\"" + ((MethodCallExpression) leftExpression).getText() + "\" is a method call expression, but it should be a variable expression"); } else if (leftExpression instanceof MapExpression) { throw new ASTRuntimeException(node, "\n'" + ((MapExpression) leftExpression).getText() + "' is a map expression, but it should be a variable expression"); } else { throw new ASTRuntimeException(node, "\n" + leftExpression.getClass() + ", with its value '" + leftExpression.getText() + "', is a bad expression as the left hand side of an assignment operator");
public Expression transformExpression(ExpressionTransformer transformer) { Expression ret = new MapExpression(transformExpressions(getMapEntryExpressions(), transformer, MapEntryExpression.class)); ret.setSourcePosition(this); return ret; }
private static void createNoArgConstructor(ClassNode cNode, int modifiers) { Statement body = stmt(ctorX(ClassNode.THIS, args(new MapExpression()))); ConstructorNode consNode = new ConstructorNode(modifiers, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, body); markAsGenerated(cNode, consNode); cNode.addConstructor(consNode); }
final MapExpression me = new MapExpression(); for (Expression expression : list.getExpressions()) { me.addMapEntryExpression((MapEntryExpression) transform(expression)); me.setSourcePosition(list); final CastExpression ce = new CastExpression(left.getType(), me); ce.setSourcePosition(be); final MapExpression me = new MapExpression(); me.addMapEntryExpression((MapEntryExpression) transform(be.getRightExpression())); me.setSourcePosition(be.getRightExpression()); final CastExpression ce = new CastExpression(left.getType(), me); ce.setSourcePosition(be);
public void addMapEntryExpression(Expression keyExpression, Expression valueExpression) { addMapEntryExpression(new MapEntryExpression(keyExpression, valueExpression)); }
throw new ASTRuntimeException(node, "\n\"" + ((MethodCallExpression) leftExpression).getText() + "\" is a method call expression, but it should be a variable expression"); } else if (leftExpression instanceof MapExpression) { throw new ASTRuntimeException(node, "\n'" + ((MapExpression) leftExpression).getText() + "' is a map expression, but it should be a variable expression"); } else { throw new ASTRuntimeException(node, "\n" + leftExpression.getClass() + ", with its value '" + leftExpression.getText() + "', is a bad expression as the left hand side of an assignment operator");
private static void addGrabResolverAsStaticInitIfNeeded(ClassNode grapeClassNode, AnnotationNode node, List<Statement> grabResolverInitializers, Map<String, Object> grabResolverMap) { if ((node.getMember("initClass") == null) || (node.getMember("initClass") == ConstantExpression.TRUE)) { MapExpression resolverArgs = new MapExpression(); for (Map.Entry<String, Object> next : grabResolverMap.entrySet()) { resolverArgs.addMapEntryExpression(constX(next.getKey()), constX(next.getValue())); } grabResolverInitializers.add(stmt(callX(grapeClassNode, "addResolver", args(resolverArgs)))); } }
private static boolean isEmptyCollection(Expression expr) { return (expr instanceof ListExpression && ((ListExpression) expr).getExpressions().size() == 0) || (expr instanceof MapExpression && ((MapExpression) expr).getMapEntryExpressions().size() == 0); }
public Expression transformExpression(ExpressionTransformer transformer) { Expression ret = new MapExpression(transformExpressions(getMapEntryExpressions(), transformer)); ret.setSourcePosition(this); return ret; }
/** * Typically only used for map constructors I think? */ protected Expression mapExpression(AST mapNode) { List expressions = new ArrayList(); AST elist = mapNode.getFirstChild(); if (elist != null) { // totally empty in the case of [:] assertNodeType(ELIST, elist); for (AST node = elist.getFirstChild(); node != null; node = node.getNextSibling()) { switch (node.getType()) { case LABELED_ARG: case SPREAD_MAP_ARG: break; // legal cases case SPREAD_ARG: assertNodeType(SPREAD_MAP_ARG, node); break; // helpful error default: assertNodeType(LABELED_ARG, node); break; // helpful error } expressions.add(mapEntryExpression(node)); } } MapExpression mapExpression = new MapExpression(expressions); configureAST(mapExpression, mapNode); return mapExpression; }