Reduce usage of .enclosingElement to get enclosing class.

lib/compiler/implementation/resolver.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.
 
 interface TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   Type getType(TypeAnnotation annotation);
 }
 
@@ skipping 68 matching lines @@
   }
 
   FunctionElement resolveConstructorRedirection(FunctionElement constructor) {
     FunctionExpression node = constructor.parseNode(compiler);
     // A synthetic constructor does not have a node.
     if (node === null) return null;
     if (node.initializers === null) return null;
     Link<Node> initializers = node.initializers.nodes;
     if (!initializers.isEmpty() &&
         Initializers.isConstructorRedirect(initializers.head)) {
-      final ClassElement classElement = constructor.enclosingElement;
+      final ClassElement classElement = constructor.getEnclosingClass();
       final SourceString constructorName =
           getConstructorName(initializers.head);
       final SourceString className = classElement.name;
       return classElement.lookupConstructor(className, constructorName);
     }
     return null;
   }
 
   void resolveRedirectingConstructor(InitializerResolver resolver,
                                      Node node,
@@ skipping 53 matching lines @@
     });
   }
 
   void visitBody(ResolverVisitor visitor, Statement body) {
     visitor.visit(body);
   }
 
   void resolveConstructorImplementation(FunctionElement constructor,
                                         FunctionExpression node) {
     if (constructor.defaultImplementation !== constructor) return;
-    ClassElement intrface = constructor.enclosingElement;
+    ClassElement intrface = constructor.getEnclosingClass();
     if (!intrface.isInterface()) return;
     Type defaultType = intrface.defaultClass;
     if (defaultType === null) {
       error(node, MessageKind.NO_DEFAULT_CLASS, [intrface.name]);
     }
     ClassElement defaultClass = defaultType.element;
     defaultClass.ensureResolved(compiler);
     if (defaultClass.isInterface()) {
       error(node, MessageKind.CANNOT_INSTANTIATE_INTERFACE,
             [defaultClass.name]);
@@ skipping 223 matching lines @@
     return node.receiver.asIdentifier().isThis();
   }
 
   void resolveFieldInitializer(FunctionElement constructor, SendSet init) {
     // init is of the form [this.]field = value.
     final Node selector = init.selector;
     final SourceString name = selector.asIdentifier().source;
     // Lookup target field.
     Element target;
     if (isFieldInitializer(init)) {
-      final ClassElement classElement = constructor.enclosingElement;
+      final ClassElement classElement = constructor.getEnclosingClass();
       target = classElement.lookupLocalMember(name);
       if (target === null) {
         error(selector, MessageKind.CANNOT_RESOLVE, [name]);
       } else if (target.kind != ElementKind.FIELD) {
         error(selector, MessageKind.NOT_A_FIELD, [name]);
       } else if (!target.isInstanceMember()) {
         error(selector, MessageKind.INIT_STATIC_FIELD, [name]);
       }
     } else {
       error(init, MessageKind.INVALID_RECEIVER_IN_INITIALIZER);
@@ skipping 21 matching lines @@
     SourceString constructorName = resolver.getConstructorName(call);
     Element result = resolveSuperOrThis(
         constructor, isSuperCall, false, constructorName, selector, call);
     visitor.useElement(call, result);
     return result;
   }
 
   void resolveImplicitSuperConstructorSend(FunctionElement constructor,
                                            FunctionExpression functionNode) {
     // If the class has a super resolve the implicit super call.
-    ClassElement classElement = constructor.enclosingElement;
+    ClassElement classElement = constructor.getEnclosingClass();
     ClassElement superClass = classElement.superclass;
     if (classElement != visitor.compiler.objectClass) {
       assert(superClass !== null);
       assert(superClass.isResolved);
       var element = resolveSuperOrThis(constructor, true, true,
                                        const SourceString(''),
                                        Selector.INVOCATION_0, functionNode);
       visitor.world.registerStaticUse(element);
     }
   }
 
   Element resolveSuperOrThis(FunctionElement constructor,
                              bool isSuperCall,
                              bool isImplicitSuperCall,
                              SourceString constructorName,
                              Selector selector,
                              Node diagnosticNode) {
-    ClassElement lookupTarget = constructor.enclosingElement;
+    ClassElement lookupTarget = constructor.getEnclosingClass();
     bool validTarget = true;
     FunctionElement result;
     if (isSuperCall) {
       // Calculate correct lookup target and constructor name.
       if (lookupTarget === visitor.compiler.objectClass) {
         error(diagnosticNode, MessageKind.SUPER_INITIALIZER_IN_OBJECT);
       } else {
         lookupTarget = lookupTarget.supertype.element;
       }
     }
@@ skipping 352 matching lines @@
   ClassElement currentClass;
   bool typeRequired = false;
   StatementScope statementScope;
   int allowedCategory = ElementCategory.VARIABLE | ElementCategory.FUNCTION;
 
   ResolverVisitor(Compiler compiler, Element element)
     : this.mapping  = new TreeElementMapping(),
       this.enclosingElement = element,
       inInstanceContext = element.isInstanceMember()
           || element.isGenerativeConstructor(),
-      this.currentClass = element.isMember() ? element.enclosingElement : null,
+      this.currentClass = element.isMember() ?
+                              element.getEnclosingClass() :
+                              null,
       this.statementScope = new StatementScope(),
       typeResolver = new TypeResolver(compiler),
       scope = element.buildEnclosingScope(),
       super(compiler) {
   }
 
   Enqueuer get world() => compiler.enqueuer.resolution;
 
   Element lookup(Node node, SourceString name) {
     Element result = scope.lookup(name);
@@ skipping 502 matching lines @@
       // TODO(ngeoffray): resolution error with wrong number of
       // parameters. We cannot do this rigth now because of the
       // List constructor.
     }
     useElement(node.send, constructor);
     compiler.withCurrentElement(constructor, () {
       FunctionExpression tree = constructor.parseNode(compiler);
       compiler.resolver.resolveConstructorImplementation(constructor, tree);
     });
     world.registerStaticUse(constructor.defaultImplementation);
-    ClassElement cls = constructor.defaultImplementation.enclosingElement;
+    ClassElement cls = constructor.defaultImplementation.getEnclosingClass();
     world.registerInstantiatedClass(cls);
     cls.forEachInstanceField(
         includeBackendMembers: false,
         includeSuperMembers: true,
         f: (ClassElement enclosingClass, Element member) {
           world.addToWorkList(member);
         });
     return null;
   }
 
@@ skipping 283 matching lines @@
   }
 }
 
 class TypeDefinitionVisitor extends CommonResolverVisitor<Type> {
   Scope scope;
   TypeDeclarationElement element;
   TypeResolver typeResolver;
 
   TypeDefinitionVisitor(Compiler compiler, TypeDeclarationElement element)
       : this.element = element,
-        scope = element.enclosingElement.buildScope(),
+        scope = element.buildEnclosingScope(),
         typeResolver = new TypeResolver(compiler),
         super(compiler);
 
   void resolveTypeVariableBounds(NodeList node) {
     if (node === null) return;
 
     var nameSet = new Set<SourceString>();
     // Resolve the bounds of type variables.
     Link<Type> typeLink = element.typeVariables;
     Link<Node> nodeLink = node.nodes;
@@ skipping 417 matching lines @@
 
   // TODO(ahe): This is temporary.
   void resolveExpression(Node node) {
     if (node == null) return;
     node.accept(new ResolverVisitor(compiler, enclosingElement));
   }
 
   // TODO(ahe): This is temporary.
   ClassElement get currentClass() {
     return enclosingElement.isMember()
-      ? enclosingElement.enclosingElement : null;
+      ? enclosingElement.getEnclosingClass() : null;
   }
 }
 
 class ConstructorResolver extends CommonResolverVisitor<Element> {
   final ResolverVisitor resolver;
   ConstructorResolver(Compiler compiler, this.resolver) : super(compiler);
 
   visitNode(Node node) {
     throw 'not supported';
   }
@@ skipping 185 matching lines @@
   TopScope(LibraryElement library) : super(null, library);
   Element lookup(SourceString name) {
     return library.find(name);
   }
 
   Element add(Element newElement) {
     throw "Cannot add an element in the top scope";
   }
   String toString() => '$element';
 }