Java ListExpression.getExpressions方法代码示例

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 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包/类
@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 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包/类
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);
		}
	}
	return expressions;
}
 

import org.codehaus.groovy.ast.expr.ListExpression; //导入方法依赖的package包/类
private static boolean containsOnlyConstants(ListExpression list) {
    for (Expression exp : list.getExpressions()) {
        if (exp instanceof ConstantExpression) continue;
        return false;
    }
    return true;
}
 

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;
}
 

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

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

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

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