Reduce usage of .enclosingElement to get enclosing class.

lib/compiler/implementation/compiler.dart

 // 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.
 
 
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
 final bool REPORT_EXCESS_RESOLUTION = false;
@@ skipping 92 matching lines @@
                             Collection<LibraryElement> libraries) {
     native.processNativeClasses(world, emitter, libraries);
   }
 
   void assembleProgram() {
     emitter.assembleProgram();
   }
 
   void updateFieldInitializers(Element field, HType propagatedType) {
     assert(field.isField());
-    assert(field.enclosingElement.isClass());
+    assert(field.isMember());
     Map<Element, HType> fields =
         fieldInitializers.putIfAbsent(
-          field.enclosingElement, () => new Map<Element, HType>());
+          field.getEnclosingClass(), () => new Map<Element, HType>());
     if (!fields.containsKey(field)) {
       fields[field] = propagatedType;
     } else {
       fields[field] = fields[field].union(propagatedType);
     }
   }
 
   HType typeFromInitializersSoFar(Element field) {
     assert(field.isField());
-    assert(field.enclosingElement.isClass());
-    if (!fieldInitializers.containsKey(field.enclosingElement)) {
+    assert(field.isMember());
+    if (!fieldInitializers.containsKey(field.getEnclosingClass())) {
       return HType.CONFLICTING;
     }
-    Map<Element, HType> fields = fieldInitializers[field.enclosingElement];
+    Map<Element, HType> fields = fieldInitializers[field.getEnclosingClass()];
     return fields[field];
   }
 
   void updateFieldConstructorSetters(Element field, HType type) {
     assert(field.isField());
-    assert(field.enclosingElement.isClass());
+    assert(field.isMember());
     Map<Element, HType> fields =
         fieldConstructorSetters.putIfAbsent(
-          field.enclosingElement, () => new Map<Element, HType>());
+            field.getEnclosingClass(), () => new Map<Element, HType>());
     if (!fields.containsKey(field)) {
       fields[field] = type;
     } else {
       fields[field] = fields[field].union(type);
     }
   }
 
   // Check if this field is set in the constructor body.
   bool hasConstructorBodyFieldSetter(Element field) {
-    if (!fieldConstructorSetters.containsKey(field.enclosingElement)) {
+    ClassElement enclosingClass = field.getEnclosingClass();
+    if (!fieldConstructorSetters.containsKey(enclosingClass)) {
       return false;
     }
-    return fieldConstructorSetters[field.enclosingElement][field] != null;
+    return fieldConstructorSetters[enclosingClass][field] != null;
   }
 
   // Provide an optimistic estimate of the type of a field after construction.
   // If the constructor body has setters for fields returns HType.UNKNOWN.
   // This only takes the initializer lists and field assignments in the
   // constructor body into account. The constructor body might have method calls
   // that could alter the field.
   HType optimisticFieldTypeAfterConstruction(Element field) {
     assert(field.isField());
-    assert(field.enclosingElement.isClass());
+    assert(field.isMember());
 
+    ClassElement classElement = field.getEnclosingClass();
     if (hasConstructorBodyFieldSetter(field)) {
       // If there are field setters but there is only constructor then the type
       // of the field is determined by the assignments in the constructor
       // body.
-      ClassElement classElement = field.enclosingElement;
       if (classElement.constructors.length == 1) {
-        return fieldConstructorSetters[field.enclosingElement][field];
+        return fieldConstructorSetters[classElement][field];
       } else {
         return HType.UNKNOWN;
       }
-    } else if (fieldInitializers.containsKey(field.enclosingElement)) {
-      HType type = fieldInitializers[field.enclosingElement][field];
+    } else if (fieldInitializers.containsKey(classElement)) {
+      HType type = fieldInitializers[classElement][field];
       return type == null ? HType.CONFLICTING : type;
     } else {
       return HType.CONFLICTING;
     }
   }
 
   void updateFieldSetters(Element field, HType type) {
     assert(field.isField());
-    assert(field.enclosingElement.isClass());
+    assert(field.isMember());
     Map<Element, HType> fields =
         fieldSettersType.putIfAbsent(
-          field.enclosingElement, () => new Map<Element, HType>());
+          field.getEnclosingClass(), () => new Map<Element, HType>());
     if (!fields.containsKey(field)) {
       fields[field] = type;
     } else {
       fields[field] = fields[field].union(type);
     }
   }
 
   // Returns the type that field setters are setting the field to based on what
   // have been seen during compilation so far.
   HType fieldSettersTypeSoFar(Element field) {
     assert(field.isField());
-    assert(field.enclosingElement.isClass());
-    if (!fieldSettersType.containsKey(field.enclosingElement)) {
+    assert(field.isMember());
+    ClassElement enclosingClass = field.getEnclosingClass();
+    if (!fieldSettersType.containsKey(enclosingClass)) {
       return HType.CONFLICTING;
     }
-    Map<Element, HType> fields = fieldSettersType[field.enclosingElement];
+    Map<Element, HType> fields = fieldSettersType[enclosingClass];
     if (!fields.containsKey(field)) return HType.CONFLICTING;
     return fields[field];
   }
 }
 
 class Compiler implements DiagnosticListener {
   final Map<String, LibraryElement> libraries;
   int nextFreeClassId = 0;
   World world;
   String assembledCode;
@@ skipping 191 matching lines @@
       return false;
     }
     tracer.close();
     log('compilation succeeded');
     return true;
   }
 
   void enableNoSuchMethod(Element element) {
     // TODO(ahe): Move this method to Enqueuer.
     if (enabledNoSuchMethod) return;
-    if (element.enclosingElement === objectClass) {
+    if (element.getEnclosingClass() === objectClass) {
       enqueuer.resolution.registerDynamicInvocationOf(element);
       return;
     }
     enabledNoSuchMethod = true;
     enqueuer.resolution.registerInvocation(NO_SUCH_METHOD,
                                            Selector.INVOCATION_2);
     enqueuer.codegen.registerInvocation(NO_SUCH_METHOD,
                                         Selector.INVOCATION_2);
   }
 
@@ skipping 387 matching lines @@
     }
     for (Element e in new Set.from(resolved)) {
       if (e.isClass() ||
           e.isField() ||
           e.isTypeVariable() ||
           e.isTypedef() ||
           e.kind === ElementKind.ABSTRACT_FIELD) {
         resolved.remove(e);
       }
       if (e.kind === ElementKind.GENERATIVE_CONSTRUCTOR) {
-        ClassElement enclosingClass = e.enclosingElement;
+        ClassElement enclosingClass = e.getEnclosingClass();
         if (enclosingClass.isInterface()) {
           resolved.remove(e);
         }
         resolved.remove(e);
 
       }
       if (e.getLibrary() === jsHelperLibrary) {
         resolved.remove(e);
       }
       if (e.getLibrary() === interceptorsLibrary) {
@@ skipping 267 matching lines @@
     final endOffset = end.charOffset + end.slowCharCount;
 
     // [begin] and [end] might be the same for the same empty token. This
     // happens for instance when scanning '$$'.
     assert(endOffset >= beginOffset);
     return f(beginOffset, endOffset);
   }
 
   String toString() => 'SourceSpan($uri, $begin, $end)';
 }