Use NodeElement to access Node in Resolver

compiler/java/com/google/dart/compiler/resolver/MemberBuilder.java

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 package com.google.dart.compiler.resolver;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.dart.compiler.DartCompilerContext;
 import com.google.dart.compiler.ErrorCode;
 import com.google.dart.compiler.ast.ASTVisitor;
@@ skipping 112 matching lines @@
                                                      parameters, returnType));
       currentHolder = libraryElement;
       context = topLevelContext;
       return null;
     }
 
     @Override
     public Element visitMethodDefinition(final DartMethodDefinition method) {
       isFactory = method.getModifiers().isFactory();
       isStatic = method.getModifiers().isStatic() || isFactory;
-      MethodElement element = method.getElement();
+      MethodNodeElement element = method.getElement();
       if (element == null) {
         switch (getMethodKind(method)) {
           case NONE:
           case CONSTRUCTOR:
             element = buildConstructor(method);
             checkConstructor(element, method);
-            addConstructor((ClassElement) currentHolder, (ConstructorElement) element);
+            addConstructor((ClassElement) currentHolder, (ConstructorNodeElement) element);
             break;
 
           case METHOD:
             element = Elements.methodFromMethodNode(method, currentHolder);
             addMethod(currentHolder, element);
             break;
         }
       } else {
         // This is a top-level element, and an element was already created in
         // TopLevelElementBuilder.
@@ skipping 74 matching lines @@
             recordElement(node.getExpression(), element);
           }
           return element;
         }
         @Override public Element visitNode(DartNode node) {
           throw new RuntimeException("Unexpected node " + node);
         }
       });
     }
 
-    private MethodElement buildConstructor(final DartMethodDefinition method) {
+    private MethodNodeElement buildConstructor(final DartMethodDefinition method) {
       // Resolve the constructor's name and class name.
       Element e = resolveConstructorName(method);
 
       switch (ElementKind.of(e)) {
         default:
           // Report an error and create a fake constructor element below.
           resolutionError(method.getName(), ResolverErrorCode.INVALID_TYPE_NAME_IN_CONSTRUCTOR);
           break;
 
         case DYNAMIC:
         case CLASS:
           break;
 
         case CONSTRUCTOR:
-          return (ConstructorElement) e;
+          return (ConstructorNodeElement) e;
       }
       // If the constructor name resolves to a class or there was an error,
       // create the unnamed constructor.
       return Elements.constructorFromMethodNode(method, "", (ClassElement) currentHolder,
                                                 (ClassElement) e);
     }
 
     private FieldElement buildField(DartField fieldNode, Type type) {
       assert !fieldNode.getModifiers().isAbstractField();
       Modifiers modifiers = fieldNode.getModifiers();
       if (modifiers.isFinal() && (modifiers.isStatic() || context == topLevelContext)) {
         // final toplevel fields are implicitly compile-time constants.
         modifiers = modifiers.makeStatic();
         // Set the "const" modifier so that it is easy to compare a constant field to other
         // types of constant expressions.
         modifiers = modifiers.makeConstant();
       }
-      FieldElement fieldElement = fieldNode.getElement();
+      FieldNodeElement fieldElement = fieldNode.getElement();
       if (fieldElement == null) {
         fieldElement = Elements.fieldFromNode(fieldNode, currentHolder, modifiers);
         addField(currentHolder, fieldElement);
       } else {
         // This is a top-level element, and an element was already created in
         // TopLevelElementBuilder.
         Elements.addField(currentHolder, fieldElement);
         assertTopLevel(fieldNode);
       }
       fieldElement.setType(type);
@@ skipping 40 matching lines @@
      *     + setter:
      *       MethodElement
      *       + name: foo
      *       + function: set foo(x) { ... }
      *
      */
     private FieldElement buildAbstractField(DartField fieldNode) {
       assert fieldNode.getModifiers().isAbstractField();
       boolean topLevelDefinition = fieldNode.getParent().getParent() instanceof DartUnit;
       DartMethodDefinition accessorNode = fieldNode.getAccessor();
-      MethodElement accessorElement = Elements.methodFromMethodNode(accessorNode, currentHolder);
+      MethodNodeElement accessorElement = Elements.methodFromMethodNode(accessorNode, currentHolder);
       EnclosingElement previousEnclosingElement = enclosingElement;
       enclosingElement = accessorElement;
       recordElement(accessorNode, accessorElement);
       resolveFunction(accessorNode.getFunction(), accessorElement);
       enclosingElement = previousEnclosingElement;
 
       String name = fieldNode.getName().getName();
       Element element = null;
       if (currentHolder != null) {
           element = currentHolder.lookupLocalElement(name);
@@ skipping 38 matching lines @@
             type = getTypeProvider().getDynamicType();
           } else {
             type = parameters.get(0).getType();
           }
           fieldElement.setType(type);
         }
       }
       return recordElement(fieldNode, fieldElement);
     }
 
-    private void addField(EnclosingElement holder, FieldElement element) {
+    private void addField(EnclosingElement holder, FieldNodeElement element) {
       if (holder != null) {
         checkUniqueName(holder, element);
         Elements.addField(holder, element);
       }
     }
 
-    private void addMethod(EnclosingElement holder, MethodElement element) {
+    private void addMethod(EnclosingElement holder, MethodNodeElement element) {
       checkUniqueName(holder, element);
       Elements.addMethod(holder, element);
     }
 
-    private void addConstructor(ClassElement cls, MethodElement element) {
+    private void addConstructor(ClassElement cls, ConstructorNodeElement element) {
       checkUniqueName(cls, element);
-      Elements.addConstructor(cls, (ConstructorElement) element);
+      Elements.addConstructor(cls, element);
     }
 
     private ElementKind getMethodKind(DartMethodDefinition method) {
       if (!ElementKind.of(currentHolder).equals(ElementKind.CLASS)) {
         return ElementKind.METHOD;
       }
 
       if (method.getModifiers().isFactory()) {
         return ElementKind.CONSTRUCTOR;
       }
@@ skipping 147 matching lines @@
      */
     private void reportDuplicateDeclaration(ErrorCode errorCode, Element element) {
       String name =
           element instanceof MethodElement
               ? Elements.getRawMethodName((MethodElement) element)
               : element.getName();
       resolutionError(element.getNameLocation(), errorCode, name);
     }
   }
 }