Use NodeElement to access Node in Resolver

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

 // Copyright (c) 2012, 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.common.collect.Lists;
 import com.google.common.collect.Sets;
 import com.google.dart.compiler.DartCompilationPhase;
@@ skipping 54 matching lines @@
 import com.google.dart.compiler.ast.Modifiers;
 import com.google.dart.compiler.common.HasSourceInfo;
 import com.google.dart.compiler.common.SourceInfo;
 import com.google.dart.compiler.type.InterfaceType;
 import com.google.dart.compiler.type.InterfaceType.Member;
 import com.google.dart.compiler.type.Type;
 import com.google.dart.compiler.type.TypeVariable;
 import com.google.dart.compiler.util.StringUtils;
 
 import java.util.EnumSet;
-import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
 
 /**
  * Resolves unqualified elements in a compilation unit.
  */
 public class Resolver {
 
   private final ResolutionContext topLevelContext;
@@ skipping 136 matching lines @@
     public Element visitFunctionTypeAlias(DartFunctionTypeAlias alias) {
       getContext().pushFunctionAliasScope(alias);
       resolveFunctionAlias(alias);
       getContext().popScope();
       return null;
     }
 
     @Override
     public Element visitClass(DartClass cls) {
       assert currentMethod == null : "nested class?";
-      ClassElement classElement = cls.getElement();
+      ClassNodeElement classElement = cls.getElement();
       try {
         classElement.getAllSupertypes();
       } catch (CyclicDeclarationException e) {
         HasSourceInfo errorTarget = e.getElement();
         if (errorTarget == null) {
           errorTarget = cls;
         }
         onError(errorTarget, ResolverErrorCode.CYCLIC_CLASS, e.getElement().getName());
       } catch (DuplicatedInterfaceException e) {
         onError(cls, ResolverErrorCode.DUPLICATED_INTERFACE,
                         e.getFirst(), e.getSecond());
       }
 
       checkClassTypeVariables(classElement);
 
       // Push new resolution context.
       ResolutionContext previousContext = context;
       EnclosingElement previousHolder = currentHolder;
       EnclosingElement previousEnclosingElement = enclosingElement;
       currentHolder = classElement;
       enclosingElement = classElement;
       context = topLevelContext.extend(classElement);
 
       this.finalsNeedingInitializing.clear();
-      for (Element element : classElement.getMembers()) {
-        element.getNode().accept(this);
+      for (NodeElement member : classElement.getMembers()) {
+        member.getNode().accept(this);
       }
 
       boolean testForAllConstantFields = false;
       for (DartNode member : cls.getMembers()) {
         if (member instanceof DartMethodDefinition) {
           DartMethodDefinition method = (DartMethodDefinition) member;
           if (method.getElement().isConstructor()) {
             method.accept(this);
             if (method.getModifiers().isConstant()) {
               testForAllConstantFields = true;
@@ skipping 45 matching lines @@
                   ResolverErrorCode.ILLEGAL_CONSTRUCTOR_NO_DEFAULT_IN_INTERFACE);
         }
       }
 
       context = previousContext;
       currentHolder = previousHolder;
       enclosingElement = previousEnclosingElement;
       return classElement;
     }
 
-    private void constVerifyMembers(Iterable<Element> members, ClassElement originalClass,
+    private void constVerifyMembers(Iterable<? extends Element> members, ClassElement originalClass,
         ClassElement currentClass) {
       for (Element element : members) {
         Modifiers modifiers = element.getModifiers();
         if (ElementKind.of(element).equals(ElementKind.FIELD) && !modifiers.isFinal()
             && !modifiers.isAbstractField()) {
           FieldElement field = (FieldElement) element;
           HasSourceInfo errorNode = field.getSetter() == null ? element : field.getSetter();
           onError(errorNode, currentClass == originalClass
               ? ResolverErrorCode.CONST_CLASS_WITH_NONFINAL_FIELDS
               : ResolverErrorCode.CONST_CLASS_WITH_INHERITED_NONFINAL_FIELDS,
@@ skipping 311 matching lines @@
         if (isStatic) {
           onError(node, ResolverErrorCode.STATIC_FINAL_REQUIRES_VALUE);
         } else {
           // If a final instance field wasn't initialized at declaration, we must check
           // at construction time.
           this.finalsNeedingInitializing.add(node.getElement());
         }
       }
 
       // If field is an accessor, both getter and setter need to be visited (if present).
-      FieldElement field = node.getElement();
+      FieldNodeElement field = node.getElement();
       if (field.getGetter() != null) {
         resolve(field.getGetter().getNode());
       }
       if (field.getSetter() != null) {
         resolve(field.getSetter().getNode());
       }
       return null;
     }
 
     @Override
@@ skipping 1134 matching lines @@
      *          (not <code>null</code>)
      */
     @Override
     public DartUnit exec(DartUnit unit, DartCompilerContext context,
                          CoreTypeProvider typeProvider) {
       Scope unitScope = unit.getLibrary().getElement().getScope();
       return new Resolver(context, unitScope, typeProvider).exec(unit);
     }
   }
 
-  private void checkRedirectConstructorCycle(List<ConstructorElement> constructors,
+  private void checkRedirectConstructorCycle(List<ConstructorNodeElement> constructors,
                                              ResolutionContext context) {
-    for (ConstructorElement element : constructors) {
+    for (ConstructorNodeElement element : constructors) {
       if (hasRedirectedConstructorCycle(element)) {
         context.onError(element, ResolverErrorCode.REDIRECTED_CONSTRUCTOR_CYCLE);
       }
     }
   }
 
-  private boolean hasRedirectedConstructorCycle(ConstructorElement constructorElement) {
-    HashSet<ConstructorElement> visited = new HashSet<ConstructorElement>();
-    ConstructorElement next = getNextConstructorInvocation(constructorElement);
+  private boolean hasRedirectedConstructorCycle(ConstructorNodeElement constructorElement) {
+    Set<ConstructorNodeElement> visited = Sets.newHashSet();
+    ConstructorNodeElement next = getNextConstructorInvocation(constructorElement);
     while (next != null) {
       if (visited.contains(next)) {
         return true;
       }
       if (constructorElement.getName().equals(next.getName())) {
         return true;
       }
       visited.add(next);
       next = getNextConstructorInvocation(next);
     }
     return false;
   }
   
-  private ConstructorElement getNextConstructorInvocation(ConstructorElement constructor) {
+  private ConstructorNodeElement getNextConstructorInvocation(ConstructorNodeElement constructor) {
     List<DartInitializer> inits = ((DartMethodDefinition) constructor.getNode()).getInitializers();
-    // The parser ensures that redirected constructors can be the only item in the initialization
-    // list.
+    // Parser ensures that redirected constructors can be the only item in the initialization list.
     if (inits.size() == 1) {
       Element element = (Element) inits.get(0).getValue().getElement();
       if (ElementKind.of(element).equals(ElementKind.CONSTRUCTOR)) {
         ConstructorElement nextConstructorElement = (ConstructorElement) element;
         ClassElement nextClass = (ClassElement) nextConstructorElement.getEnclosingElement();
         ClassElement currentClass = (ClassElement) constructor.getEnclosingElement();
         if (nextClass == currentClass) {
-          return nextConstructorElement;
+          return (ConstructorNodeElement) nextConstructorElement;
         }
       }
     }
     return null;
   }
 }