import org.codehaus.groovy.ast.expr.ListExpression; //导入依赖的package包/类
private List<ConstantExpression> getConstantExpressions(
		ListExpression valueExpression) {
	List<ConstantExpression> expressions = new ArrayList<ConstantExpression>();
	for (Expression expression : valueExpression.getExpressions()) {
		if (expression instanceof ConstantExpression
				&& ((ConstantExpression) expression).getValue() instanceof String) {
			expressions.add((ConstantExpression) expression);
		}
		else {
			reportError(
					"Each entry in the array must be an " + "inline string constant",
					expression);
		}
	}
	return expressions;
}
 

import org.codehaus.groovy.ast.expr.ListExpression; //导入依赖的package包/类
private List<String> getValue() {
	Expression expression = findAnnotation().getMember("value");
	if (expression instanceof ListExpression) {
		List<String> list = new ArrayList<String>();
		for (Expression ex : ((ListExpression) expression).getExpressions()) {
			list.add((String) ((ConstantExpression) ex).getValue());
		}
		return list;
	}
	else if (expression == null) {
		return null;
	}
	else {
		throw new IllegalStateException("Member 'value' is not a ListExpression");
	}
}
 

import org.codehaus.groovy.ast.expr.ListExpression; //导入依赖的package包/类
private Expression transformInlineConstants(Expression exp) {
    if (exp instanceof PropertyExpression) {
        PropertyExpression pe = (PropertyExpression) exp;
        if (pe.getObjectExpression() instanceof ClassExpression) {
            ClassExpression ce = (ClassExpression) pe.getObjectExpression();
            ClassNode type = ce.getType();
            if (type.isEnum()) return exp;
            Expression constant = findConstant(getField(type, pe.getPropertyAsString()));
            if (constant != null) return constant;
        }
    } else if (exp instanceof ListExpression) {
        ListExpression le = (ListExpression) exp;
        ListExpression result = new ListExpression();
        for (Expression e : le.getExpressions()) {
            result.addExpression(transformInlineConstants(e));
        }
        return result;
    }

    return exp;
}
 

import org.codehaus.groovy.ast.expr.ListExpression; //导入依赖的package包/类
private Expression serialize(Expression e) {
    if (e instanceof AnnotationConstantExpression) {
        AnnotationConstantExpression ace = (AnnotationConstantExpression) e;
        return serialize((AnnotationNode) ace.getValue());
    } else if (e instanceof ListExpression) {
        boolean annotationConstant = false;
        ListExpression le = (ListExpression) e;
        List<Expression> list = le.getExpressions();
        List<Expression> newList = new ArrayList<Expression>(list.size());
        for (Expression exp: list) {
            annotationConstant = annotationConstant || exp instanceof AnnotationConstantExpression;
            newList.add(serialize(exp));
        }
        ClassNode type = ClassHelper.OBJECT_TYPE;
        if (annotationConstant) type = type.makeArray();
        return new ArrayExpression(type, newList);
    }
    return e;
}
 

import org.codehaus.groovy.ast.expr.ListExpression; //导入依赖的package包/类
private List<AnnotationNode> getTargetListFromValue(AnnotationNode collector, AnnotationNode aliasAnnotationUsage, SourceUnit source) {
    Expression memberValue = collector.getMember("value");
    if (memberValue == null) {
        return Collections.emptyList();
    }
    if (!(memberValue instanceof ListExpression)) {
        addError("Annotation collector expected a list of classes, but got a "+memberValue.getClass(), collector, source);
        return Collections.emptyList();
    }
    ListExpression memberListExp = (ListExpression) memberValue;
    List<Expression> memberList = memberListExp.getExpressions();
    if (memberList.isEmpty()) {
        return Collections.emptyList();
    }
    List<AnnotationNode> ret = new ArrayList<AnnotationNode>();
    for (Expression e : memberList) {
        AnnotationNode toAdd = new AnnotationNode(e.getType());
        toAdd.setSourcePosition(aliasAnnotationUsage);
        ret.add(toAdd);
    }
    return ret;
}
 

import org.codehaus.groovy.ast.expr.ListExpression; //导入依赖的package包/类
public static List<String> getMemberStringList(AnnotationNode anno, String name) {
    Expression expr = anno.getMember(name);
    if (expr == null) {
        return null;
    }
    if (expr instanceof ListExpression) {
        List<String> list = new ArrayList<String>();
        final ListExpression listExpression = (ListExpression) expr;
        if (isUndefinedMarkerList(listExpression)) {
            return null;
        }
        for (Expression itemExpr : listExpression.getExpressions()) {
            if (itemExpr != null && itemExpr instanceof ConstantExpression) {
                Object value = ((ConstantExpression) itemExpr).getValue();
                if (value != null) list.add(value.toString());
            }
        }
        return list;
    }
    return tokenize(getMemberStringValue(anno, name));
}
 

import org.codehaus.groovy.ast.expr.ListExpression; //导入依赖的package包/类
@Deprecated
public List<String> getMemberList(AnnotationNode anno, String name) {
    List<String> list;
    Expression expr = anno.getMember(name);
    if (expr != null && expr instanceof ListExpression) {
        list = new ArrayList<String>();
        final ListExpression listExpression = (ListExpression) expr;
        for (Expression itemExpr : listExpression.getExpressions()) {
            if (itemExpr != null && itemExpr instanceof ConstantExpression) {
                Object value = ((ConstantExpression) itemExpr).getValue();
                if (value != null) list.add(value.toString());
            }
        }
    } else {
        list = tokenize(getMemberStringValue(anno, name));
    }
    return list;
}
 

import org.codehaus.groovy.ast.expr.ListExpression; //导入依赖的package包/类
private static String[] convertToStringArray(final Expression options) {
    if (options==null) {
        return EMPTY_STRING_ARRAY;
    }
    if (options instanceof ConstantExpression) {
        return new String[] { options.getText() };
    }
    if (options instanceof ListExpression) {
        List<Expression> list = ((ListExpression) options).getExpressions();
        List<String> result = new ArrayList<String>(list.size());
        for (Expression expression : list) {
            result.add(expression.getText());
        }
        return result.toArray(new String[result.size()]);
    }
    throw new IllegalArgumentException("Unexpected options for @ClosureParams:"+options);
}
 

import org.codehaus.groovy.ast.expr.ListExpression; //导入依赖的package包/类
private List<String> getKnownImmutableClasses(AnnotationNode node) {
    final List<String> immutableClasses = new ArrayList<String>();

    final Expression expression = node.getMember(MEMBER_KNOWN_IMMUTABLE_CLASSES);
    if (expression == null) return immutableClasses;

    if (!(expression instanceof ListExpression)) {
        addError("Use the Groovy list notation [el1, el2] to specify known immutable classes via \"" + MEMBER_KNOWN_IMMUTABLE_CLASSES + "\"", node);
        return immutableClasses;
    }

    final ListExpression listExpression = (ListExpression) expression;
    for (Expression listItemExpression : listExpression.getExpressions()) {
        if (listItemExpression instanceof ClassExpression) {
            immutableClasses.add(listItemExpression.getType().getName());
        }
    }

    return immutableClasses;
}
 

import org.codehaus.groovy.ast.expr.ListExpression; //导入依赖的package包/类
private List<String> getKnownImmutables(AnnotationNode node) {
    final List<String> immutables = new ArrayList<String>();

    final Expression expression = node.getMember(MEMBER_KNOWN_IMMUTABLES);
    if (expression == null) return immutables;

    if (!(expression instanceof ListExpression)) {
        addError("Use the Groovy list notation [el1, el2] to specify known immutable property names via \"" + MEMBER_KNOWN_IMMUTABLES + "\"", node);
        return immutables;
    }

    final ListExpression listExpression = (ListExpression) expression;
    for (Expression listItemExpression : listExpression.getExpressions()) {
        if (listItemExpression instanceof ConstantExpression) {
            immutables.add((String) ((ConstantExpression) listItemExpression).getValue());
        }
    }

    return immutables;
}
 

import org.codehaus.groovy.ast.expr.ListExpression; //导入依赖的package包/类
protected Expression indexExpression(AST indexNode) {
    AST bracket = indexNode.getFirstChild();
    AST leftNode = bracket.getNextSibling();
    Expression leftExpression = expression(leftNode);

    AST rightNode = leftNode.getNextSibling();
    Expression rightExpression = expression(rightNode);
    // easier to massage here than in the grammar
    if (rightExpression instanceof SpreadExpression) {
        ListExpression wrapped = new ListExpression();
        wrapped.addExpression(rightExpression);
        rightExpression = wrapped;
    }

    BinaryExpression binaryExpression = new BinaryExpression(leftExpression, makeToken(Types.LEFT_SQUARE_BRACKET, bracket), rightExpression);
    configureAST(binaryExpression, indexNode);
    return binaryExpression;
}
 

import org.codehaus.groovy.ast.expr.ListExpression; //导入依赖的package包/类
public static boolean containsSpreadExpression(Expression arguments) {
    List args = null;
    if (arguments instanceof TupleExpression) {
        TupleExpression tupleExpression = (TupleExpression) arguments;
        args = tupleExpression.getExpressions();
    } else if (arguments instanceof ListExpression) {
        ListExpression le = (ListExpression) arguments;
        args = le.getExpressions();
    } else {
        return arguments instanceof SpreadExpression;
    }
    for (Iterator iter = args.iterator(); iter.hasNext();) {
        if (iter.next() instanceof SpreadExpression) return true;
    }
    return false;
}
 

import org.codehaus.groovy.ast.expr.ListExpression; //导入依赖的package包/类
private Expression annotationValueToExpression (Object value) {
    if (value == null || value instanceof String || value instanceof Number || value instanceof Character || value instanceof Boolean)
        return new ConstantExpression(value);

    if (value instanceof Class)
        return new ClassExpression(ClassHelper.makeWithoutCaching((Class)value));

    if (value.getClass().isArray()) {
        ListExpression elementExprs = new ListExpression();
        int len = Array.getLength(value);
        for (int i = 0; i != len; ++i)
            elementExprs.addExpression(annotationValueToExpression(Array.get(value, i)));
        return elementExprs;
    }

    return null;
}
 

import org.codehaus.groovy.ast.expr.ListExpression; //导入依赖的package包/类
private void addDependencyManagementBom(ModuleNode node, String module) {
	AnnotatedNode annotated = getAnnotatedNode(node);
	if (annotated != null) {
		AnnotationNode bom = getAnnotation(annotated);
		List<Expression> expressions = new ArrayList<Expression>(
				getConstantExpressions(bom.getMember("value")));
		expressions.add(new ConstantExpression(module));
		bom.setMember("value", new ListExpression(expressions));
	}
}
 

import org.codehaus.groovy.ast.expr.ListExpression; //导入依赖的package包/类
private List<ConstantExpression> getConstantExpressions(Expression valueExpression) {
	if (valueExpression instanceof ListExpression) {
		return getConstantExpressions((ListExpression) valueExpression);
	}
	if (valueExpression instanceof ConstantExpression
			&& ((ConstantExpression) valueExpression).getValue() instanceof String) {
		return Arrays.asList((ConstantExpression) valueExpression);
	}
	return Collections.emptyList();
}
 

import org.codehaus.groovy.ast.expr.ListExpression; //导入依赖的package包/类
@Override
public ListExpression visitList(ListContext ctx) {
    if (asBoolean(ctx.COMMA()) && !asBoolean(ctx.expressionList())) {
        throw createParsingFailedException("Empty list constructor should not contain any comma(,)", ctx.COMMA());
    }

    return configureAST(
            new ListExpression(
                    this.visitExpressionList(ctx.expressionList())),
            ctx);
}
 

import org.codehaus.groovy.ast.expr.ListExpression; //导入依赖的package包/类
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);
        }
    }
}
 

import org.codehaus.groovy.ast.expr.ListExpression; //导入依赖的package包/类
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;
}
 

import org.codehaus.groovy.ast.expr.ListExpression; //导入依赖的package包/类
private boolean typeCheckMultipleAssignmentAndContinue(Expression leftExpression, Expression rightExpression) {
    // multiple assignment check
    if (!(leftExpression instanceof TupleExpression)) return true;

    if (!(rightExpression instanceof ListExpression)) {
        addStaticTypeError("Multiple assignments without list expressions on the right hand side are unsupported in static type checking mode", rightExpression);
        return false;
    }

    TupleExpression tuple = (TupleExpression) leftExpression;
    ListExpression list = (ListExpression) rightExpression;
    List<Expression> listExpressions = list.getExpressions();
    List<Expression> tupleExpressions = tuple.getExpressions();
    if (listExpressions.size() < tupleExpressions.size()) {
        addStaticTypeError("Incorrect number of values. Expected:" + tupleExpressions.size() + " Was:" + listExpressions.size(), list);
        return false;
    }
    for (int i = 0, tupleExpressionsSize = tupleExpressions.size(); i < tupleExpressionsSize; i++) {
        Expression tupleExpression = tupleExpressions.get(i);
        Expression listExpression = listExpressions.get(i);
        ClassNode elemType = getType(listExpression);
        ClassNode tupleType = getType(tupleExpression);
        if (!isAssignableTo(elemType, tupleType)) {
            addStaticTypeError("Cannot assign value of type " + elemType.toString(false) + " to variable of type " + tupleType.toString(false), rightExpression);
            return false; // avoids too many errors
        } else {
            storeType(tupleExpression, elemType);
        }
    }

    return true;
}
 

import org.codehaus.groovy.ast.expr.ListExpression; //导入依赖的package包/类
protected ClassNode inferListExpressionType(final ListExpression list) {
    List<Expression> expressions = list.getExpressions();
    if (expressions.isEmpty()) {
        // cannot infer, return list type
        return list.getType();
    }
    ClassNode listType = list.getType();
    GenericsType[] genericsTypes = listType.getGenericsTypes();
    if ((genericsTypes == null
            || genericsTypes.length == 0
            || (genericsTypes.length == 1 && OBJECT_TYPE.equals(genericsTypes[0].getType())))
            && (!expressions.isEmpty())) {
        // maybe we can infer the component type
        List<ClassNode> nodes = new LinkedList<ClassNode>();
        for (Expression expression : expressions) {
            if (isNullConstant(expression)) {
                // a null element is found in the list, skip it because we'll use the other elements from the list
            } else {
                nodes.add(getType(expression));
            }
        }
        if (nodes.isEmpty()) {
            // every element was the null constant
            return listType;
        }
        ClassNode superType = getWrapper(lowestUpperBound(nodes)); // to be used in generics, type must be boxed
        ClassNode inferred = listType.getPlainNodeReference();
        inferred.setGenericsTypes(new GenericsType[]{new GenericsType(wrapTypeIfNecessary(superType))});
        return inferred;
    }
    return listType;
}