public void addMapEntryExpression(Expression keyExpression, Expression valueExpression) { addMapEntryExpression(new MapEntryExpression(keyExpression, valueExpression)); }
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); } }
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)))); } }
MapExpression basicArgs = new MapExpression(); if (autoDownload != null) { basicArgs.addMapEntryExpression(constX(AUTO_DOWNLOAD_SETTING), constX(autoDownload)); basicArgs.addMapEntryExpression(constX(DISABLE_CHECKSUMS_SETTING), constX(disableChecksums)); MapExpression inner = new MapExpression(); for (Map.Entry<String, Object> entry : entries) { inner.addMapEntryExpression(constX(entry.getKey()), constX(entry.getValue())); basicArgs.addMapEntryExpression(constX("excludes"), list); dependencyArg.addMapEntryExpression(constX(s), constX(grabMap.get(s))); dependencyArg.addMapEntryExpression(constX(s), constX(grabMap.get(s)));
public void testIterateOverMap() throws Exception { MapExpression mapExpression = new MapExpression(); mapExpression.addMapEntryExpression(new ConstantExpression("a"), new ConstantExpression("x")); mapExpression.addMapEntryExpression(new ConstantExpression("b"), new ConstantExpression("y")); mapExpression.addMapEntryExpression(new ConstantExpression("c"), new ConstantExpression("z")); assertIterate("iterateOverMap", mapExpression); }
final MapExpression me = new MapExpression(); for (Expression expression : list.getExpressions()) { me.addMapEntryExpression((MapEntryExpression) transform(expression)); me.addMapEntryExpression((MapEntryExpression) transform(be.getRightExpression())); me.setSourcePosition(be.getRightExpression()); final CastExpression ce = new CastExpression(left.getType(), me);
public static MapExpression mapx(MapEntryExpression... entries) { MapExpression map = new MapExpression(); for (MapEntryExpression entry : entries) { map.addMapEntryExpression(entry); } return map; } }
public void addMapEntryExpression(Expression keyExpression, Expression valueExpression) { addMapEntryExpression(new MapEntryExpression(keyExpression, valueExpression)); }
public void addMapEntryExpression(Expression keyExpression, Expression valueExpression) { addMapEntryExpression(new MapEntryExpression(keyExpression, valueExpression)); }
public void addMapEntryExpression(Expression keyExpression, Expression valueExpression) { addMapEntryExpression(new MapEntryExpression(keyExpression, valueExpression)); }
public void addMapEntryExpression(Expression keyExpression, Expression valueExpression) { addMapEntryExpression(new MapEntryExpression(keyExpression, valueExpression)); }
me.addMapEntryExpression(new ConstantExpression(s),node.getMember(s)); me.addMapEntryExpression(new ConstantExpression(s),node.getMember(s)); MapExpression inner = new MapExpression(); for (Map.Entry<String, Object> entry : entries) { inner.addMapEntryExpression(new ConstantExpression(entry.getKey()), new ConstantExpression(entry.getValue())); args.addMapEntryExpression(new ConstantExpression("excludes"), list); grabArgs = new ArgumentListExpression(args, me);
newParallelMap.addMapEntryExpression(constX(b.getName()), closureX(handleBranch(b)));
@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; } }
protected FieldNode addTestRuntimeAwareMixinFieldIfNonExistent(ClassNode classNode, ClassNode fieldType, String fieldName) { if (classNode == null || classNode.getField(fieldName) != null) { return null; } MapExpression constructorArguments = new MapExpression(); constructorArguments.addMapEntryExpression(new MapEntryExpression(new ConstantExpression("testClass"), new ClassExpression(classNode))); FieldNode mixinInstanceFieldNode = classNode.addField(fieldName, Modifier.STATIC, fieldType, new ConstructorCallExpression(fieldType, constructorArguments)); mixinInstanceFieldNode.addAnnotation(new AnnotationNode(ClassHelper.make(MixinInstance.class))); addJunitRuleFields(classNode); return mixinInstanceFieldNode; }
static protected FieldNode addLegacyMixinFieldIfNonExistent(ClassNode classNode, ClassNode fieldType, String fieldName) { ClassNode targetAwareInterface = GrailsASTUtils.findInterface(fieldType, new ClassNode(TestMixinTargetAware.class).getPlainNodeReference()); if (classNode != null && classNode.getField(fieldName) == null) { Expression constructorArgument = new ArgumentListExpression(); if(targetAwareInterface != null) { MapExpression namedArguments = new MapExpression(); namedArguments.addMapEntryExpression(new MapEntryExpression(new ConstantExpression("target"), new VariableExpression("this"))); constructorArgument = namedArguments; } return classNode.addField(fieldName, Modifier.PRIVATE, fieldType, new ConstructorCallExpression(fieldType, constructorArgument)); } return null; }
private void createConstructorOrdered(ClassNode cNode, List<PropertyNode> list) { final MapExpression argMap = new MapExpression(); final Parameter[] orderedParams = new Parameter[list.size()]; int index = 0; for (PropertyNode pNode : list) { Parameter param = new Parameter(pNode.getField().getType(), pNode.getField().getName()); orderedParams[index++] = param; argMap.addMapEntryExpression(new ConstantExpression(pNode.getName()), new VariableExpression(pNode.getName())); } final BlockStatement orderedBody = new BlockStatement(); orderedBody.addStatement(new ExpressionStatement( new ConstructorCallExpression(ClassNode.THIS, new ArgumentListExpression(new CastExpression(HASHMAP_TYPE, argMap))) )); cNode.addConstructor(new ConstructorNode(ACC_PUBLIC, orderedParams, ClassNode.EMPTY_ARRAY, orderedBody)); }
private void createConstructorOrdered(ClassNode cNode, FieldExpression constructorStyle, List<PropertyNode> list) { final MapExpression argMap = new MapExpression(); final Parameter[] orderedParams = new Parameter[list.size()]; int index = 0; for (PropertyNode pNode : list) { orderedParams[index++] = new Parameter(pNode.getField().getType(), pNode.getField().getName()); argMap.addMapEntryExpression(new ConstantExpression(pNode.getName()), new VariableExpression(pNode.getName())); } final BlockStatement orderedBody = new BlockStatement(); orderedBody.addStatement(new ExpressionStatement( new ConstructorCallExpression(ClassNode.THIS, new ArgumentListExpression(new CastExpression(HASHMAP_TYPE, argMap))) )); orderedBody.addStatement(assignStatement(constructorStyle, ConstantExpression.FALSE)); cNode.addConstructor(new ConstructorNode(ACC_PUBLIC, orderedParams, ClassNode.EMPTY_ARRAY, orderedBody)); }
private void createConstructorOrdered(ClassNode cNode, FieldExpression constructorStyle, List<PropertyNode> list) { final MapExpression argMap = new MapExpression(); final Parameter[] orderedParams = new Parameter[list.size()]; int index = 0; for (PropertyNode pNode : list) { orderedParams[index++] = new Parameter(pNode.getField().getType(), pNode.getField().getName()); argMap.addMapEntryExpression(new ConstantExpression(pNode.getName()), new VariableExpression(pNode.getName())); } final BlockStatement orderedBody = new BlockStatement(); orderedBody.addStatement(new ExpressionStatement( new ConstructorCallExpression(ClassNode.THIS, new ArgumentListExpression(new CastExpression(HASHMAP_TYPE, argMap))) )); orderedBody.addStatement(assignStatement(constructorStyle, ConstantExpression.FALSE)); cNode.addConstructor(new ConstructorNode(ACC_PUBLIC, orderedParams, ClassNode.EMPTY_ARRAY, orderedBody)); }
final MapExpression me = new MapExpression(); for (Expression expression : list.getExpressions()) { me.addMapEntryExpression((MapEntryExpression) transform(expression)); me.addMapEntryExpression((MapEntryExpression) transform(be.getRightExpression())); me.setSourcePosition(be.getRightExpression()); final CastExpression ce = new CastExpression(left.getType(), me);