Java VariableExpression.setAccessedVariable方法代码示例

import org.codehaus.groovy.ast.expr.VariableExpression; //导入方法依赖的package包/类
private static void correctAccessedVariable(final InnerClassNode closureClass, ClosureExpression ce) {
    CodeVisitorSupport visitor = new CodeVisitorSupport() {
        @Override
        public void visitVariableExpression(VariableExpression expression) {
            Variable v = expression.getAccessedVariable(); 
            if (v==null) return;
            if (!(v instanceof FieldNode)) return;
            String name = expression.getName();
            FieldNode fn = closureClass.getDeclaredField(name);
            if (fn != null) { // only overwrite if we find something more specific
                expression.setAccessedVariable(fn);
            }
        }  
    };
    visitor.visitClosureExpression(ce);
}
 

import org.codehaus.groovy.ast.expr.VariableExpression; //导入方法依赖的package包/类
@Override
public Expression transform(Expression expr) {
    if (expr == null) return null;
    if (expr instanceof DeclarationExpression) {
        DeclarationExpression de = (DeclarationExpression) expr;
        if (de.getLeftExpression() == candidate.getLeftExpression()) {
            if (insideScriptBody) {
                // TODO make EmptyExpression work
                // partially works but not if only thing in script
                // return EmptyExpression.INSTANCE;
                return new ConstantExpression(null);
            }
            addError("Annotation " + MY_TYPE_NAME + " can only be used within a Script body.", expr);
            return expr;
        }
    } else if (insideScriptBody && expr instanceof VariableExpression && currentClosure != null) {
        VariableExpression ve = (VariableExpression) expr;
        if (ve.getName().equals(variableName)) {
            // we may only check the variable name because the Groovy compiler
            // already fails if a variable with the same name already exists in the scope.
            // this means that a closure cannot shadow a class variable
            ve.setAccessedVariable(fieldNode);
            final VariableScope variableScope = currentClosure.getVariableScope();
            final Iterator<Variable> iterator = variableScope.getReferencedLocalVariablesIterator();
            while (iterator.hasNext()) {
                Variable next = iterator.next();
                if (next.getName().equals(variableName)) iterator.remove();
            }
            variableScope.putReferencedClassVariable(fieldNode);
            return ve;
        }
    }
    return expr.transformExpression(this);
}
 

import org.codehaus.groovy.ast.expr.VariableExpression; //导入方法依赖的package包/类
private void adjustToClassVar(VariableExpression expr) {
    // we only need to check the variable name because the Groovy compiler
    // already fails if a variable with the same name already exists in the scope.
    // this means that a closure cannot shadow a class variable
    expr.setAccessedVariable(fieldNode);
    final VariableScope variableScope = currentClosure.getVariableScope();
    final Iterator<Variable> iterator = variableScope.getReferencedLocalVariablesIterator();
    while (iterator.hasNext()) {
        Variable next = iterator.next();
        if (next.getName().equals(variableName)) iterator.remove();
    }
    variableScope.putReferencedClassVariable(fieldNode);
}
 

import org.codehaus.groovy.ast.expr.VariableExpression; //导入方法依赖的package包/类
private static void doAddConstructor(final ClassNode cNode, final ConstructorNode constructorNode) {
    cNode.addConstructor(constructorNode);
    // GROOVY-5814: Immutable is not compatible with @CompileStatic
    Parameter argsParam = null;
    for (Parameter p : constructorNode.getParameters()) {
        if ("args".equals(p.getName())) {
            argsParam = p;
            break;
        }
    }
    if (argsParam!=null) {
        final Parameter arg = argsParam;
        ClassCodeVisitorSupport variableExpressionFix = new ClassCodeVisitorSupport() {
            @Override
            protected SourceUnit getSourceUnit() {
                return cNode.getModule().getContext();
            }

            @Override
            public void visitVariableExpression(final VariableExpression expression) {
                super.visitVariableExpression(expression);
                if ("args".equals(expression.getName())) {
                    expression.setAccessedVariable(arg);
                }
            }
        };
        variableExpressionFix.visitConstructor(constructorNode);
    }
}
 

import org.codehaus.groovy.ast.expr.VariableExpression; //导入方法依赖的package包/类
public void visitVariableExpression(VariableExpression expression) {
    String name = expression.getName();
    Variable v = checkVariableNameForDeclaration(name, expression);
    if (v == null) return;
    expression.setAccessedVariable(v);
    checkVariableContextAccess(v, expression);
}
 

import org.codehaus.groovy.ast.expr.VariableExpression; //导入方法依赖的package包/类
private void declare(VariableExpression vex) {
    vex.setInStaticContext(currentScope.isInStaticContext());
    declare(vex, vex);
    vex.setAccessedVariable(vex);
}