A bit of element model cleanup.

sdk/lib/_internal/compiler/implementation/js_backend/backend.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.
 
 part of js_backend;
 
 const VERBOSE_OPTIMIZER_HINTS = false;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked = new Set<HInstruction>();
@@ skipping 1817 matching lines @@
    * be visible by reflection unless some other interfaces makes them
    * accessible.
    */
   computeMembersNeededForReflection() {
     if (_membersNeededForReflection != null) return;
     if (compiler.mirrorsLibrary == null) {
       _membersNeededForReflection = const [];
     }
     // Compute a mapping from class to the closures it contains, so we
     // can include the correct ones when including the class.
-    Map<ClassElement, List<Element>> closureMap =
-        new Map<ClassElement, List<Element>>();
-    for (FunctionElement closure in compiler.resolverWorld.allClosures) {
+    Map<ClassElement, List<LocalFunctionElement>> closureMap =
+        new Map<ClassElement, List<LocalFunctionElement>>();
+    for (LocalFunctionElement closure in compiler.resolverWorld.allClosures) {
       closureMap.putIfAbsent(closure.enclosingClass, () => []).add(closure);
     }
     bool foundClosure = false;
     Set<Element> reflectableMembers = new Set<Element>();
     ResolutionEnqueuer resolution = compiler.enqueuer.resolution;
     for (ClassElement cls in resolution.universe.instantiatedClasses) {
       // Do not process internal classes.
       if (cls.library.isInternalLibrary || cls.isInjected) continue;
       if (referencedFromMirrorSystem(cls)) {
         Set<Name> memberNames = new Set<Name>();
@@ skipping 19 matching lines @@
             subcls.forEachClassMember((Member member) {
               if (memberNames.contains(member.name)) {
                 assert(invariant(member.element,
                     resolution.isLive(member.element)));
                 reflectableMembers.add(member.element);
               }
             });
           }
         }
         // 5) all its closures
-        List<Element> closures = closureMap[cls];
+        List<LocalFunctionElement> closures = closureMap[cls];
         if (closures != null) {
           reflectableMembers.addAll(closures);
           foundClosure = true;
         }
       } else {
         // check members themselves
         cls.constructors.forEach((ConstructorElement element) {
           if (!compiler.enqueuer.resolution.isLive(element)) return;
           if (referencedFromMirrorSystem(element, false)) {
             reflectableMembers.add(element);
           }
         });
         cls.forEachClassMember((Member member) {
           if (!compiler.enqueuer.resolution.isLive(member.element)) return;
           if (referencedFromMirrorSystem(member.element, false)) {
             reflectableMembers.add(member.element);
           }
         });
         // Also add in closures. Those might be reflectable is their enclosing
         // member is.
-        List<Element> closures = closureMap[cls];
+        List<LocalFunctionElement> closures = closureMap[cls];
         if (closures != null) {
-          for (Element closure in closures) {
-            if (referencedFromMirrorSystem(closure.enclosingMember, false)) {
+          for (LocalFunctionElement closure in closures) {
+            if (referencedFromMirrorSystem(closure.memberContext, false)) {
               reflectableMembers.add(closure);
               foundClosure = true;
             }
           }
         }
       }
     }
     // We also need top-level non-class elements like static functions and
     // global fields. We use the resolution queue to decide which elements are
     // part of the live world.
@@ skipping 396 matching lines @@
 }
 
 /// Records that [constant] is used by the element behind [registry].
 class Dependency {
   final Constant constant;
   // TODO(johnniwinther): Change to [Element] when dependency nodes are added.
   final Registry registry;
 
   const Dependency(this.constant, this.registry);
 }