import org.codehaus.groovy.syntax.Token; //导入依赖的package包/类
public void visitBinaryExpression(BinaryExpression expression) {
    Expression left = expression.getLeftExpression();
    Expression right = expression.getRightExpression();
    boolean leaf = (right instanceof ConstantExpression || left instanceof ConstantExpression);

    if (!leaf) buffer.append("(");
    left.visit(this);
    buffer.append(" ");

    Token token = expression.getOperation();
    buffer.append(tokenAsSql(token));

    buffer.append(" ");
    right.visit(this);
    if (!leaf) buffer.append(")");
}
 

import org.codehaus.groovy.syntax.Token; //导入依赖的package包/类
@Override
public void visitField(final FieldNode node) {
    final boolean osc = typeCheckingContext.isInStaticContext;
    try {
        typeCheckingContext.isInStaticContext = node.isInStaticContext();
        currentField = node;
        super.visitField(node);
        Expression init = node.getInitialExpression();
        if (init != null) {
            FieldExpression left = new FieldExpression(node);
            BinaryExpression bexp = binX(
                    left,
                    Token.newSymbol("=", node.getLineNumber(), node.getColumnNumber()),
                    init
            );
            bexp.setSourcePosition(init);
            typeCheckAssignment(bexp, left, node.getOriginType(), init, getType(init));
            if (init instanceof ConstructorCallExpression) {
                inferDiamondType((ConstructorCallExpression) init, node.getOriginType());
            }
        }
    } finally {
        currentField = null;
        typeCheckingContext.isInStaticContext = osc;
    }
}
 

import org.codehaus.groovy.syntax.Token; //导入依赖的package包/类
private Expression convertInOperatorToTernary(final BinaryExpression bin, final Expression rightExpression, final Expression leftExpression) {
    MethodCallExpression call = new MethodCallExpression(
            rightExpression,
            "isCase",
            leftExpression
    );
    call.setMethodTarget((MethodNode) bin.getNodeMetaData(StaticTypesMarker.DIRECT_METHOD_CALL_TARGET));
    call.setSourcePosition(bin);
    call.copyNodeMetaData(bin);
    TernaryExpression tExp = new TernaryExpression(
            new BooleanExpression(
                    new BinaryExpression(rightExpression, Token.newSymbol("==", -1, -1), new ConstantExpression(null))
            ),
            new BinaryExpression(leftExpression, Token.newSymbol("==", -1, -1), new ConstantExpression(null)),
            call
    );
    return staticCompilationTransformer.transform(tExp);
}
 

import org.codehaus.groovy.syntax.Token; //导入依赖的package包/类
private static DeclarationExpression optimizeConstantInitialization(
        final BinaryExpression originalDeclaration,
        final Token operation,
        final ConstantExpression constant,
        final Expression leftExpression,
        final ClassNode declarationType) {
    ConstantExpression cexp = new ConstantExpression(
            convertConstant((Number) constant.getValue(), ClassHelper.getWrapper(declarationType)), true);
    cexp.setType(declarationType);
    cexp.setSourcePosition(constant);
    DeclarationExpression result = new DeclarationExpression(
            leftExpression,
            operation,
            cexp
    );
    result.setSourcePosition(originalDeclaration);
    result.copyNodeMetaData(originalDeclaration);
    return result;
}
 

import org.codehaus.groovy.syntax.Token; //导入依赖的package包/类
private Expression transformBinaryExpression(final BinaryExpression exp) {
    final int op = exp.getOperation().getType();
    int token = TokenUtil.removeAssignment(op);
    if (token == op) {
        // no transform needed
        return super.transform(exp);
    }
    BinaryExpression operation = new BinaryExpression(
            exp.getLeftExpression(),
            Token.newSymbol(token, -1, -1),
            exp.getRightExpression()
    );
    operation.setSourcePosition(exp);
    BinaryExpression result = new BinaryExpression(
            exp.getLeftExpression(),
            Token.newSymbol(EQUAL, -1, -1),
            operation
    );
    result.setSourcePosition(exp);
    return result;
}
 

import org.codehaus.groovy.syntax.Token; //导入依赖的package包/类
protected static void setPropertySetterDispatcher(BlockStatement block, Expression thiz, Parameter[] parameters) {
    List<ConstantExpression> gStringStrings = new ArrayList<ConstantExpression>();
    gStringStrings.add(new ConstantExpression(""));
    gStringStrings.add(new ConstantExpression(""));
    List<Expression> gStringValues = new ArrayList<Expression>();
    gStringValues.add(new VariableExpression(parameters[0]));
    block.addStatement(
            new ExpressionStatement(
                    new BinaryExpression(
                            new PropertyExpression(
                                    thiz,
                                    new GStringExpression("$name", gStringStrings, gStringValues)
                            ),
                            Token.newSymbol(Types.ASSIGN, -1, -1),
                            new VariableExpression(parameters[1])
                    )
            )
    );
}
 

import org.codehaus.groovy.syntax.Token; //导入依赖的package包/类
@Override
public void visitClosureExpression(ClosureExpression expression) {
    if (inputs == null) {
        inputs = ImmutableListMultimap.builder();
        try {
            accessVariable = new VariableExpression(ACCESS_HOLDER_FIELD, ACCESS_API_TYPE);

            super.visitClosureExpression(expression);

            BlockStatement code = (BlockStatement) expression.getCode();
            code.setNodeMetaData(AST_NODE_METADATA_INPUTS_KEY, inputs.build());
            accessVariable.setClosureSharedVariable(true);
            StaticMethodCallExpression getAccessCall = new StaticMethodCallExpression(CONTEXTUAL_INPUT_TYPE, GET_ACCESS, ArgumentListExpression.EMPTY_ARGUMENTS);
            DeclarationExpression variableDeclaration = new DeclarationExpression(accessVariable, new Token(Types.ASSIGN, "=", -1, -1), getAccessCall);
            code.getStatements().add(0, new ExpressionStatement(variableDeclaration));
            code.getVariableScope().putDeclaredVariable(accessVariable);
        } finally {
            inputs = null;
        }
    } else {
        expression.getVariableScope().putReferencedLocalVariable(accessVariable);
        super.visitClosureExpression(expression);
    }
}
 

import org.codehaus.groovy.syntax.Token; //导入依赖的package包/类
@Override
public void visitBinaryExpression(BinaryExpression expression) {
    Token operation = expression.getOperation();
    if (operation.isA(Types.LEFT_SHIFT) && expression.getLeftExpression() instanceof VariableExpression && expression.getRightExpression() instanceof ClosureExpression) {
        addCreator(scope, (VariableExpression) expression.getLeftExpression(), (ClosureExpression) expression.getRightExpression());
    } else if (operation.isA(Types.ASSIGN)) {
        if (expression.getLeftExpression() instanceof VariableExpression) {
            addCreator(scope, (VariableExpression) expression.getLeftExpression(), expression.getRightExpression());
        } else if (expression.getLeftExpression() instanceof PropertyExpression) {
            addCreator(scope, (PropertyExpression) expression.getLeftExpression(), expression.getRightExpression());
        } else {
            super.visitBinaryExpression(expression);
        }
    } else {
        super.visitBinaryExpression(expression);
    }
}
 

import org.codehaus.groovy.syntax.Token; //导入依赖的package包/类
protected String tokenAsSql(Token token) {
    switch (token.getType()) {
        case Types.COMPARE_EQUAL:
            return "=";
        case Types.LOGICAL_AND:
            return "and";
        case Types.LOGICAL_OR:
            return "or";
        default:
            return token.getText();
    }
}
 

import org.codehaus.groovy.syntax.Token; //导入依赖的package包/类
/**
 * Checks that a given token is either in the whitelist or not in the blacklist.
 *
 * @param token the token to be checked
 * @throws SecurityException if usage of this token is forbidden
 */
private void assertTokenAuthorized(final Token token) throws SecurityException {
    final int value = token.getType();
    if (tokensBlacklist != null && tokensBlacklist.contains(value)) {
        throw new SecurityException("Token " + token + " is not allowed");
    } else if (tokensWhitelist != null && !tokensWhitelist.contains(value)) {
        throw new SecurityException("Token " + token + " is not allowed");
    }
}
 

import org.codehaus.groovy.syntax.Token; //导入依赖的package包/类
private Expression transformPrefixExpression(final PrefixExpression exp) {
    if (isInternalFieldAccess(exp.getExpression())) {
        Token operation = exp.getOperation();
        sourceUnit.addError(new SyntaxException("Prefix expressions on trait fields/properties are not supported in traits.", operation.getStartLine(), operation.getStartColumn()));
        return exp;
    } else {
        return super.transform(exp);
    }
}
 

import org.codehaus.groovy.syntax.Token; //导入依赖的package包/类
private Expression transformPostfixExpression(final PostfixExpression exp) {
    if (isInternalFieldAccess(exp.getExpression())) {
        Token operation = exp.getOperation();
        sourceUnit.addError(new SyntaxException("Postfix expressions on trait fields/properties  are not supported in traits.", operation.getStartLine(), operation.getStartColumn()));
        return exp;
    } else {
        return super.transform(exp);
    }
}
 

import org.codehaus.groovy.syntax.Token; //导入依赖的package包/类
private static Statement createSuperFallback(MethodNode forwarderMethod, ClassNode returnType) {
    ArgumentListExpression args = new ArgumentListExpression();
    Parameter[] forwarderMethodParameters = forwarderMethod.getParameters();
    for (final Parameter forwarderMethodParameter : forwarderMethodParameters) {
        args.addExpression(new VariableExpression(forwarderMethodParameter));
    }
    BinaryExpression instanceOfExpr = new BinaryExpression(new VariableExpression("this"), Token.newSymbol(Types.KEYWORD_INSTANCEOF, -1, -1), new ClassExpression(Traits.GENERATED_PROXY_CLASSNODE));
    MethodCallExpression superCall = new MethodCallExpression(
            new VariableExpression("super"),
            forwarderMethod.getName(),
            args
    );
    superCall.setImplicitThis(false);
    CastExpression proxyReceiver = new CastExpression(Traits.GENERATED_PROXY_CLASSNODE, new VariableExpression("this"));
    MethodCallExpression getProxy = new MethodCallExpression(proxyReceiver, "getProxyTarget", ArgumentListExpression.EMPTY_ARGUMENTS);
    getProxy.setImplicitThis(true);
    StaticMethodCallExpression proxyCall = new StaticMethodCallExpression(
            ClassHelper.make(InvokerHelper.class),
            "invokeMethod",
            new ArgumentListExpression(getProxy, new ConstantExpression(forwarderMethod.getName()), new ArrayExpression(ClassHelper.OBJECT_TYPE, args.getExpressions()))
    );
    IfStatement stmt = new IfStatement(
            new BooleanExpression(instanceOfExpr),
            new ExpressionStatement(new CastExpression(returnType,proxyCall)),
            new ExpressionStatement(superCall)
    );
    return stmt;
}
 

import org.codehaus.groovy.syntax.Token; //导入依赖的package包/类
private TernaryExpression createStaticReceiver(final Expression receiver) {
    return new TernaryExpression(
            new BooleanExpression(new BinaryExpression(
                    receiver,
                    Token.newSymbol(Types.KEYWORD_INSTANCEOF, -1, -1),
                    new ClassExpression(ClassHelper.CLASS_Type)
            )),
            receiver,
            new MethodCallExpression(createFieldHelperReceiver(), "getClass", ArgumentListExpression.EMPTY_ARGUMENTS)
    );
}
 

import org.codehaus.groovy.syntax.Token; //导入依赖的package包/类
private BinaryExpression createAssignmentToField(final Expression rightExpression,
                                                 final Token operation, final String fieldName) {
    return new BinaryExpression(
            new PropertyExpression(
                    new VariableExpression(weaved),
                    fieldName
            ),
            operation,
            transform(rightExpression));
}
 

import org.codehaus.groovy.syntax.Token; //导入依赖的package包/类
public BinaryExpression(Expression leftExpression,
                        Token operation,
                        Expression rightExpression) {
    this.leftExpression = leftExpression;
    this.operation = operation;
    this.rightExpression = rightExpression;
}
 

import org.codehaus.groovy.syntax.Token; //导入依赖的package包/类
/**
 * Creates an assignment expression in which the specified expression
 * is written into the specified variable name.
 */

public static BinaryExpression newAssignmentExpression(Variable variable, Expression rhs) {
    VariableExpression lhs = new VariableExpression(variable);
    Token operator = Token.newPlaceholder(Types.ASSIGN);

    return new BinaryExpression(lhs, operator, rhs);
}
 

import org.codehaus.groovy.syntax.Token; //导入依赖的package包/类
protected static void addFieldInit(Parameter p, FieldNode fn, BlockStatement block) {
    VariableExpression ve = new VariableExpression(p);
    FieldExpression fe = new FieldExpression(fn);
    block.addStatement(new ExpressionStatement(
            new BinaryExpression(fe, Token.newSymbol(Types.ASSIGN, -1, -1), ve)
    ));
}
 

import org.codehaus.groovy.syntax.Token; //导入依赖的package包/类
public void evaluateElvisEqual(BinaryExpression expression) {
    Token operation = expression.getOperation();
    BinaryExpression elvisAssignmentExpression =
            new BinaryExpression(
                    expression.getLeftExpression(),
                    Token.newSymbol(Types.EQUAL, operation.getStartLine(), operation.getStartColumn()),
                    new ElvisOperatorExpression(expression.getLeftExpression(), expression.getRightExpression())
            );

    this.evaluateEqual(elvisAssignmentExpression, false);
}
 

import org.codehaus.groovy.syntax.Token; //导入依赖的package包/类
private void evaluateNotInstanceof(BinaryExpression expression) {
    unaryExpressionHelper.writeNotExpression(
            new NotExpression(
                    new BinaryExpression(
                            expression.getLeftExpression(),
                            Token.newSymbol(KEYWORD_INSTANCEOF, -1, -1),
                            expression.getRightExpression()
                    )
            )
    );
}