Reduce usage of .enclosingElement to get enclosing class.

lib/compiler/implementation/ssa/codegen.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 SsaCodeGeneratorTask extends CompilerTask {
   final JavaScriptBackend backend;
   SsaCodeGeneratorTask(JavaScriptBackend backend)
       : this.backend = backend,
         super(backend.compiler);
   String get name() => 'SSA code generator';
@@ skipping 40 matching lines @@
       parameterNames.forEach((element, name) {
         compiler.enqueuer.codegen.addToWorkList(element);
       });
       String parameters = Strings.join(parameterNames.getValues(), ', ');
       SsaOptimizedCodeGenerator codegen = new SsaOptimizedCodeGenerator(
           backend, work, parameters, parameterNames);
       codegen.visitGraph(graph);
 
       FunctionElement element = work.element;
       CodeBuffer code;
+      ClassElement enclosingClass = element.getEnclosingClass();
       if (element.isInstanceMember()
-          && element.enclosingElement.isClass()
-          && element.enclosingElement.isNative()
+          && enclosingClass.isNative()
           && native.isOverriddenMethod(
-              element, element.enclosingElement, nativeEmitter)) {
+              element, enclosingClass, nativeEmitter)) {
         // Record that this method is overridden. In case of optional
         // arguments, the emitter will generate stubs to handle them,
         // and needs to know if the method is overridden.
         nativeEmitter.overriddenMethods.add(element);
         StringBuffer buffer = new StringBuffer();
         native.generateMethodWithPrototypeCheckForElement(
             compiler, buffer, element, '${codegen.buffer}', parameters);
         code = new CodeBuffer();
         code.add(buffer);
       } else {
@@ skipping 1717 matching lines @@
   visitInvokeStatic(HInvokeStatic node) {
     beginExpression(JSPrecedence.CALL_PRECEDENCE);
     use(node.target, JSPrecedence.CALL_PRECEDENCE);
     visitArguments(node.inputs);
     endExpression(JSPrecedence.CALL_PRECEDENCE);
   }
 
   visitInvokeSuper(HInvokeSuper node) {
     beginExpression(JSPrecedence.CALL_PRECEDENCE);
     Element superMethod = node.element;
-    Element superClass = superMethod.enclosingElement;
+    Element superClass = superMethod.getEnclosingClass();
     // Remove the element and 'this'.
     int argumentCount = node.inputs.length - 2;
     String className = compiler.namer.isolateAccess(superClass);
     if (superMethod.kind == ElementKind.FUNCTION ||
         superMethod.kind == ElementKind.GENERATIVE_CONSTRUCTOR) {
       String methodName = compiler.namer.instanceMethodName(
           currentLibrary, superMethod.name, argumentCount);
       buffer.add('$className.prototype.$methodName.call');
       visitArguments(node.inputs);
     } else if (superMethod.kind == ElementKind.FIELD) {
-      ClassElement currentClass = work.element.enclosingElement;
+      ClassElement currentClass = work.element.getEnclosingClass();
       if (currentClass.isShadowedByField(superMethod)) {
         buffer.add('this.${compiler.namer.shadowedFieldName(superMethod)}');
       } else {
         LibraryElement library = superMethod.getLibrary();
         SourceString name = superMethod.name;
         buffer.add('this.${compiler.namer.instanceFieldName(library, name)}');
       }
     } else {
       assert(superMethod.kind == ElementKind.GETTER ||
              superMethod.kind == ElementKind.SETTER);
@@ skipping 42 matching lines @@
       return (isSimpleFieldNumberComputation(value.left, node) &&
               isSimpleFieldNumberComputation(value.right, node));
     }
     if (value is HFieldGet) return value.element == node.element;
     return false;
   }
 
   visitFieldSet(HFieldSet node) {
     if (node.element != null &&
         work.element.isGenerativeConstructorBody() &&
-        node.element.enclosingElement.isClass() &&
+        node.element.isMember() &&
         node.value.hasGuaranteedType() &&
         node.block.dominates(currentGraph.exit)) {
       backend.updateFieldConstructorSetters(node.element,
                                             node.value.guaranteedType);
     }
     String name =
         compiler.namer.instanceFieldName(node.library, node.fieldName);
     beginExpression(JSPrecedence.ASSIGNMENT_PRECEDENCE);
     use(node.receiver, JSPrecedence.MEMBER_PRECEDENCE);
     buffer.add('.');
@@ skipping 1320 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }