resolver.java

Checkstyle 可寻找：·不能使用的或者多余的输入 ·空格更好的地方不使用跳格符

                case TokenTypes.STAR :
                case TokenTypes.BAND :
                case TokenTypes.BOR :
                case TokenTypes.BXOR :
                case TokenTypes.MOD :
                    result =
                        resolveArithmeticExpression(
                            expression,
                            location,
                            context,
                            referencePhase);
                    break;

                case TokenTypes.LITERAL_BREAK :
                case TokenTypes.LITERAL_CONTINUE :
                    resolveGoto(expression, location, context, referencePhase);
                    break;

                case TokenTypes.LPAREN :
                    result = resolveExpression(
                        //TODO: child || sibling?
     (SymTabAST) (expression.getNextSibling()),
                        //(SymTabAST) (expression.getFirstChild()),
    location, context, referencePhase);
                    break;

                case TokenTypes.INDEX_OP :
                    result =
                        resolveArrayAccess(
                            expression,
                            location,
                            context,
                            referencePhase);
                    break;

                case TokenTypes.LITERAL_NULL :
                    result = new NullClass();
                    break;

                case TokenTypes.QUESTION :
                    result =
                        resolveQuestion(
                            expression,
                            location,
                            context,
                            referencePhase);
                    break;

                case TokenTypes.LITERAL_CLASS :
                    result = resolveLiteralClass();
                    break;

                case TokenTypes.ARRAY_INIT :
                    resolveArrayInitializer(
                        expression,
                        location,
                        context,
                        referencePhase);
                    break;

                case TokenTypes.LITERAL_THROW :
                    resolveThrowExpression(
                        expression,
                        location,
                        context,
                        referencePhase);
                    break;

                case TokenTypes.SL :
                case TokenTypes.SR :
                case TokenTypes.BSR :
                    result =
                        resolveShiftOperator(
                            expression,
                            location,
                            context,
                            referencePhase);
                    break;

                case TokenTypes.BNOT :
                    resolveBitwiseNot(
                        expression,
                        location,
                        context,
                        referencePhase);
                    break;

                case TokenTypes.LITERAL_ASSERT :
//                                        resolveAssert(
//                                            expression,
//                                            location,
//                                            context,
//                                            referencePhase);
                    break;

                case TokenTypes.RPAREN :
                case TokenTypes.EMPTY_STAT :
                    //    case TokenTypes.ML_COMMENT:
                    //    case TokenTypes.SL_COMMENT:
                case TokenTypes.VARIABLE_DEF :
                case TokenTypes.METHOD_DEF :
                case TokenTypes.CLASS_DEF :
                case TokenTypes.LITERAL_FOR :
                case TokenTypes.LITERAL_WHILE :
                case TokenTypes.LITERAL_IF :
                case TokenTypes.LITERAL_VOID :
                    //    case TokenTypes.LITERAL_INTERFACE:
                case TokenTypes.LITERAL_DO :
                case TokenTypes.LITERAL_SWITCH :
                case TokenTypes.LITERAL_STATIC :
                case TokenTypes.LITERAL_TRANSIENT :
                case TokenTypes.LITERAL_NATIVE :
                    //    case TokenTypes.LITERAL_threadsafe:
                case TokenTypes.LITERAL_SYNCHRONIZED :
                case TokenTypes.LITERAL_VOLATILE :
                case TokenTypes.LITERAL_TRY :
                case TokenTypes.LITERAL_CATCH :
                case TokenTypes.LITERAL_FINALLY :
                case TokenTypes.LABELED_STAT :
                case TokenTypes.LCURLY :
                case TokenTypes.RCURLY :
                case TokenTypes.SLIST :
                case TokenTypes.SEMI :
                case TokenTypes.COMMA :
                case TokenTypes.ARRAY_DECLARATOR :
                    break;

                default :
                //TODO: throw exception
                    if (mInitialized) {
                        final Log log =
                            mLogFactory.getInstance(this.getClass());
                        log.error(
                            "Unhandled expression type: "
                                + expression.getType());
                    }
                    break;
            }
        }
        catch (Exception e) {
            
            result = new UnknownClass(expression.getText(), expression);
//          TODO: This really should be logged
//            if (mInitialized) {
//                final Log log = mLogFactory.getInstance(this.getClass());
//                log.error("Error resolving near " + expression);
//            }
        }

        return result;
    }

    private IClass resolveTypecast(
        SymTabAST node,
        Scope location,
        IClass context,
        boolean referencePhase) {
        SymTabAST typeNode = (SymTabAST) node.getFirstChild();
        SymTabAST exprNode = (SymTabAST) typeNode.getNextSibling();
        //handle Checkstyle grammar
        if (exprNode.getType() == TokenTypes.RPAREN) {
            exprNode = (SymTabAST) exprNode.getNextSibling();
        }

        IClass type = null;

        final SymTabAST child = (SymTabAST) typeNode.getFirstChild();
        // TODO: Checkstyle change.
        // Do not create references from typecast.
        // Original transmogrify code is equivalent to
        // final boolean createReference = referencePhase;
        // which creates non-existant references for variables.
        final boolean createReference = false;
        if (child.getType()
            == TokenTypes.ARRAY_DECLARATOR) {
            type =
                new ArrayDef(
                    resolveType(
                        (SymTabAST) typeNode.getFirstChild(),
                        location,
                        context,
                        createReference));
        }
        else {
            type = resolveType(typeNode, location, context, createReference);
        }

        resolveExpression(exprNode, location, context, referencePhase);
        //TODO: Checkstyle change. Can this be ignored?
        if (type != null) {
            ((SymTabAST) typeNode.getFirstChild()).setDefinition(
                type,
                location,
                referencePhase);
        }

        return type;
    }

    private IClass resolveArrayAccess(
        SymTabAST node,
        Scope location,
        IClass context,
        boolean referencePhase) {

        SymTabAST arrayNode = (SymTabAST) (node.getFirstChild());
        SymTabAST exprNode = (SymTabAST) (arrayNode.getNextSibling());

        //resolve index expressions
        while (arrayNode.getType() == TokenTypes.INDEX_OP) {
            resolveExpression(exprNode, location, context, referencePhase);
            arrayNode = (SymTabAST) (arrayNode.getFirstChild());
            exprNode = (SymTabAST) (arrayNode.getNextSibling()); 
        }
        
        ArrayDef array =
            (ArrayDef) resolveExpression(arrayNode,
                location,
                context,
                referencePhase);

        resolveExpression(exprNode, location, context, referencePhase);

        return array.getType();
    }

    private IClass resolveLiteralClass() {
        return new ExternalClass(Class.class);
    }

    /**
     * Resolves any dotted reference, returning the <code>Scope</code>
     * identified by the reference.
     *
     * @param tree the root node of the dotted reference
     * @param location the <code>Scope</code> in which the expression occours.
     * @param context the <code>Scope</code> in which the search for the
     *                definition will start
     * @return the <code>Scope</code> indentified by the reference
     */
    private IClass resolveDottedName(
        SymTabAST tree,
        Scope location,
        IClass context,
        boolean referencePhase) {
        IClass result = null;

        IClass localContext = context;
        String name = null;

        DotIterator it = new DotIterator(tree);
        while (it.hasNext()) {
            SymTabAST node = it.nextNode();
            if (node.getType() != TokenTypes.COMMA) {
                localContext =
                    resolveExpression(
                        node,
                        location,
                        localContext,
                        referencePhase);
                if (localContext == null) {
                    node.setMeaningfulness(false);
                    name = node.getText();
                    while (localContext == null && it.hasNext()) {
                        SymTabAST next = it.nextNode();
                        name = name + "." + next.getText();
                        localContext = location.getClassDefinition(name);
                        if (localContext != null && referencePhase) {
                            next.setDefinition(
                                localContext,
                                location,
                                referencePhase);
                        }
                        else {
                            next.setMeaningfulness(false);
                        }
                    }
                }
            }
        }

        if (localContext != null) {
            result = localContext;
        }
        else {
            result = new UnknownClass(name, tree);
        }

        return result;
    }

    /**
     * Resolves a method call.
     *
     * @param methodNode the <code>SymTabAST</code> for the METHOD_CALL node
     * @param location the <code>Scope</code> where the expression occurs
     * @param context the <code>Scope</code> in which the expression occurs
     *                (where the search for a defintion begins)
     * @param referencePhase whether or not this is the reference phase of
     *                       table construction
     *
     * @return the <code>ClassDef</code> for the type returned by the method
     */
    private IClass resolveMethod(
        SymTabAST methodNode,
        Scope location,
        IClass context,
        boolean referencePhase) {
        IClass result = new UnknownClass(methodNode.getText(), methodNode);
        IClass newContext = null;

        if (context == null) {
            newContext = location.getEnclosingClass();
        }
        else {
            newContext = context;
        }

        String name = null;
        boolean createReference = true;

        SymTabAST nameNode = (SymTabAST) (methodNode.getFirstChild());
        SymTabAST parametersNode = (SymTabAST) (nameNode.getNextSibling());

        ISignature signature =
            resolveParameters(
                parametersNode,
                location,
                context,
                referencePhase);

        if (nameNode.getType() == TokenTypes.IDENT) {
            name = nameNode.getText();
        }
        else if (
            nameNode.getType() == TokenTypes.LITERAL_SUPER
                || (nameNode.getType() == TokenTypes.SUPER_CTOR_CALL)) {
            IClass superclass = location.getEnclosingClass().getSuperclass();
            newContext = superclass;
            name = superclass.getName();
            createReference = false;
        }
        else if (nameNode.getType() == TokenTypes.LITERAL_THIS) {
            newContext = location.getEnclosingClass();
            name = newContext.getName();
            createReference = false;
        }
        else {
            // REDTAG -- doing dotted name resolution on its own
            SymTabAST contextNode = (SymTabAST) (nameNode.getFirstChild());
            //TODO: handle Checkstyle grammar
            nameNode = (SymTabAST) contextNode.getNextSibling();
            //skip to IDENT
            while (nameNode.getType() != TokenTypes.IDENT) {
                nameNode = (SymTabAST) nameNode.getNextSibling();
            }
            
            name = nameNode.getText();
            newContext =
                resolveExpression(
                    contextNode,
                    location,
                    context,
                    referencePhase);
        }

        if (newContext != null) {