All strong mode cleaning of dart2js.

pkg/compiler/lib/src/resolution/class_members.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.
 
 library dart2js.resolution.compute_members;
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers, Names;
 import '../common/resolution.dart' show Resolution;
 import '../elements/elements.dart'
@@ skipping 87 matching lines @@
   /// [classMembers].
   ///
   /// If [name] and [names] are not null, the computation is restricted to
   /// members with these names.
   void computeSuperClassMembers(String name, Setlet<Name> names) {
     ResolutionInterfaceType supertype = cls.supertype;
     if (supertype == null) return;
     ClassElement superclass = supertype.element;
 
     // Inherit class and interface members from superclass.
-    void inheritClassMember(DeclaredMember member) {
+    void inheritClassMember(Member _member) {
+      DeclaredMember member = _member;
       if (shouldSkipMember(member)) return;
       if (!member.isStatic) {
         DeclaredMember inherited = member.inheritFrom(supertype);
         classMembers[member.name] = inherited;
       }
     }
 
     if (names != null) {
       _computeClassMember(resolution, superclass, name, names);
       for (Name memberName in names) {
@@ skipping 10 matching lines @@
   /// If [name] and [names] are not null, the computation is restricted to
   /// members with these names.
   Map<Name, Member> computeClassMembers(String nameText, Setlet<Name> names) {
     Map<Name, Member> declaredMembers = new Map<Name, Member>();
 
     if (cls.isMixinApplication) {
       MixinApplicationElement mixinApplication = cls;
       if (mixinApplication.mixin != null) {
         // Only mix in class members when the mixin type is not malformed.
 
-        void inheritMixinMember(DeclaredMember member) {
+        void inheritMixinMember(Member _member) {
+          DeclaredMember member = _member;
           if (shouldSkipMember(member)) return;
           Name name = member.name;
           if (!member.isAbstract && !member.isStatic) {
             // Abstract and static members are not mixed in.
             DeclaredMember mixedInMember =
                 member.inheritFrom(mixinApplication.mixinType);
             DeclaredMember inherited = classMembers[name];
             classMembers[name] = mixedInMember;
             checkValidOverride(mixedInMember, inherited);
           }
         }
 
         if (names != null) {
           _computeClassMember(
               resolution, mixinApplication.mixin, nameText, names);
           for (Name memberName in names) {
             inheritMixinMember(
                 mixinApplication.mixin.lookupClassMember(memberName));
           }
         } else {
           computeAllClassMembers(resolution, mixinApplication.mixin);
           mixinApplication.mixin.forEachClassMember(inheritMixinMember);
         }
       }
     } else {
       LibraryElement library = cls.library;
       ResolutionInterfaceType thisType = cls.thisType;
 
-      void createMember(MemberElement element) {
+      void createMember(Element _element) {
+        MemberElement element = _element;
         if (element.isConstructor) return;
         String elementName = element.name;
         if (shouldSkipName(elementName)) return;
         if (nameText != null && elementName != nameText) return;
 
         void addDeclaredMember(Name name, ResolutionDartType type,
             ResolutionFunctionType functionType) {
           DeclaredMember inherited = classMembers[name];
           DeclaredMember declared;
           if (element.isAbstract) {
@@ skipping 783 matching lines @@
         failedAt(this, "Members have not been fully computed for $this."));
     if (interfaceMembersAreClassMembers) {
       classMembers.forEach((_, member) {
         if (!member.isStatic) f(member);
       });
     } else {
       interfaceMembers.forEach((_, member) => f(member));
     }
   }
 }