Java tutorial
// Transmogrify License // // Copyright (c) 2001, ThoughtWorks, Inc. // All rights reserved. // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions // are met: // - Redistributions of source code must retain the above copyright notice, // this list of conditions and the following disclaimer. // - Redistributions in binary form must reproduce the above copyright // notice, this list of conditions and the following disclaimer in the // documentation and/or other materials provided with the distribution. // Neither the name of the ThoughtWorks, Inc. nor the names of its // contributors may be used to endorse or promote products derived from this // software without specific prior written permission. // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED // TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; // OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF // ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. package com.puppycrawl.tools.checkstyle.checks.usage.transmogrify; import java.util.Vector; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogConfigurationException; import org.apache.commons.logging.LogFactory; import com.puppycrawl.tools.checkstyle.api.TokenTypes; /** * The resolver is responsible for traversing all the various * definitions in a symbol table and resolving references in them. * * @see SymbolTable */ public class Resolver extends DefinitionTraverser { /** true if the log factory has been initialized */ private boolean mInitialized = false; /** Factory for creating org.apache.commons.logging.Log instances */ private LogFactory mLogFactory; /** * constructor with <code>SymbolTable</code> to be resolved */ public Resolver(SymbolTable symbolTable) { super(symbolTable); try { mLogFactory = LogFactory.getFactory(); } catch (LogConfigurationException e) { System.out.println("log configuration exception" + e); } mInitialized = true; } /** * resolves the symbol table * @return <code>void</code> * @see #traverse() */ public void resolve() { traverse(); } protected void handleSList(SymTabAST node, Scope scope) { SymTabASTIterator iterator = node.getChildren(); while (iterator.hasNext()) { SymTabAST current = iterator.nextChild(); resolveExpression(current, scope, null, true); } } protected void handleAnonymousInnerClass(AnonymousInnerClass innerClass) { SymTabAST objblock = innerClass.getTreeNode(); SymTabAST expression = (SymTabAST) objblock.getFirstChild(); while (expression != null) { resolveExpression(expression, innerClass, null, true); expression = (SymTabAST) expression.getNextSibling(); } } /** * processes a <code>ClassDef</code> and resolves references in it * * @param classDef the <code>ClassDef</code> to process */ protected void handleClass(ClassDef classDef) { SymTabAST node = classDef.getTreeNode(); if (node != null) { SymTabAST nameNode = node.findFirstToken(TokenTypes.IDENT); nameNode.setDefinition(classDef, classDef, true); SymTabAST extendsClause = node.findFirstToken(TokenTypes.EXTENDS_CLAUSE); SymTabAST extendedClassNode = (SymTabAST) extendsClause.getFirstChild(); while (extendedClassNode != null) { IClass superClass = resolveClass(extendedClassNode, classDef, null, true); extendedClassNode.setDefinition(superClass, classDef, true); extendedClassNode = (SymTabAST) extendedClassNode.getNextSibling(); } SymTabAST implementsNode = node.findFirstToken(TokenTypes.IMPLEMENTS_CLAUSE); if (implementsNode != null) { SymTabAST interfaceNode = (SymTabAST) (implementsNode.getFirstChild()); while (interfaceNode != null) { resolveClass(interfaceNode, classDef, null, true); interfaceNode = (SymTabAST) (interfaceNode.getNextSibling()); } } } } /** * processes a <code>MethodDef</code> and resolves references in it * * @param method the <code>MethodDef</code> to process */ protected void handleMethod(MethodDef method) { SymTabAST node = method.getTreeNode(); SymTabAST nameNode = node.findFirstToken(TokenTypes.IDENT); nameNode.setDefinition(method, method, true); // references to classes in return type SymTabAST returnTypeNode = node.findFirstToken(TokenTypes.TYPE); if (returnTypeNode != null) { // this is not a constructor resolveExpression(returnTypeNode, method, null, true); } SymTabAST throwsNode = node.findFirstToken(TokenTypes.LITERAL_THROWS); if (throwsNode != null) { SymTabAST exception = (SymTabAST) throwsNode.getFirstChild(); while (exception != null) { // handle Checkstyle grammar if (exception.getType() != TokenTypes.COMMA) { resolveClass(exception, method, null, true); } exception = (SymTabAST) exception.getNextSibling(); } } // references to classes in parameters // the body -- this would be better its own function SymTabAST slist = node.findFirstToken(TokenTypes.SLIST); if (slist != null) { handleSList(slist, method); } } /** * processes a <code>BlockDef</code> and resolves references in it * * @param block the <code>BlockDef</code> to process */ protected void handleBlock(BlockDef block) { SymTabAST node = block.getTreeNode(); switch (node.getType()) { case TokenTypes.LITERAL_FOR: handleFor(block); break; case TokenTypes.LITERAL_IF: handleIf(block); break; case TokenTypes.LITERAL_WHILE: handleWhileAndSynchronized(block); break; case TokenTypes.LITERAL_DO: handleDoWhile(block); break; case TokenTypes.LITERAL_TRY: case TokenTypes.LITERAL_FINALLY: SymTabAST slist = node.findFirstToken(TokenTypes.SLIST); handleSList(slist, block); break; case TokenTypes.LITERAL_CATCH: handleCatch(block); break; case TokenTypes.LITERAL_SWITCH: handleSwitch(block); break; case TokenTypes.SLIST: handleSList(node, block); break; case TokenTypes.EXPR: resolveExpression(node, block, null, true); break; case TokenTypes.INSTANCE_INIT: case TokenTypes.STATIC_INIT: handleSList((SymTabAST) node.getFirstChild(), block); break; case TokenTypes.LITERAL_SYNCHRONIZED: handleWhileAndSynchronized(block); break; case TokenTypes.LITERAL_ASSERT: handleAssert(block); break; default: if (mInitialized) { final Log log = mLogFactory.getInstance(this.getClass()); log.error("Unhandled block " + block + " of type " + node.getType()); } } } /** * @param block */ private void handleAssert(BlockDef block) { SymTabAST node = block.getTreeNode(); SymTabAST conditional = (node.findFirstToken(TokenTypes.EXPR)); resolveExpression(conditional, block, null, true); SymTabAST message = (SymTabAST) conditional.getNextSibling(); while ((message != null) && (message.getType() != TokenTypes.EXPR)) { message = (SymTabAST) message.getNextSibling(); } if (message != null) { resolveExpression(message, block, null, true); } } /** * processes a switch statement and resolves references in it * * @param block the <code>BlockDef</code> to process */ private void handleSwitch(BlockDef block) { SymTabAST node = block.getTreeNode(); SymTabAST expr = node.findFirstToken(TokenTypes.EXPR); resolveExpression(expr, block, null, true); SymTabAST caseGroup = (SymTabAST) (expr.getNextSibling()); while (caseGroup != null && (caseGroup.getType() != TokenTypes.CASE_GROUP)) { caseGroup = (SymTabAST) caseGroup.getNextSibling(); } if (caseGroup != null) { while (caseGroup.getType() == TokenTypes.CASE_GROUP) { SymTabAST caseNode = caseGroup.findFirstToken(TokenTypes.LITERAL_CASE); while (caseNode != null && caseNode.getType() == TokenTypes.LITERAL_CASE) { resolveExpression((SymTabAST) caseNode.getFirstChild(), block, null, true); caseNode = (SymTabAST) caseNode.getNextSibling(); } SymTabAST caseSlist = caseGroup.findFirstToken(TokenTypes.SLIST); handleSList(caseSlist, block); caseGroup = (SymTabAST) (caseGroup.getNextSibling()); } } } /** * processes a catch block and resolves references in it * * @param block the <code>BlockDef</code> to process */ private void handleCatch(BlockDef block) { SymTabAST node = block.getTreeNode(); SymTabAST slist = node.findFirstToken(TokenTypes.SLIST); handleSList(slist, block); } /** * processes a for loop and resolves references in it * * @param block the <code>BlockDef</code> to process */ private void handleFor(BlockDef block) { SymTabAST node = block.getTreeNode(); SymTabAST body; SymTabAST forEach = node.findFirstToken(TokenTypes.FOR_EACH_CLAUSE); if (forEach == null) { SymTabAST init = node.findFirstToken(TokenTypes.FOR_INIT); // only need to handle the elist case. if the init node is a variable // definition, the variable def will be handled later on in the resolution if (init.getFirstChild() != null) { if (init.getFirstChild().getType() == TokenTypes.ELIST) { resolveExpression((SymTabAST) (init.getFirstChild()), block, null, true); } } SymTabAST cond = node.findFirstToken(TokenTypes.FOR_CONDITION); if (cond.getFirstChild() != null) { resolveExpression((SymTabAST) (cond.getFirstChild()), block, null, true); } SymTabAST iterator = node.findFirstToken(TokenTypes.FOR_ITERATOR); if (iterator.getFirstChild() != null) { resolveExpression((SymTabAST) (iterator.getFirstChild()), block, null, true); } body = (SymTabAST) (iterator.getNextSibling()); } else { resolveExpression((forEach.findFirstToken(TokenTypes.EXPR)), block, null, true); body = (SymTabAST) (forEach.getNextSibling()); } //could be an SLIST, EXPR or an EMPTY_STAT if (body.getType() == TokenTypes.RPAREN) { body = (SymTabAST) body.getNextSibling(); } if (body.getType() == TokenTypes.SLIST) { handleSList(body, block); } else { resolveExpression(body, block, null, true); } } /** * processes an if statement and resolves references in it * * @param block the <code>BlockDef</code> to process */ private void handleIf(BlockDef block) { SymTabAST node = block.getTreeNode(); SymTabAST conditional = (node.findFirstToken(TokenTypes.EXPR)); resolveExpression(conditional, block, null, true); SymTabAST body = (SymTabAST) conditional.getNextSibling(); // Handle Checkstyle grammar if (body.getType() == TokenTypes.RPAREN) { body = (SymTabAST) body.getNextSibling(); } if (body != null) { if (body.getType() == TokenTypes.SLIST) { handleSList(body, block); } else { resolveExpression(body, block, null, true); } SymTabAST elseBody = (SymTabAST) body.getNextSibling(); //handle Checkstyle grammar while ((elseBody != null) && (elseBody.getType() != TokenTypes.LITERAL_ELSE)) { elseBody = (SymTabAST) elseBody.getNextSibling(); } /* if (elseBody != null && elseBody.getType() == TokenTypes.SLIST) { handleSList(elseBody, block); }else{ resolveExpression(elseBody, block, null, true); } */ if (elseBody != null) { elseBody = (SymTabAST) elseBody.getFirstChild(); } if (elseBody != null) { resolveExpression(elseBody, block.getParentScope(), null, true); } } } /** * processes a while loop and resolves references in it * * @param block the <code>BlockDef</code> to process */ private void handleWhileAndSynchronized(BlockDef block) { SymTabAST node = block.getTreeNode(); SymTabAST condition = (node.findFirstToken(TokenTypes.EXPR)); SymTabAST slist = (SymTabAST) (condition.getNextSibling()); // handle Checkstyle grammar if (slist.getType() == TokenTypes.RPAREN) { slist = (SymTabAST) slist.getNextSibling(); } resolveExpression(condition, block, null, true); handleSList(slist, block); } private void handleDoWhile(BlockDef block) { SymTabAST node = block.getTreeNode(); SymTabAST slist = (SymTabAST) node.getFirstChild(); SymTabAST condition = node.findFirstToken(TokenTypes.EXPR); handleSList(slist, block); resolveExpression(condition, block, null, true); } /** * processes a variable definition and resolves references in it * * @param variable the <code>VariableDef</code> to process */ protected void handleVariable(VariableDef variable) { SymTabAST node = variable.getTreeNode(); Scope location = variable.getParentScope(); SymTabAST nameNode = node.findFirstToken(TokenTypes.IDENT); nameNode.setDefinition(variable, location, true); SymTabAST typeNode = node.findFirstToken(TokenTypes.TYPE); resolveType(typeNode, location, null, true); SymTabAST assignmentNode = node.findFirstToken(TokenTypes.ASSIGN); if (assignmentNode != null) { resolveExpression((SymTabAST) (assignmentNode.getFirstChild()), variable.getParentScope(), null, true); } } /** * processes a label and resolves references in it * * @param label the <code>LabelDef</code> to process */ protected void handleLabel(LabelDef label) { SymTabAST node = label.getTreeNode(); ((SymTabAST) node.getFirstChild()).setDefinition(label, label.getParentScope(), true); } /** * Resolves Java expressions, returning the type to which the expression * evalutes. If this is the reference creation phase, any references found during resolution are created and * resolved. * * @param expression the <code>SymTabAST</code> representing the expression * @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 * @param referencePhase whether or not this is the reference phase of * table construction * * @return the <code>ClassDef</code> representing the type to which the * expression evalutes. */ public IClass resolveExpression(SymTabAST expression, Scope location, IClass context, boolean referencePhase) { IClass result = null; try { switch (expression.getType()) { case TokenTypes.TYPECAST: result = resolveTypecast(expression, location, context, referencePhase); break; case TokenTypes.EXPR: case TokenTypes.LITERAL_RETURN: if (expression.getFirstChild() != null) { result = resolveExpression((SymTabAST) expression.getFirstChild(), location, context, referencePhase); } else { // YOU WRITE BAD CODE! } break; case TokenTypes.ELIST: SymTabAST child = (SymTabAST) (expression.getFirstChild()); while (child != null) { if (child.getType() != TokenTypes.COMMA) { resolveExpression(child, location, context, referencePhase); } child = (SymTabAST) (child.getNextSibling()); } break; case TokenTypes.IDENT: result = resolveIdent(expression, location, context, referencePhase); break; case TokenTypes.TYPE: result = resolveType(expression, location, context, referencePhase); break; case TokenTypes.METHOD_CALL: //case TokenTypes.SUPER_CTOR_CALL : result = resolveMethod(expression, location, context, referencePhase); break; case TokenTypes.LITERAL_THIS: result = resolveLiteralThis(expression, location, context); break; case TokenTypes.LITERAL_SUPER: result = resolveLiteralSuper(expression, location, context); break; case TokenTypes.DOT: result = resolveDottedName(expression, location, context, referencePhase); break; case TokenTypes.LITERAL_NEW: case TokenTypes.CTOR_CALL: case TokenTypes.SUPER_CTOR_CALL: result = resolveNew(expression, location, context, referencePhase); break; case TokenTypes.LITERAL_BOOLEAN: case TokenTypes.LITERAL_DOUBLE: case TokenTypes.LITERAL_FLOAT: case TokenTypes.LITERAL_LONG: case TokenTypes.LITERAL_INT: case TokenTypes.LITERAL_SHORT: case TokenTypes.LITERAL_BYTE: case TokenTypes.LITERAL_CHAR: result = resolvePrimitiveType(expression, location, context, referencePhase); break; case TokenTypes.NUM_INT: case TokenTypes.NUM_LONG: result = resolveNumInt(expression, location, context); break; case TokenTypes.NUM_FLOAT: case TokenTypes.NUM_DOUBLE: result = resolveNumFloat(expression, location, context); break; case TokenTypes.STRING_LITERAL: result = resolveStringLiteral(expression, location, context); break; case TokenTypes.CHAR_LITERAL: result = resolveCharLiteral(expression, location, context); break; case TokenTypes.ASSIGN: case TokenTypes.PLUS_ASSIGN: case TokenTypes.MINUS_ASSIGN: case TokenTypes.STAR_ASSIGN: case TokenTypes.DIV_ASSIGN: case TokenTypes.MOD_ASSIGN: case TokenTypes.SR_ASSIGN: case TokenTypes.BSR_ASSIGN: case TokenTypes.SL_ASSIGN: case TokenTypes.BAND_ASSIGN: case TokenTypes.BXOR_ASSIGN: case TokenTypes.BOR_ASSIGN: resolveAssignment(expression, location, context, referencePhase); break; case TokenTypes.LOR: case TokenTypes.LAND: case TokenTypes.NOT_EQUAL: case TokenTypes.EQUAL: case TokenTypes.LT: case TokenTypes.GT: case TokenTypes.LE: case TokenTypes.GE: result = resolveBooleanExpression(expression, location, context, referencePhase); break; case TokenTypes.LITERAL_INSTANCEOF: result = resolveInstanceOf(expression, location, context, referencePhase); break; case TokenTypes.LITERAL_TRUE: case TokenTypes.LITERAL_FALSE: result = resolveBooleanLiteral(expression, location, context); break; case TokenTypes.LNOT: result = resolveBooleanUnary(expression, location, context, referencePhase); break; case TokenTypes.INC: case TokenTypes.POST_INC: case TokenTypes.DEC: case TokenTypes.POST_DEC: case TokenTypes.UNARY_PLUS: case TokenTypes.UNARY_MINUS: result = resolveUnaryExpression(expression, location, context, referencePhase); break; case TokenTypes.PLUS: case TokenTypes.MINUS: case TokenTypes.DIV: 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) { IMethod method = newContext.getMethodDefinition(name, signature); if (method != null) { if (createReference && referencePhase) { nameNode.setDefinition(method, location, referencePhase); } result = method.getType(); } } if (result == null) { result = new UnknownClass(methodNode.getText(), methodNode); } return result; } /** * resolves a literal "this" * * @param expression the <code>SymTabAST</code> of the expression * @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) * * @return the resulting scope of the expression (the type to which it evaluates) */ private IClass resolveLiteralThis(SymTabAST thisNode, Scope location, IClass context) { return location.getEnclosingClass(); } /** * resolves a literal "super" * * @param expression the <code>SymTabAST</code> of the expression * @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) * * @return the resulting scope of the expression (the type to which it evaluates) */ private IClass resolveLiteralSuper(SymTabAST superNode, Scope location, IClass context) { return location.getEnclosingClass().getSuperclass(); } private boolean newIsConstructor(SymTabAST newNode) { boolean result = false; SymTabAST typeNode = (SymTabAST) (newNode.getFirstChild().getNextSibling()); //handle Checkstyle grammar if (typeNode.getType() == TokenTypes.LPAREN) { typeNode = (SymTabAST) typeNode.getNextSibling(); } if (typeNode.getType() == TokenTypes.ELIST) { result = true; } return result; } /** * resolves and expression of type TokenTypes.TYPE * * @param expression the <code>SymTabAST</code> of the expression * @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 resulting scope of the expression (the type to which it evaluates) * @see #resolveDottedName(SymTabAST, Scope, IClass, boolean) * @see #resolveClassIdent(SymTabAST, Scope, IClass, boolean) */ public IClass resolveType(SymTabAST expr, Scope location, IClass context, boolean referencePhase) { IClass result = null; SymTabAST nameNode = (SymTabAST) expr.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 (nameNode.getType() == TokenTypes.DOT) { result = resolveDottedName(nameNode, location, context, createReference); } else { result = resolveClassIdent(nameNode, location, context, createReference); } return result; } /** * resolves Class type expression * @param expr node to be resolved * @param location scope of the <code>expr</code> * @param context context of the <code>expr</code> if exists * @param referencePhase <code>true</code> if this method is used to during * finding reference phase * <code>false</code> otherwise * @return <code>IClass</code> representing the type to which the * expression evalutes. * @see #resolveDottedName(SymTabAST, Scope, IClass, boolean) */ public IClass resolveClass(SymTabAST expr, Scope location, IClass context, boolean referencePhase) { IClass result = resolveDottedName(expr, location, context, referencePhase); if (result != null && referencePhase) { expr.setDefinition(result, location, referencePhase); } return result; } /** * resolves expression with <code>JavaTokenTypes<code> other than <code>DOT</code> * @param expr expression to be resolved * @param location scope of the expression * @param context context of the expression if any * @param referencePhase <code>true</code> if this method is used to during * finding reference phase * <code>false</code> otherwise * @return <code>IClass</code> representing the type to which the * expression evalutes. */ public IClass resolveClassIdent(SymTabAST expr, Scope location, IClass context, boolean referencePhase) { IClass result = location.getClassDefinition(expr.getText()); if (result != null) { expr.setDefinition(result, location, referencePhase); } return result; } private IClass resolveNew(SymTabAST newNode, Scope location, IClass context, boolean referencePhase) { IClass result; if (newIsConstructor(newNode)) { result = resolveConstructor(newNode, location, context, referencePhase); } else { result = resolveNewArray(newNode, location, context, referencePhase); } return result; } private IClass resolveNewArray(SymTabAST newNode, Scope location, IClass context, boolean referencePhase) { IClass arrayType; SymTabAST typeNode = (SymTabAST) (newNode.getFirstChild()); SymTabAST declaratorNode = (SymTabAST) (typeNode.getNextSibling()); SymTabAST initializerNode = (SymTabAST) (declaratorNode.getNextSibling()); arrayType = resolveClass(typeNode, location, context, referencePhase); if (declaratorNode.getFirstChild() != null) { resolveExpression(((SymTabAST) declaratorNode.getFirstChild()), location, context, referencePhase); } if (initializerNode != null) { resolveArrayInitializer(initializerNode, location, context, referencePhase); } return new ArrayDef(arrayType); } private IClass resolveQuestion(SymTabAST question, Scope location, IClass context, boolean referencePhase) { SymTabAST test = (SymTabAST) question.getFirstChild(); while (test.getType() == TokenTypes.LPAREN) { test = (SymTabAST) test.getNextSibling(); } SymTabAST leftBranch = (SymTabAST) test.getNextSibling(); while (leftBranch.getType() == TokenTypes.RPAREN) { leftBranch = (SymTabAST) leftBranch.getNextSibling(); } SymTabAST rightBranch = (SymTabAST) leftBranch.getNextSibling(); while (rightBranch.getType() != TokenTypes.COLON) { rightBranch = (SymTabAST) rightBranch.getNextSibling(); } rightBranch = (SymTabAST) rightBranch.getNextSibling(); resolveExpression(test, location, context, referencePhase); IClass leftClass = resolveExpression(leftBranch, location, context, referencePhase); IClass rightClass = resolveExpression(rightBranch, location, context, referencePhase); return moreGeneral(leftClass, rightClass); } private IClass moreGeneral(IClass a, IClass b) { return (a.isCompatibleWith(b)) ? b : a; } /** * Resolves a constructor call. * * @param tree the root node of the constructor call * @return the <code>ClassDef</code> for the class instantiated by the * constructor */ private IClass resolveConstructor(SymTabAST constructor, Scope location, IClass context, boolean referencePhase) { IClass classConstructed = null; SymTabAST nameNode = (SymTabAST) (constructor.getFirstChild()); //SymTabAST parametersNode = (SymTabAST) (nameNode.getNextSibling()); SymTabAST parametersNode = constructor.findFirstToken(TokenTypes.ELIST); SymTabAST nameIdent = null; if (nameNode.getType() == TokenTypes.IDENT) { nameIdent = nameNode; } else { nameIdent = (SymTabAST) nameNode.getFirstChild().getNextSibling(); } classConstructed = resolveClass(nameNode, location, context, false); if (classConstructed != null) { MethodSignature signature = resolveParameters(parametersNode, location, context, referencePhase); IMethod constructorDef = classConstructed.getMethodDefinition(nameIdent.getText(), signature); if (constructorDef != null && referencePhase) { nameIdent.setDefinition(constructorDef, location, referencePhase); } } return classConstructed; } /** * Resolves the types found in a method call. Any references found * in the process are created. Returns a <code>MethodSignature</code> for * the types of the parameters. * * @param elist The <code>SymTabAST</code> for the list of parameters * @return the signature of the parameters */ private MethodSignature resolveParameters(SymTabAST elist, Scope location, IClass context, boolean referencePhase) { Vector parameters = new Vector(); SymTabAST expr = (SymTabAST) (elist.getFirstChild()); while (expr != null) { if (expr.getType() != TokenTypes.COMMA) { IClass parameter = resolveExpression((SymTabAST) (expr.getFirstChild()), location, context, referencePhase); parameters.add(parameter); } expr = (SymTabAST) (expr.getNextSibling()); } return new MethodSignature(parameters); } /** * Resolves an IDENT node of an AST, creating the appropriate reference and * returning the scope of the identifer. * * @param ident the IDENT node * @param location the <code>Scope</code> in which the IDENT is found * @return the <code>Scope</code> the identifier identifies */ private IClass resolveIdent(SymTabAST ident, Scope location, IClass context, boolean referencePhase) { IClass result = null; IDefinition def = null; String name = ident.getText(); // look for var if (context != null) { def = context.getVariableDefinition(name); } else { def = location.getVariableDefinition(name); } if (def != null) { result = ((IVariable) def).getType(); } else { // look for class if (context != null) { result = context.getClassDefinition(name); } else { result = location.getClassDefinition(name); } def = result; } if (def != null) { ident.setDefinition(def, location, referencePhase); } return result; } /** * Resolves a (binary) boolean expression. The left and right sides of the * expression * are resolved in the process. * * @param expression the <code>SymTabAST</code> representing the boolean * expression. * @return the <code>Scope</code> for the boolean primitive type. */ private IClass resolveBooleanExpression(SymTabAST expression, Scope location, IClass context, boolean referencePhase) { IClass result = null; SymTabAST leftChild = findLeftChild(expression); resolveExpression(leftChild, location, context, referencePhase); SymTabAST rightChild = findRightSibling(leftChild); resolveExpression(rightChild, location, context, referencePhase); result = LiteralResolver.getDefinition(TokenTypes.LITERAL_BOOLEAN); return result; } /** * resolves references in an assignment expression * * @param expression the <code>SymTabAST</code> of the expression * @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) * * @return the resulting scope of the expression (the type to which it evaluates) */ private IClass resolveAssignment(SymTabAST expression, Scope location, IClass context, boolean referencePhase) { IClass result = null; SymTabAST leftNode = (SymTabAST) (expression.getFirstChild()); SymTabAST rightNode = (SymTabAST) (leftNode.getNextSibling()); result = resolveExpression(leftNode, location, context, referencePhase); resolveExpression(rightNode, location, context, referencePhase); return result; } /** * Resolves a unary expression. Returns the type of the expression, * creating any references found along the way. Unary expressions are * increment (x++), decrement (x--), unary plus (+x), and unary minus (-x) * * @param expression the <code>SymTabAST</code> of the unary expression. * @return the <code>Scope</code> for the type to which the expression * evalutes. */ private IClass resolveUnaryExpression(SymTabAST expression, Scope location, IClass context, boolean referencePhase) { SymTabAST operatee = (SymTabAST) (expression.getFirstChild()); return resolveExpression(operatee, location, context, referencePhase); } /** * Resolves an arithmetic expression. Returns the <code>Scope</code> for * the type to which the expression resolves. Any references found during * resolution are created and resolved. * * @param expression the <code>SymTabAST</code> representing the arithmetic * expression. * * @return the <code>Scope</code> for the type to which the expression * evaluates. */ private IClass resolveArithmeticExpression(SymTabAST expression, Scope location, IClass context, boolean referencePhase) { IClass result = null; SymTabAST leftChild = findLeftChild(expression); IClass leftType = (resolveExpression(leftChild, location, context, referencePhase)); SymTabAST rightChild = findRightSibling(leftChild); IClass rightType = (resolveExpression(rightChild, location, context, referencePhase)); result = binaryResultType(leftType, rightType); return result; } /** * Finds the left child of a binary operator, skipping parentheses. * @param aExpression the node for the binary operator. * @return the node for the left child. */ private SymTabAST findLeftChild(SymTabAST aExpression) { SymTabAST leftChild = (SymTabAST) (aExpression.getFirstChild()); // handle Checkstyle grammar while (leftChild.getType() == TokenTypes.LPAREN) { leftChild = (SymTabAST) leftChild.getNextSibling(); } return leftChild; } /** * Finds the right sibling of the left child of a binary operator, * skipping parentheses. * @param aLeftChild the left child of a binary operator. * @return the node of the right sibling. */ private SymTabAST findRightSibling(SymTabAST aLeftChild) { SymTabAST rightChild = (SymTabAST) (aLeftChild.getNextSibling()); // handle Checkstyle grammar while ((rightChild != null) && (rightChild.getType() == TokenTypes.RPAREN)) { rightChild = (SymTabAST) rightChild.getNextSibling(); } return rightChild; } /** * Returns the <code>ClassDef</code> for the type to which arithmetic * expressions evaluate. * * @param a the <code>ClassDef</code> of the first operand. * @param b the <code>ClassDef</code> of the second operand. * * @return the <code>ClassDef</code> to which the expression evaluates. */ private IClass binaryResultType(IClass a, IClass b) { IClass result = null; // These may or may not be in line with the rules set forth in the java // language specification. Not being in line would be a BadThing(r). IClass string = new ExternalClass(java.lang.String.class); if (a.equals(string) || b.equals(string)) { result = string; } else if (a.equals(PrimitiveClasses.BOOLEAN)) { result = PrimitiveClasses.BOOLEAN; } else { result = PrimitiveClasses.binaryPromote(a, b); } return result; } /** * resolves references in an instanceof expression * * @param expression the <code>SymTabAST</code> of the expression * @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) * * @return the resulting scope of the expression (the type to which it evaluates) */ private IClass resolveInstanceOf(SymTabAST expression, Scope location, IClass context, boolean referencePhase) { SymTabAST leftNode = (SymTabAST) (expression.getFirstChild()); SymTabAST rightNode = (SymTabAST) (leftNode.getNextSibling()); resolveExpression(leftNode, location, context, referencePhase); SymTabAST classNameNode = (SymTabAST) (rightNode.getFirstChild()); resolveClass(classNameNode, location, context, referencePhase); return LiteralResolver.getDefinition(TokenTypes.LITERAL_BOOLEAN); } /** * resolves references in a a break statement * * @param expression the <code>SymTabAST</code> for the expression * @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) * * @return the <code>Scope</code> for the int primitive type */ private IClass resolveGoto(SymTabAST expression, Scope location, IClass context, boolean referencePhase) { SymTabAST label = (SymTabAST) (expression.getFirstChild()); // handle Checkstyle grammar if (label != null && (label.getType() != TokenTypes.SEMI)) { LabelDef def = location.getLabelDefinition(label.getText()); if (def != null) { label.setDefinition(def, location, referencePhase); } } return null; } private IClass resolvePrimitiveType(SymTabAST primitive, Scope location, IClass context, boolean referencePhase) { IClass result = LiteralResolver.getDefinition(primitive.getType()); primitive.setDefinition(result, location, referencePhase); return result; } /** * Returns the <code>ClassDef</code> of the int primitive type. This may * need to be amended, based on the Java Language spec, to return a long * if the literal is larger than an int can hold. * * @param expression the <code>SymTabAST</code> for the integer literal * @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) * * @return the <code>Scope</code> for the int primitive type */ private IClass resolveNumInt(SymTabAST expression, Scope location, IClass context) { return PrimitiveClasses.INT; } /** * Returns the <code>ClassDef</code> type of the float primitive type. * This may need to be amended, based on the Java Language spec, to return * a double if the literal is larger than a float can hold. * * @param expression the <code>SymTabAST</code> for the floating point literal * @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) * * @return the <code>Scope</code> for the float primitive type */ private IClass resolveNumFloat(SymTabAST expression, Scope location, IClass context) { return PrimitiveClasses.DOUBLE; } /** * Returns the <code>ClassDef</code> type of a string literal * * @param expression the <code>SymTabAST</code> for a string literal * @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) * * @return the <code>Scope</code> type of a string literal */ private IClass resolveStringLiteral(SymTabAST expression, Scope location, IClass context) { return LiteralResolver.getDefinition(TokenTypes.STRING_LITERAL); } /** * Returns the <code>ClassDef</code> type of a character literal * * @param expression the <code>SymTabAST</code> for a string literal * @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) * * @return the <code>Scope</code> type of a character literal */ private IClass resolveCharLiteral(SymTabAST expression, Scope location, IClass context) { return LiteralResolver.getDefinition(TokenTypes.LITERAL_CHAR); } /** * Describe <code>resolveBooleanLiteral</code> method here. * * @param expression the <code>SymTabAST</code> of the expression * @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) * * @return the <code>Scope</code> for the boolean primitive. */ private IClass resolveBooleanLiteral(SymTabAST expression, Scope location, IClass context) { return LiteralResolver.getDefinition(TokenTypes.LITERAL_BOOLEAN); } private IClass resolveBooleanUnary(SymTabAST expression, Scope location, IClass context, boolean referencePhase) { SymTabAST child = (SymTabAST) expression.getFirstChild(); resolveExpression(child, location, context, referencePhase); return LiteralResolver.getDefinition(TokenTypes.LITERAL_BOOLEAN); } /** * Resolves a constructor call. * * @param tree the root node of the constructor call * @return the <code>ClassDef</code> for the class instantiated by the * constructor */ private void resolveArrayInitializer(SymTabAST initializerNode, Scope location, IClass context, boolean referencePhase) { SymTabAST child = (SymTabAST) (initializerNode.getFirstChild()); while (child != null) { if (child.getType() != TokenTypes.COMMA) { resolveExpression(child, location, context, referencePhase); } child = (SymTabAST) (child.getNextSibling()); } } /** * Resolves a constructor call. * * @param tree the root node of the constructor call * @return the <code>ClassDef</code> for the class instantiated by the * constructor */ private void resolveThrowExpression(SymTabAST throwNode, Scope location, IClass context, boolean referencePhase) { SymTabAST nameNode = (SymTabAST) (throwNode.getFirstChild()); resolveExpression(nameNode, location, context, referencePhase); } private IClass resolveShiftOperator(SymTabAST expression, Scope location, IClass context, boolean referencePhase) { IClass result = null; SymTabAST leftChild = findLeftChild(expression); SymTabAST rightChild = findRightSibling(leftChild); result = resolveExpression(leftChild, location, context, referencePhase); resolveExpression(rightChild, location, context, referencePhase); result = PrimitiveClasses.unaryPromote(result); return result; } private IClass resolveBitwiseNot(SymTabAST expression, Scope location, IClass context, boolean referencePhase) { IClass result = null; SymTabAST child = (SymTabAST) expression.getFirstChild(); result = resolveExpression(child, location, context, referencePhase); result = PrimitiveClasses.unaryPromote(result); return result; } }