Reduce usage of .enclosingElement to get enclosing class.

lib/compiler/implementation/ssa/builder.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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 155 matching lines @@
       }
       assert(graph.isValid());
       bool inLoop = functionsCalledInLoop.contains(element);
       if (!inLoop) {
         Selector selector = selectorsCalledInLoop[element.name];
         inLoop = selector !== null && selector.applies(element, compiler);
       }
       graph.calledInLoop = inLoop;
       if (compiler.tracer.enabled) {
         String name;
-        if (element.enclosingElement !== null &&
-            element.enclosingElement.kind == ElementKind.CLASS) {
-          String className = element.enclosingElement.name.slowToString();
+        if (element.isMember()) {
+          String className = element.getEnclosingClass().name.slowToString();
           String memberName = element.name.slowToString();
           name = "$className.$memberName";
           if (element.kind == ElementKind.GENERATIVE_CONSTRUCTOR_BODY) {
             name = "$name (body)";
           }
         } else {
           name = "${element.name.slowToString()}";
         }
         compiler.tracer.traceCompilation(name);
         compiler.tracer.traceGraph('builder', graph);
       }
       return graph;
     });
   }
 
   HGraph compileConstructor(SsaBuilder builder, WorkItem work) {
     // The body of the constructor will be generated in a separate function.
-    final ClassElement classElement = work.element.enclosingElement;
+    final ClassElement classElement = work.element.getEnclosingClass();
     return builder.buildFactory(classElement, work.element);
   }
 }
 
 /**
  * Keeps track of locals (including parameters and phis) when building. The
  * 'this' reference is treated as parameter and hence handled by this class,
  * too.
  */
 class LocalsHandler {
@@ skipping 125 matching lines @@
     if (closureData.isClosure()) {
       // Inside closure redirect references to itself to [:this:].
       HInstruction thisInstruction = new HThis();
       builder.add(thisInstruction);
       updateLocal(closureData.closureElement, thisInstruction);
     } else if (function.isInstanceMember()
                || function.isGenerativeConstructor()) {
       // Once closures have been mapped to classes their instance members might
       // not have any thisElement if the closure was created inside a static
       // context.
-      ClassElement cls = function.enclosingElement;
+      ClassElement cls = function.getEnclosingClass();
       Type type = cls.computeType(builder.compiler);
       HInstruction thisInstruction = new HThis(new HBoundedType.nonNull(type));
       builder.add(thisInstruction);
       directLocals[closureData.thisElement] = thisInstruction;
     }
   }
 
   bool hasValueForDirectLocal(Element element) {
     assert(element !== null);
     assert(isAccessedDirectly(element));
     return directLocals[element] !== null;
   }
 
   /**
    * Returns true if the local can be accessed directly. Boxed variables or
    * captured variables that are stored in the closure-field return [false].
    */
   bool isAccessedDirectly(Element element) {
     assert(element !== null);
     return redirectionMapping[element] === null
         && !closureData.usedVariablesInTry.contains(element);
   }
 
   bool isStoredInClosureField(Element element) {
     assert(element !== null);
     if (isAccessedDirectly(element)) return false;
     Element redirectTarget = redirectionMapping[element];
     if (redirectTarget == null) return false;
-    if (redirectTarget.enclosingElement.kind == ElementKind.CLASS) {
+    if (redirectTarget.isMember()) {
       assert(redirectTarget is ClosureFieldElement);
       return true;
     }
     return false;
   }
 
   bool isBoxed(Element element) {
     if (isAccessedDirectly(element)) return false;
     if (isStoredInClosureField(element)) return false;
     return redirectionMapping[element] !== null;
@@ skipping 43 matching lines @@
   }
 
   HType cachedTypeOfThis;
 
   HInstruction readThis() {
     HInstruction res = readLocal(closureData.thisElement);
     if (res.guaranteedType === null) {
       if (cachedTypeOfThis === null) {
         assert(closureData.isClosure());
         Element element = closureData.thisElement;
-        ClassElement cls = element.enclosingElement.enclosingElement;
+        ClassElement cls = element.enclosingElement.getEnclosingClass();
         Type type = cls.computeType(builder.compiler);
         cachedTypeOfThis = new HBoundedType.nonNull(type);
       }
       res.guaranteedType = cachedTypeOfThis;
     }
     return res;
   }
 
   HLocalValue getLocal(Element element) {
     // If the element is a parameter, we already have a
@@ skipping 408 matching lines @@
   ConstructorBodyElement getConstructorBody(FunctionElement constructor) {
     assert(constructor.kind === ElementKind.GENERATIVE_CONSTRUCTOR);
     if (constructor is SynthesizedConstructorElement) return null;
     FunctionExpression node = constructor.parseNode(compiler);
     // If we know the body doesn't have any code, we don't generate
     // it.
     if (node.body.asBlock() !== null) {
       NodeList statements = node.body.asBlock().statements;
       if (statements.isEmpty()) return null;
     }
-    ClassElement classElement = constructor.enclosingElement;
+    ClassElement classElement = constructor.getEnclosingClass();
     ConstructorBodyElement bodyElement;
     for (Link<Element> backendMembers = classElement.backendMembers;
          !backendMembers.isEmpty();
          backendMembers = backendMembers.tail) {
       Element backendMember = backendMembers.head;
       if (backendMember.kind == ElementKind.GENERATIVE_CONSTRUCTOR_BODY) {
         ConstructorBodyElement body = backendMember;
         if (body.constructor == constructor) {
           bodyElement = backendMember;
           break;
@@ skipping 87 matching lines @@
           assert(!arguments.isEmpty() && arguments.tail.isEmpty());
           visit(arguments.head);
           fieldValues[elements[init]] = pop();
         }
       }
     }
 
     if (!foundSuperOrRedirect) {
       // No super initializer found. Try to find the default constructor if
       // the class is not Object.
-      ClassElement enclosingClass = constructor.enclosingElement;
+      ClassElement enclosingClass = constructor.getEnclosingClass();
       ClassElement superClass = enclosingClass.superclass;
       if (enclosingClass != compiler.objectClass) {
         assert(superClass !== null);
         assert(superClass.isResolved);
         FunctionElement target = superClass.lookupConstructor(superClass.name);
         if (target === null) {
           compiler.internalError("no default constructor available");
         }
         inlineSuperOrRedirect(target,
                               Selector.INVOCATION_0,
@@ skipping 1273 matching lines @@
       add(target);
       inputs = <HInstruction>[target];
       addDynamicSendArgumentsToList(node, inputs);
       push(new HInvokeClosure(selector, inputs));
     }
   }
 
   visitNewSend(Send node) {
     computeType(element) {
       Element originalElement = elements[node];
-      if (originalElement.enclosingElement === compiler.listClass) {
+      if (originalElement.getEnclosingClass() === compiler.listClass) {
         if (node.arguments.isEmpty()) {
           return HType.EXTENDABLE_ARRAY;
         } else {
           return HType.MUTABLE_ARRAY;
         }
       } else if (element.isGenerativeConstructor()) {
-        ClassElement cls = element.enclosingElement;
+        ClassElement cls = element.getEnclosingClass();
         return new HBoundedType.exact(cls.type);
       } else {
         return HType.UNKNOWN;
       }
     }
 
     Selector selector = elements.getSelector(node);
     Element element = elements[node];
     if (compiler.enqueuer.resolution.getCachedElements(element) === null) {
       compiler.internalError("Unresolved element: $element", node: node);
@@ skipping 1315 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }