Java Token.newSymbol方法代码示例

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 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包/类
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包/类
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包/类
protected ClassNode checkReturnType(final ReturnStatement statement) {
    Expression expression = statement.getExpression();
    ClassNode type = getType(expression);
    if (typeCheckingContext.getEnclosingClosure()!=null) {
        return type;
    }
    // handle instanceof cases
    if ((expression instanceof VariableExpression) && hasInferredReturnType(expression)) {
        type = expression.getNodeMetaData(StaticTypesMarker.INFERRED_RETURN_TYPE);
    }
    MethodNode enclosingMethod = typeCheckingContext.getEnclosingMethod();
    if (enclosingMethod != null && typeCheckingContext.getEnclosingClosure()==null) {
        if (!enclosingMethod.isVoidMethod()
                && !type.equals(void_WRAPPER_TYPE)
                && !type.equals(VOID_TYPE)
                && !checkCompatibleAssignmentTypes(enclosingMethod.getReturnType(), type, null, false)
                && !(isNullConstant(expression))) {
            if (!extension.handleIncompatibleReturnType(statement, type)) {
                addStaticTypeError("Cannot return value of type " + type.toString(false) + " on method returning type " + enclosingMethod.getReturnType().toString(false), expression);
            }
        } else if (!enclosingMethod.isVoidMethod()) {
            ClassNode previousType = getInferredReturnType(enclosingMethod);
            ClassNode inferred = previousType == null ? type : lowestUpperBound(type, previousType);
            if (implementsInterfaceOrIsSubclassOf(inferred, enclosingMethod.getReturnType())) {
                if (missesGenericsTypes(inferred)) {
                    DeclarationExpression virtualDecl = new DeclarationExpression(
                            varX("{target}", enclosingMethod.getReturnType()),
                            Token.newSymbol(EQUAL, -1, -1),
                            varX("{source}", type)
                    );
                    virtualDecl.setSourcePosition(statement);
                    virtualDecl.visit(this);
                    ClassNode newlyInferred = (ClassNode) virtualDecl.getNodeMetaData(StaticTypesMarker.INFERRED_TYPE);
                    if (!missesGenericsTypes(newlyInferred)) type = newlyInferred;
                } else {
                    checkTypeGenerics(enclosingMethod.getReturnType(), inferred, expression);
                }
                return type;
            } else {
                return enclosingMethod.getReturnType();
            }
        }
    }
    return type;
}
 

import org.codehaus.groovy.syntax.Token; //导入方法依赖的package包/类
protected static Token makeToken(int typeCode, AST node) {
    return Token.newSymbol(typeCode, node.getLine(), node.getColumn());
}
 

import org.codehaus.groovy.syntax.Token; //导入方法依赖的package包/类
protected void addFieldInitialization(List list, List staticList, FieldNode fieldNode,
                                      boolean isEnumClassNode, List initStmtsAfterEnumValuesInit, Set explicitStaticPropsInEnum) {
    Expression expression = fieldNode.getInitialExpression();
    if (expression != null) {
        final FieldExpression fe = new FieldExpression(fieldNode);
        if (fieldNode.getType().equals(ClassHelper.REFERENCE_TYPE) && ((fieldNode.getModifiers() & Opcodes.ACC_SYNTHETIC) != 0)) {
            fe.setUseReferenceDirectly(true);
        }
        ExpressionStatement statement =
                new ExpressionStatement(
                        new BinaryExpression(
                                fe,
                                Token.newSymbol(Types.EQUAL, fieldNode.getLineNumber(), fieldNode.getColumnNumber()),
                                expression));
        if (fieldNode.isStatic()) {
            // GROOVY-3311: pre-defined constants added by groovy compiler for numbers/characters should be
            // initialized first so that code dependent on it does not see their values as empty
            Expression initialValueExpression = fieldNode.getInitialValueExpression();
            if (initialValueExpression instanceof ConstantExpression) {
                ConstantExpression cexp = (ConstantExpression) initialValueExpression;
                cexp = transformToPrimitiveConstantIfPossible(cexp);
                if (fieldNode.isFinal() && ClassHelper.isStaticConstantInitializerType(cexp.getType()) && cexp.getType().equals(fieldNode.getType())) {
                    return; // GROOVY-5150: primitive type constants will be initialized directly
                }
                staticList.add(0, statement);
            } else {
                staticList.add(statement);
            }
            fieldNode.setInitialValueExpression(null); // to avoid double initialization in case of several constructors
            /*
             * If it is a statement for an explicitly declared static field inside an enum, store its
             * reference. For enums, they need to be handled differently as such init statements should
             * come after the enum values have been initialized inside <clinit> block. GROOVY-3161.
             */
            if (isEnumClassNode && explicitStaticPropsInEnum.contains(fieldNode.getName())) {
                initStmtsAfterEnumValuesInit.add(statement);
            }
        } else {
            list.add(statement);
        }
    }
}
 

import org.codehaus.groovy.syntax.Token; //导入方法依赖的package包/类
private void transformSpreadOnLHS(BinaryExpression origin) {
    PropertyExpression spreadExpression = (PropertyExpression) origin.getLeftExpression();
    Expression value = origin.getRightExpression();
    WriterController controller = getController();
    MethodVisitor mv = controller.getMethodVisitor();
    CompileStack compileStack = controller.getCompileStack();
    TypeChooser typeChooser = controller.getTypeChooser();
    OperandStack operandStack = controller.getOperandStack();
    ClassNode classNode = controller.getClassNode();
    int counter = labelCounter.incrementAndGet();
    Expression receiver = spreadExpression.getObjectExpression();

    // create an empty arraylist
    VariableExpression result = new VariableExpression(
            this.getClass().getSimpleName()+"$spreadresult" + counter,
            ARRAYLIST_CLASSNODE
    );
    ConstructorCallExpression cce = new ConstructorCallExpression(ARRAYLIST_CLASSNODE, ArgumentListExpression.EMPTY_ARGUMENTS);
    cce.setNodeMetaData(StaticTypesMarker.DIRECT_METHOD_CALL_TARGET, ARRAYLIST_CONSTRUCTOR);
    DeclarationExpression declr = new DeclarationExpression(
            result,
            Token.newSymbol("=", spreadExpression.getLineNumber(), spreadExpression.getColumnNumber()),
            cce
    );
    declr.visit(controller.getAcg());
    // if (receiver != null)
    receiver.visit(controller.getAcg());
    Label ifnull = compileStack.createLocalLabel("ifnull_" + counter);
    mv.visitJumpInsn(IFNULL, ifnull);
    operandStack.remove(1); // receiver consumed by if()
    Label nonull = compileStack.createLocalLabel("nonull_" + counter);
    mv.visitLabel(nonull);
    ClassNode componentType = StaticTypeCheckingVisitor.inferLoopElementType(typeChooser.resolveType(receiver, classNode));
    Parameter iterator = new Parameter(componentType, "for$it$" + counter);
    VariableExpression iteratorAsVar = new VariableExpression(iterator);
    PropertyExpression pexp = spreadExpression instanceof AttributeExpression ?
            new AttributeExpression(iteratorAsVar, spreadExpression.getProperty(), true):
            new PropertyExpression(iteratorAsVar, spreadExpression.getProperty(), true);
    pexp.setImplicitThis(spreadExpression.isImplicitThis());
    pexp.setSourcePosition(spreadExpression);
    BinaryExpression assignment = new BinaryExpression(
            pexp,
            origin.getOperation(),
            value
    );
    MethodCallExpression add = new MethodCallExpression(
            result,
            "add",
            assignment
    );
    add.setMethodTarget(ARRAYLIST_ADD_METHOD);
    // for (e in receiver) { result.add(e?.method(arguments) }
    ForStatement stmt = new ForStatement(
            iterator,
            receiver,
            new ExpressionStatement(add)
    );
    stmt.visit(controller.getAcg());
    // else { empty list }
    mv.visitLabel(ifnull);

    // end of if/else
    // return result list
    result.visit(controller.getAcg());

}
 

import org.codehaus.groovy.syntax.Token; //导入方法依赖的package包/类
public void testLoop() throws Exception {
    ClassNode classNode = new ClassNode("Foo", ACC_PUBLIC, ClassHelper.OBJECT_TYPE);
    classNode.addConstructor(new ConstructorNode(ACC_PUBLIC, null));
    classNode.addProperty(new PropertyNode("bar", ACC_PUBLIC, ClassHelper.STRING_TYPE, classNode, null, null, null));

    classNode.addProperty(new PropertyNode("result", ACC_PUBLIC, ClassHelper.STRING_TYPE, classNode, null, null, null));

    BooleanExpression expression =
            new BooleanExpression(
                    new BinaryExpression(
                            new FieldExpression(
                                    new FieldNode("bar", ACC_PRIVATE, ClassHelper.STRING_TYPE, classNode, ConstantExpression.NULL)),
                            Token.newSymbol("==", 0, 0),
                            new ConstantExpression("abc")));

    Statement trueStatement =
            new ExpressionStatement(
                    new BinaryExpression(
                            new FieldExpression(
                                    new FieldNode("result", ACC_PRIVATE, ClassHelper.STRING_TYPE, classNode, ConstantExpression.NULL)),
                            Token.newSymbol("=", 0, 0),
                            new ConstantExpression("worked")));

    Statement falseStatement = createPrintlnStatement(new ConstantExpression("false"));

    IfStatement statement = new IfStatement(expression, trueStatement, falseStatement);
    classNode.addMethod(new MethodNode("ifDemo", ACC_PUBLIC, ClassHelper.VOID_TYPE, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, statement));

    Class fooClass = loadClass(classNode);
    assertTrue("Loaded a new class", fooClass != null);

    Object bean = fooClass.newInstance();
    assertTrue("Managed to create bean", bean != null);

    assertSetProperty(bean, "bar", "abc");

    System.out.println("################ Now about to invoke method");

    Object[] array = {
    };

    InvokerHelper.invokeMethod(bean, "ifDemo", array);

    System.out.println("################ Done");

    assertGetProperty(bean, "result", "worked");
}
 

import org.codehaus.groovy.syntax.Token; //导入方法依赖的package包/类
/**
 * Creates a variable definition expression. Where, in the code a
 * variable is defined. If could be also initialized.
 *
 * <strong>AST</strong>
 * <pre><code>
 * //...after declaring the variables somewhere
 * varDeclarationX('johnAge',
 *                  A.NODES.clazz(Integer).build(),
 *                  A.EXPR.constX(23))
 * </code></pre>
 *
 * <strong>Result</strong>
 * <pre><code>
 * Integer johnAge = 23
 * </code></pre>
 *
 * @param varName name of the declared variable
 * @param type type of the declared variable as a {@link ClassNode} instance
 * @param defaultValue expression setting the default value of the declared variable
 * @return an instance of a {@link DeclarationExpression}
 * @since 0.2.4
 */
public static DeclarationExpression varDeclarationX(final String varName, final ClassNode type, final Expression defaultValue) {
    return new DeclarationExpression(
        A.EXPR.varX(varName, type),
        Token.newSymbol(Types.EQUAL, 0, 0),
        defaultValue);
}
 

import org.codehaus.groovy.syntax.Token; //导入方法依赖的package包/类
/**
 * Builds a new {@link BinaryExpression} with the names of the
 * variables pointing at both left/right terms in the binary
 * expression plus the operator in between. The operator can be
 * anyone found in the {@link Types} type
 *
 * <strong>AST</strong>
 * <pre><code>
 * //...after declaring the variables somewhere
 * boolX('johnAge', Types.PLUS, 'peterAge')
 * </code></pre>
 *
 * <strong>Result</strong>
 * <pre><code>
 * johnAge + peterAge
 * </code></pre>
 *
 * @param leftVarName name of the variable referenced in the left
 * side of the binary expression
 * @param operator type of the operator. Use any of the listed in
 * {@link Types}
 * @param rightVarName name of the variable referenced in the
 * right side of the binary expression
 * @return a binary expression as a {@link BinaryExpression} instance
 * @since 0.2.4
 */
public static BinaryExpression binX(final String leftVarName, final int operator, final String rightVarName) {
    return new BinaryExpression(A.EXPR.varX(leftVarName),
                                Token.newSymbol(operator, 0, 0),
                                A.EXPR.varX(rightVarName));
}