git_sniffer 0.0.1

data/third_party_tools/checkstyle-5.6/contrib/usage/src/checkstyle/com/puppycrawl/tools/checkstyle/checks/usage/transmogrify/ReferenceThreshold.java

@@ -0,0 +1,78 @@
+
+// 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.Set;
+import java.util.TreeSet;
+
+
+
+public class ReferenceThreshold extends ReferenceTool {
+  private Set _underreferencedDefinitions;
+  private int _threshold;
+
+  public ReferenceThreshold(SymbolTable table, int threshold) {
+    super(table.getTree());
+    _threshold = threshold;
+    _underreferencedDefinitions = new TreeSet();
+    go();
+  }
+
+  private void go() {
+    collectUnderreferencedDefinitions();
+  }
+
+  private void collectUnderreferencedDefinitions() {
+    handleNode(_tree);
+  }
+
+  protected void handleNode(SymTabAST node) {
+    if (node.isMeaningful()) {
+      IDefinition def = node.getDefinition();
+      if (def != null &&
+          def.getNumReferences() <= _threshold &&
+          def instanceof Definition) {
+        // this is inheritently hackish
+        // basically we want to ignore
+        // all test cases and main() methods
+        if (def.getQualifiedName().indexOf("test") < 0 &&
+            def.getQualifiedName().indexOf("main") < 0) {
+          _underreferencedDefinitions.add(def);
+        }
+      }
+    }
+
+    walkChildren(node);
+  }
+
+  public Set getUnderreferencedDefinitions() {
+    return _underreferencedDefinitions;
+  }
+}

data/third_party_tools/checkstyle-5.6/contrib/usage/src/checkstyle/com/puppycrawl/tools/checkstyle/checks/usage/transmogrify/ReferenceTool.java

@@ -0,0 +1,55 @@
+
+// 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;
+
+
+public abstract class ReferenceTool {
+  protected SymTabAST _tree = null;
+
+  public ReferenceTool(SymTabAST tree) {
+    _tree = tree;
+  }
+
+  protected void walkChildren( SymTabAST node ) {
+    if ( node.getFirstChild() != null ) {
+      walkSelfAndSiblings( (SymTabAST)node.getFirstChild() );
+    }
+  }
+
+  private void walkSelfAndSiblings( SymTabAST node ) {
+    handleNode( node );
+    SymTabAST sibling = (SymTabAST)node.getNextSibling();
+    while ( sibling != null ) {
+      handleNode( sibling );
+      sibling = (SymTabAST)sibling.getNextSibling();
+    }
+  }
+
+  protected abstract void handleNode(SymTabAST node);
+}

data/third_party_tools/checkstyle-5.6/contrib/usage/src/checkstyle/com/puppycrawl/tools/checkstyle/checks/usage/transmogrify/Resolver.java

@@ -0,0 +1,1893 @@
+
+// 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);
+
+            if(extendsClause != null) {
+                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;
+    }
+}