private static boolean containsOnlyConstants(ListExpression list) { for (Expression exp : list.getExpressions()) { if (exp instanceof ConstantExpression) continue; return false; } return true; }
private boolean hasClassesToNewify() { return (classesToNewify != null && !classesToNewify.getExpressions().isEmpty()) || (classNamePattern != null); }
@Override @SuppressWarnings("unchecked") public void visitListExpression(ListExpression expr) { replaceAllExprs(expr.getExpressions()); }
private List<Expression> transformArguments(final ListExpression expr) { List<Expression> expressions = expr.getExpressions(); List<Expression> transformedArgs = new LinkedList<Expression>(); for (Expression expression : expressions) { transformedArgs.add(transformer.transform(expression)); } return transformedArgs; } }
private static List<ClassNode> getTypeList(ListExpression listExpression) { List<ClassNode> list = new ArrayList<ClassNode>(); for (Expression itemExpr : listExpression.getExpressions()) { if (itemExpr instanceof ClassExpression) { ClassNode cn = itemExpr.getType(); if (cn != null) list.add(cn); } } return list; }
protected void visitListExpression(String attrName, ListExpression listExpr, ClassNode elementType) { for (Expression expression : listExpr.getExpressions()) { visitExpression(attrName, expression, elementType); } }
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 isEmptyCollection(Expression expr) { return (expr instanceof ListExpression && ((ListExpression) expr).getExpressions().size() == 0) || (expr instanceof MapExpression && ((MapExpression) expr).getMapEntryExpressions().size() == 0); }
private static List<groovy.transform.PackageScopeTarget> determineTargets(Expression expr) { List<groovy.transform.PackageScopeTarget> list = new ArrayList<groovy.transform.PackageScopeTarget>(); if (expr instanceof PropertyExpression) { list.add(extractTarget((PropertyExpression) expr)); } else if (expr instanceof ListExpression) { final ListExpression expressionList = (ListExpression) expr; final List<Expression> expressions = expressionList.getExpressions(); for (Expression ex : expressions) { if (ex instanceof PropertyExpression) { list.add(extractTarget((PropertyExpression) ex)); } } } return list; }
private void checkDuplicateNameClashes(ListExpression list) { final Set<String> seen = new HashSet<String>(); @SuppressWarnings("unchecked") final List<ClassExpression> classes = (List) list.getExpressions(); for (ClassExpression ce : classes) { final String name = ce.getType().getNameWithoutPackage(); if (seen.contains(name)) { addError("Duplicate name '" + name + "' found during @" + MY_NAME + " processing.", ce); } seen.add(name); } }
private void visitArrayAttributes(AnnotationNode an, Map<String, ListExpression> arrayAttr, AnnotationVisitor av) { if (arrayAttr.isEmpty()) return; for (Map.Entry entry : arrayAttr.entrySet()) { AnnotationVisitor av2 = av.visitArray((String) entry.getKey()); List<Expression> values = ((ListExpression) entry.getValue()).getExpressions(); if (!values.isEmpty()) { int arrayElementType = determineCommonArrayType(values); for (Expression exprChild : values) { visitAnnotationArrayElement(exprChild, arrayElementType, av2); } } av2.visitEnd(); } }
public void visitListExpression(ListExpression expression) { for (Expression element : expression.getExpressions()) { if (element instanceof MapEntryExpression) { throw new RuntimeParserException("No map entry allowed at this place", element); } } super.visitListExpression(expression); }
public void visitListExpression(final ListExpression expression) { assertExpressionAuthorized(expression); visitListOfExpressions(expression.getExpressions()); }
@Override @SuppressWarnings("unchecked") public void visitListExpression(ListExpression expr) { ListExpression conversion = new ListExpression( convertAll(expr.getExpressions())); conversion.setSourcePosition(expr); result = record(conversion); }
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; }
private void checkClassLevelClashes(ListExpression list) { @SuppressWarnings("unchecked") final List<ClassExpression> classes = (List) list.getExpressions(); for (ClassExpression ce : classes) { final String name = ce.getType().getNameWithoutPackage(); if (findClassWithMatchingBasename(name)) { addError("Error during @" + MY_NAME + " processing. Class '" + name + "' can't appear at " + "method/constructor/field level if it already appears at the class level.", ce); } } }
public Expression transformExpression(ExpressionTransformer transformer) { Expression ret = new ListExpression(transformExpressions(getExpressions(), transformer)); ret.setSourcePosition(this); ret.copyNodeMetaData(this); return ret; }
@Override @SuppressWarnings("unchecked") public void visitListExpression(ListExpression expr) { result = new ExpressionInfo( TextRegion.of(expr), TextPosition.startOf(expr), "[]", convertAll(expr.getExpressions()) ).setRelevant(false); }
protected void addTypeCheckingExtensions(StaticTypeCheckingVisitor visitor, Expression extensions) { if (extensions instanceof ConstantExpression) { visitor.addTypeCheckingExtension(new GroovyTypeCheckingExtensionSupport( visitor, extensions.getText(), compilationUnit )); } else if (extensions instanceof ListExpression) { ListExpression list = (ListExpression) extensions; for (Expression ext : list.getExpressions()) { addTypeCheckingExtensions(visitor, ext); } } }
private void checkAnnotationMemberValue(Expression newValue) { if (newValue instanceof PropertyExpression) { PropertyExpression pe = (PropertyExpression) newValue; if (!(pe.getObjectExpression() instanceof ClassExpression)) { addError("unable to find class '" + pe.getText() + "' for annotation attribute constant", pe.getObjectExpression()); } } else if (newValue instanceof ListExpression) { ListExpression le = (ListExpression) newValue; for (Expression e : le.getExpressions()) { checkAnnotationMemberValue(e); } } }