Add forEachLibraryMember and forEachConstructor to ElementEnvironment

pkg/compiler/lib/src/resolution/resolution_strategy.dart

 // Copyright (c) 2017, 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_strategy;
 
 import '../common.dart';
 import '../common_elements.dart';
 import '../common/backend_api.dart';
 import '../common/names.dart';
@@ skipping 276 matching lines @@
           "contain required member: '$name'.");
     }
     return member?.declaration;
   }
 
   @override
   ConstructorElement lookupConstructor(ClassElement cls, String name,
       {bool required: false}) {
     cls.ensureResolved(_resolution);
     ConstructorElement constructor = cls.implementation.lookupConstructor(name);
+    // TODO(johnniwinther): Skip redirecting factories.
     if (constructor == null && required) {
       throw new SpannableAssertionFailure(
           cls,
           "The class '${cls.name}' does not contain "
           "required constructor: '$name'.");
     }
     return constructor?.declaration;
   }
 
   @override
   void forEachClassMember(
       ClassElement cls, void f(ClassElement declarer, MemberElement member)) {
     cls.ensureResolved(_resolution);
     cls.forEachMember((ClassElement declarer, MemberElement member) {
       if (member.isSynthesized) return;
       if (member.isMalformed) return;
       if (member.isConstructor) return;
       f(declarer, member);
     }, includeSuperAndInjectedMembers: true);
   }
 
   @override
+  void forEachConstructor(
+      ClassElement cls, void f(ConstructorEntity constructor)) {
+    cls.ensureResolved(_resolution);
+    for (ConstructorElement constructor in cls.implementation.constructors) {
+      _resolution.ensureResolved(constructor.declaration);
+      if (constructor.isRedirectingFactory) continue;
+      f(constructor);
+    }
+  }
+
+  @override
   ClassEntity getSuperClass(ClassElement cls,
       {bool skipUnnamedMixinApplications: false}) {
     cls.ensureResolved(_resolution);
     ClassElement superclass = cls.superclass;
     if (skipUnnamedMixinApplications) {
       while (superclass != null && superclass.isUnnamedMixinApplication) {
         superclass = superclass.superclass;
       }
     }
     return superclass;
@@ skipping 37 matching lines @@
     if (member == null && required) {
       throw new SpannableAssertionFailure(
           member,
           "The library '${library.libraryName}' does not "
           "contain required member: '$name'.");
     }
     return member?.declaration;
   }
 
   @override
+  void forEachLibraryMember(
+      LibraryElement library, void f(MemberEntity member)) {
+    library.implementation.forEachLocalMember((Element element) {
+      if (!element.isClass && !element.isTypedef) {
+        MemberElement member = element;
+        f(member);
+      }
+    });
+  }
+
+  @override
   ClassElement lookupClass(LibraryElement library, String name,
       {bool required: false}) {
     ClassElement cls = library.implementation.findLocal(name);
     if (cls == null && required) {
       throw new SpannableAssertionFailure(
           library,
           "The library '${library.libraryName}' does not "
           "contain required class: '$name'.");
     }
     return cls?.declaration;
@@ skipping 277 matching lines @@
   @override
   WorkItem createWorkItem(MemberElement element) {
     assert(invariant(element, element.isDeclaration));
     if (element.isMalformed) return null;
 
     assert(invariant(element, element is AnalyzableElement,
         message: 'Element $element is not analyzable.'));
     return _resolution.createWorkItem(element);
   }
 }