private static void checkDuplicateNamedParams(AST elist, List expressionList) { if (expressionList.isEmpty()) return; Set<String> namedArgumentNames = new HashSet<String>(); for (Object expression : expressionList) { MapEntryExpression meExp = (MapEntryExpression) expression; if (meExp.getKeyExpression() instanceof ConstantExpression) { String argName = meExp.getKeyExpression().getText(); if (!namedArgumentNames.contains(argName)) { namedArgumentNames.add(argName); } else { throw new ASTRuntimeException(elist, "Duplicate named parameter '" + argName + "' found."); } } } }
public String getText() { StringBuilder sb = new StringBuilder(32); sb.append("["); int size = mapEntryExpressions.size(); MapEntryExpression mapEntryExpression = null; if (size > 0) { mapEntryExpression = mapEntryExpressions.get(0); sb.append(mapEntryExpression.getKeyExpression().getText()).append(":").append(mapEntryExpression.getValueExpression().getText()); for (int i = 1; i < size; i++) { mapEntryExpression = mapEntryExpressions.get(i); sb.append(", ").append(mapEntryExpression.getKeyExpression().getText()).append(":").append(mapEntryExpression.getValueExpression().getText()); if (sb.length() > 120 && i < size - 1) { sb.append(", ... "); break; } } } else { sb.append(":"); } sb.append("]"); return sb.toString(); }
public void visitMapEntryExpression(MapEntryExpression expression) { expression.getKeyExpression().visit(this); expression.getValueExpression().visit(this); }
public void visitMapEntryExpression(final MapEntryExpression expression) { assertExpressionAuthorized(expression); expression.getKeyExpression().visit(this); expression.getValueExpression().visit(this); }
@SuppressWarnings("unchecked") private void addNamedArgs(MapExpression args, boolean isMixed) { useNamedArgs(isMixed); for (MapEntryExpression arg : args.getMapEntryExpressions()) { addName(arg.getKeyExpression()); addArg(arg.getValueExpression()); } }
Map<Object, Expression> entries = new LinkedHashMap<Object, Expression>(); for (MapEntryExpression entry : entryExpressions) { Object key = entry.getKeyExpression(); if (key instanceof ConstantExpression) { key = ((ConstantExpression) key).getValue();
@Override public void visitMapEntryExpression(MapEntryExpression expr) { MapEntryExpression conversion = new MapEntryExpression( convert(expr.getKeyExpression()), convert(expr.getValueExpression())); conversion.setSourcePosition(expr); result = recordNa(conversion); }
@Override public void visitMapEntryExpression(MapEntryExpression expr) { result = new ExpressionInfo( TextRegion.of(expr), startOf(":", expr.getValueExpression()), null, convert(expr.getKeyExpression()), convert(expr.getValueExpression()) ); }
@Override public void visitMapEntryExpression(MapEntryExpression expr) { MapEntryExpression result = new MapEntryExpression( replaceExpr(expr.getKeyExpression()), replaceExpr(expr.getValueExpression()) ); result.setType(expr.getType()); result.setSourcePosition(expr); replaceVisitedExpressionWith(result); }
if (entries.size() == 1) { MapEntryExpression mapEntry = entries.get(0); Expression keyExpression = mapEntry.getKeyExpression(); try { IncludeType includeType = IncludeType.valueOf(keyExpression.getText().toLowerCase());
private Expression transformMapEntryExpression(MapEntryExpression me, ClassNode constructorCallType) { Expression key = me.getKeyExpression(); Expression value = me.getValueExpression(); ModuleNode module = currentClass.getModule(); if (module != null && key instanceof ConstantExpression) { Map<String, ImportNode> importNodes = module.getStaticImports(); if (importNodes.containsKey(key.getText())) { ImportNode importNode = importNodes.get(key.getText()); if (importNode.getType().equals(constructorCallType)) { String newKey = importNode.getFieldName(); return new MapEntryExpression(new ConstantExpression(newKey), value.transformExpression(this)); } } } return me; }
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(); }
int line = entryExpression.getLineNumber(); int col = entryExpression.getColumnNumber(); Expression keyExpression = staticCompilationTransformer.transform(entryExpression.getKeyExpression()); Expression valueExpression = staticCompilationTransformer.transform(entryExpression.getValueExpression()); BinaryExpression bexp = new BinaryExpression(new PropertyExpression(new BytecodeExpression() {
@Override public void visitMapEntryExpression(MapEntryExpression expression) { children.add(expression.getKeyExpression()); children.add(expression.getValueExpression()); }
private boolean isParameterPrefix(NamedArgumentListExpression namedArgsExpression, String name) { List<MapEntryExpression> namedArgs = namedArgsExpression.getMapEntryExpressions(); for (MapEntryExpression namedEntry : namedArgs) { String namedArgument = namedEntry.getKeyExpression().getText(); if (namedArgument != null && name.startsWith(namedArgument)) { return true; } } return false; } }
public void visitMapEntryExpression(MapEntryExpression expression) { expression.getKeyExpression().visit(this); expression.getValueExpression().visit(this); }
public void visitMapEntryExpression(final MapEntryExpression expression) { assertExpressionAuthorized(expression); expression.getKeyExpression().visit(this); expression.getValueExpression().visit(this); }
@Override public void visitMapEntryExpression(MapEntryExpression expr) { MapEntryExpression result = new MapEntryExpression( replaceExpr(expr.getKeyExpression()), replaceExpr(expr.getValueExpression()) ); result.setType(expr.getType()); result.setSourcePosition(expr); replaceVisitedExpressionWith(result); }