@Override @SuppressWarnings("unchecked") public void visitMapExpression(MapExpression expr) { replaceAllExprs(expr.getMapEntryExpressions()); }
private static boolean isEmptyCollection(Expression expr) { return (expr instanceof ListExpression && ((ListExpression) expr).getExpressions().size() == 0) || (expr instanceof MapExpression && ((MapExpression) expr).getMapEntryExpressions().size() == 0); }
public void visitMapExpression(MapExpression expression) { visitListOfExpressions(expression.getMapEntryExpressions()); }
public void visitMapExpression(final MapExpression expression) { assertExpressionAuthorized(expression); visitListOfExpressions(expression.getMapEntryExpressions()); }
@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 Expression transformExpression(ExpressionTransformer transformer) { Expression ret = new MapExpression(transformExpressions(getMapEntryExpressions(), transformer, MapEntryExpression.class)); ret.setSourcePosition(this); ret.copyNodeMetaData(this); return ret; }
@SuppressWarnings("unchecked") private void addNamedArgs(MapExpression args, boolean isMixed) { useNamedArgs(isMixed); for (MapEntryExpression arg : args.getMapEntryExpressions()) { addName(arg.getKeyExpression()); addArg(arg.getValueExpression()); } }
@Override @SuppressWarnings("unchecked") public void visitMapExpression(MapExpression expr) { result = new ExpressionInfo( TextRegion.of(expr), TextPosition.startOf(expr), "[:]", convertAll(expr.getMapEntryExpressions()) ).setRelevant(false); }
private void checkNamedParamsAnnotation(Parameter param, MapExpression args) { if (!param.getType().isDerivedFrom(ClassHelper.MAP_TYPE)) return; List<MapEntryExpression> entryExpressions = args.getMapEntryExpressions(); Map<Object, Expression> entries = new LinkedHashMap<Object, Expression>(); for (MapEntryExpression entry : entryExpressions) {
if (expressions.size() == 1 && expressions.get(0) instanceof MapExpression) { MapExpression map = (MapExpression) expressions.get(0); List<MapEntryExpression> entries = map.getMapEntryExpressions(); if (entries.size() == 1) { MapEntryExpression mapEntry = entries.get(0);
protected ClassNode inferMapExpressionType(final MapExpression map) { ClassNode mapType = LINKEDHASHMAP_CLASSNODE.getPlainNodeReference(); List<MapEntryExpression> entryExpressions = map.getMapEntryExpressions(); if (entryExpressions.isEmpty()) return mapType; GenericsType[] genericsTypes = mapType.getGenericsTypes(); if (genericsTypes == null || genericsTypes.length < 2 || (genericsTypes.length == 2 && OBJECT_TYPE.equals(genericsTypes[0].getType()) && OBJECT_TYPE.equals(genericsTypes[1].getType()))) { List<ClassNode> keyTypes = new LinkedList<ClassNode>(); List<ClassNode> valueTypes = new LinkedList<ClassNode>(); for (MapEntryExpression entryExpression : entryExpressions) { keyTypes.add(getType(entryExpression.getKeyExpression())); valueTypes.add(getType(entryExpression.getValueExpression())); } ClassNode keyType = getWrapper(lowestUpperBound(keyTypes)); // to be used in generics, type must be boxed ClassNode valueType = getWrapper(lowestUpperBound(valueTypes)); // to be used in generics, type must be boxed if (!OBJECT_TYPE.equals(keyType) || !OBJECT_TYPE.equals(valueType)) { ClassNode inferred = mapType.getPlainNodeReference(); inferred.setGenericsTypes(new GenericsType[]{new GenericsType(wrapTypeIfNecessary(keyType)), new GenericsType(wrapTypeIfNecessary(valueType))}); return inferred; } } return mapType; }
public void visitMapExpression(MapExpression expression) { MethodVisitor mv = controller.getMethodVisitor(); List entries = expression.getMapEntryExpressions(); int size = entries.size(); BytecodeHelper.pushConstant(mv, size * 2); mv.visitTypeInsn(ANEWARRAY, "java/lang/Object"); int i = 0; for (Iterator iter = entries.iterator(); iter.hasNext();) { Object object = iter.next(); MapEntryExpression entry = (MapEntryExpression) object; mv.visitInsn(DUP); BytecodeHelper.pushConstant(mv, i++); entry.getKeyExpression().visit(this); controller.getOperandStack().box(); mv.visitInsn(AASTORE); mv.visitInsn(DUP); BytecodeHelper.pushConstant(mv, i++); entry.getValueExpression().visit(this); controller.getOperandStack().box(); mv.visitInsn(AASTORE); controller.getOperandStack().remove(2); } createMapMethod.call(mv); controller.getOperandStack().push(ClassHelper.MAP_TYPE); }
protected void checkGroovyConstructorMap(final Expression receiver, final ClassNode receiverType, final MapExpression mapExpression) { // workaround for map-style checks putting setter info on wrong AST nodes typeCheckingContext.pushEnclosingBinaryExpression(null); for (MapEntryExpression entryExpression : mapExpression.getMapEntryExpressions()) { Expression keyExpr = entryExpression.getKeyExpression(); if (!(keyExpr instanceof ConstantExpression)) { addStaticTypeError("Dynamic keys in map-style constructors are unsupported in static type checking", keyExpr); } else { AtomicReference<ClassNode> lookup = new AtomicReference<ClassNode>(); PropertyExpression pexp = new PropertyExpression(varX("_", receiverType), keyExpr.getText()); boolean hasProperty = existsProperty(pexp, false, new PropertyLookupVisitor(lookup)); if (!hasProperty) { addStaticTypeError("No such property: " + keyExpr.getText() + " for class: " + receiverType.getName(), receiver); } else { ClassNode valueType = getType(entryExpression.getValueExpression()); MethodNode setter = receiverType.getSetterMethod("set" + MetaClassHelper.capitalize(pexp.getPropertyAsString()), false); ClassNode toBeAssignedTo = setter == null ? lookup.get() : setter.getParameters()[0].getType(); if (!isAssignableTo(valueType, toBeAssignedTo) && !extension.handleIncompatibleAssignment(toBeAssignedTo, valueType, entryExpression)) { addAssignmentError(toBeAssignedTo, valueType, entryExpression); } } } } typeCheckingContext.popEnclosingBinaryExpression(); }
for (MapEntryExpression entryExpression : map.getMapEntryExpressions()) { int line = entryExpression.getLineNumber(); int col = entryExpression.getColumnNumber();
@Override public void visitMapExpression(MapExpression expression) { visitListOfExpressions(expression.getMapEntryExpressions()); }
@Override @SuppressWarnings("unchecked") public void visitMapExpression(MapExpression expr) { replaceAllExprs(expr.getMapEntryExpressions()); }
public void visitMapExpression(final MapExpression expression) { assertExpressionAuthorized(expression); visitListOfExpressions(expression.getMapEntryExpressions()); }
public Expression transformExpression(ExpressionTransformer transformer) { Expression ret = new MapExpression(transformExpressions(getMapEntryExpressions(), transformer, MapEntryExpression.class)); ret.setSourcePosition(this); return ret; }
private static void populatePropertiesForInitialExpression(Map<String, ClassNode> cachedProperties, Expression initialExpression) { if (initialExpression instanceof MapExpression) { MapExpression me = (MapExpression) initialExpression; List<MapEntryExpression> mapEntryExpressions = me.getMapEntryExpressions(); for (MapEntryExpression mapEntryExpression : mapEntryExpressions) { Expression keyExpression = mapEntryExpression.getKeyExpression(); Expression valueExpression = mapEntryExpression.getValueExpression(); if (valueExpression instanceof ClassExpression) { cachedProperties.put(keyExpression.getText(), valueExpression.getType()); } } } }
public Expression transformExpression(ExpressionTransformer transformer) { Expression ret = new MapExpression(transformExpressions(getMapEntryExpressions(), transformer)); ret.setSourcePosition(this); return ret; }