Finish strong mode cleaning of dart2js.

pkg/compiler/lib/src/js_backend/mirrors_analysis.dart

 // Copyright (c) 2016, 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.
 
 library dart2js.mirrors_handler;
 
 import '../common.dart';
 import '../common/resolution.dart';
 import '../compiler.dart';
 import '../constants/values.dart';
@@ skipping 43 matching lines @@
 
   DiagnosticReporter get _reporter => _backend.reporter;
   Compiler get _compiler => _backend.compiler;
   JavaScriptConstantCompiler get _constants => _backend.constants;
   MirrorsData get _mirrorsData => _backend.mirrorsData;
 
   /// Returns all static fields that are referenced through
   /// `mirrorsData.targetsUsed`. If the target is a library or class all nested
   /// static fields are included too.
   Iterable<Element> _findStaticFieldTargets() {
-    List staticFields = [];
+    List<Element> staticFields = <Element>[];
 
     void addFieldsInContainer(ScopeContainerElement container) {
       container.forEachLocalMember((Element member) {
         if (!member.isInstanceMember && member.isField) {
           staticFields.add(member);
         } else if (member.isClass) {
           addFieldsInContainer(member);
         }
       });
     }
@@ skipping 289 matching lines @@
       ClassElement declaration = cls.declaration;
       declaration.ensureResolved(_resolution);
       impactBuilder.registerTypeUse(
           new TypeUse.mirrorInstantiation(declaration.rawType));
     }
     // If the class is never instantiated, we know nothing of it can possibly
     // be reflected upon.
     // TODO(herhut): Add a warning if a mirrors annotation cannot hit.
     if (recents.contains(cls.declaration)) {
       _logEnqueueReflectiveAction(cls, "members");
-      cls.constructors.forEach((ConstructorElement element) {
+      cls.constructors.forEach((Element element) {
         _enqueueReflectiveConstructor(element.declaration,
             enclosingWasIncluded: includeClass);
       });
       cls.forEachClassMember((Member member) {
         _enqueueReflectiveMember(member.element, includeClass);
       });
     }
   }
 
   /// Set of classes that need to be considered for reflection although not
@@ skipping 71 matching lines @@
       for (LibraryElement lib in loadedLibraries) {
         _enqueueReflectiveElementsInLibrary(lib, recents);
       }
       _enqueueReflectiveSpecialClasses();
       hasEnqueuedReflectiveElements = true;
       hasEnqueuedReflectiveStaticFields = true;
       _logEnqueueReflectiveAction("!DONE enqueueAll");
     } else if (recents.isNotEmpty) {
       // Keep looking at new classes until fixpoint is reached.
       _logEnqueueReflectiveAction("!START enqueueRecents");
-      recents.forEach((ClassElement cls) {
+      recents.forEach((ClassEntity _cls) {
+        ClassElement cls = _cls;
         _enqueueReflectiveElementsInClass(cls, recents,
             enclosingWasIncluded: _shouldIncludeElementDueToMirrors(cls.library,
                 includedEnclosing: false));
       });
       _logEnqueueReflectiveAction("!DONE enqueueRecents");
     }
   }
 
   /// Enqueue the static fields that have been marked as used by reflective
   /// usage through `MirrorsUsed`.
   // TODO(johnniwinther): Compute [WorldImpact] instead of enqueuing directly.
   void enqueueReflectiveStaticFields(Iterable<Element> elements) {
     if (hasEnqueuedReflectiveStaticFields) return;
     hasEnqueuedReflectiveStaticFields = true;
     for (Element element in elements) {
       _enqueueReflectiveMember(element, true);
     }
   }
 }
 
 /// Records that [constant] is used by the element behind [registry].
 class Dependency {
   final ConstantValue constant;
   final Element annotatedElement;
 
   const Dependency(this.constant, this.annotatedElement);
 
   String toString() => '$annotatedElement:${constant.toStructuredText()}';
 }