Examples with Variable org.codehaus.groovy.ast.Variable used on opensource projects

Example 41 with Variable

use of org.codehaus.groovy.ast.Variable in project groovy by apache.

the class StaticTypeCheckingVisitor method isSecondPassNeededForControlStructure.

protected boolean isSecondPassNeededForControlStructure(final Map<VariableExpression, ClassNode> varOrigType, final Map<VariableExpression, List<ClassNode>> oldTracker) {
    Map<VariableExpression, ClassNode> assignedVars = popAssignmentTracking(oldTracker);
    for (Map.Entry<VariableExpression, ClassNode> entry : assignedVars.entrySet()) {
        Variable key = findTargetVariable(entry.getKey());
        if (key instanceof VariableExpression) {
            ClassNode origType = varOrigType.get(key);
            ClassNode newType = entry.getValue();
            if (varOrigType.containsKey(key) && (origType == null || !newType.equals(origType))) {
                return true;
            }
        }
    }
    return false;
}

Example 42 with Variable

use of org.codehaus.groovy.ast.Variable in project groovy by apache.

the class StaticTypeCheckingVisitor method saveVariableExpressionMetadata.

protected void saveVariableExpressionMetadata(final Set<VariableExpression> closureSharedExpressions, final Map<VariableExpression, ListHashMap> typesBeforeVisit) {
    for (VariableExpression ve : closureSharedExpressions) {
        // GROOVY-6921: We must force a call to getType in order to update closure shared variable which types are
        // inferred thanks to closure parameter type inference
        getType(ve);
        ListHashMap<StaticTypesMarker, Object> metadata = new ListHashMap<StaticTypesMarker, Object>();
        for (StaticTypesMarker marker : StaticTypesMarker.values()) {
            Object value = ve.getNodeMetaData(marker);
            if (value != null) {
                metadata.put(marker, value);
            }
        }
        typesBeforeVisit.put(ve, metadata);
        Variable accessedVariable = ve.getAccessedVariable();
        if (accessedVariable != ve && accessedVariable instanceof VariableExpression) {
            saveVariableExpressionMetadata(Collections.singleton((VariableExpression) accessedVariable), typesBeforeVisit);
        }
    }
}

Example 43 with Variable

use of org.codehaus.groovy.ast.Variable in project gradle by gradle.

the class GradleResolveVisitor method transformVariableExpression.

protected Expression transformVariableExpression(VariableExpression ve) {
    visitAnnotations(ve);
    Variable v = ve.getAccessedVariable();
    if (!(v instanceof DynamicVariable) && !checkingVariableTypeInDeclaration) {
        /*
         *  GROOVY-4009: when a normal variable is simply being used, there is no need to try to
         *  resolve its type. Variable type resolve should proceed only if the variable is being declared.
         */
        return ve;
    }
    if (v instanceof DynamicVariable) {
        String name = ve.getName();
        ClassNode t = ClassHelper.make(name);
        // asking isResolved here allows to check if a primitive
        // type name like "int" was used to make t. In such a case
        // we have nothing left to do.
        boolean isClass = t.isResolved();
        if (!isClass) {
            // compiler skip the resolving at several places in this class.
            if (Character.isLowerCase(name.charAt(0))) {
                t = new LowerCaseClass(name);
            }
            isClass = resolve(t);
            if (!isClass) {
                isClass = resolveToNestedOfCurrent(t);
            }
        }
        if (isClass) {
            // for each parentscope too
            for (VariableScope scope = currentScope; scope != null && !scope.isRoot(); scope = scope.getParent()) {
                if (scope.isRoot()) {
                    break;
                }
                if (scope.removeReferencedClassVariable(ve.getName()) == null) {
                    break;
                }
            }
            ClassExpression ce = new ClassExpression(t);
            ce.setSourcePosition(ve);
            return ce;
        }
    }
    resolveOrFail(ve.getType(), ve);
    ClassNode origin = ve.getOriginType();
    if (origin != ve.getType()) {
        resolveOrFail(origin, ve);
    }
    return ve;
}