Add forEachLibraryMember and forEachConstructor to ElementEnvironment

pkg/compiler/lib/src/kernel/element_map_impl.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.kernel.element_map;
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers;
@@ skipping 141 matching lines @@
     });
   }
 
   MemberEntity lookupLibraryMember(KLibrary library, String name,
       {bool setter: false}) {
     _KLibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
     ir.Member member = libraryEnv.lookupMember(name, setter: setter);
     return member != null ? getMember(member) : null;
   }
 
+  void _forEachLibraryMember(KLibrary library, void f(MemberEntity member)) {
+    _KLibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
+    libraryEnv.forEachMember((ir.Member node) {
+      f(getMember(node));
+    });
+  }
+
   ClassEntity lookupClass(KLibrary library, String name) {
     _KLibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
     _KClassEnv classEnv = libraryEnv.lookupClass(name);
     if (classEnv != null) {
       return _getClass(classEnv.cls, classEnv);
     }
     return null;
   }
 
   void _forEachClass(KLibrary library, void f(ClassEntity cls)) {
@@ skipping 351 matching lines @@
     while (cls != null) {
       _KClassEnv env = _classEnvs[cls.classIndex];
       _ensureSupertypes(cls, env);
       if (env.mixedInType != null) {
         f(env.mixedInType.element);
       }
       cls = env.supertype?.element;
     }
   }
 
+  void _forEachConstructor(KClass cls, void f(ConstructorEntity member)) {
+    _KClassEnv env = _classEnvs[cls.classIndex];
+    env.forEachConstructor((ir.Member member) {
+      f(getConstructor(member));
+    });
+  }
+
   void _forEachClassMember(
       KClass cls, void f(ClassEntity cls, MemberEntity member)) {
     _KClassEnv env = _classEnvs[cls.classIndex];
     env.forEachMember((ir.Member member) {
       f(cls, getMember(member));
     });
     _ensureSupertypes(cls, env);
     if (env.supertype != null) {
       _forEachClassMember(env.supertype.element, f);
     }
@@ skipping 159 matching lines @@
     _ensureClassMap();
     return _classMap[name];
   }
 
   /// Calls [f] for each class in this library.
   void forEachClass(void f(_KClassEnv cls)) {
     _ensureClassMap();
     _classMap.values.forEach(f);
   }
 
-  /// Return the [ir.Member] for the member [name] in [library].
-  ir.Member lookupMember(String name, {bool setter: false}) {
+  void _ensureMemberMaps() {
     if (_memberMap == null) {
       _memberMap = <String, ir.Member>{};
       _setterMap = <String, ir.Member>{};
       for (ir.Member member in library.members) {
         if (member is ir.Procedure) {
           if (member.kind == ir.ProcedureKind.Setter) {
             _setterMap[member.name.name] = member;
           } else {
             _memberMap[member.name.name] = member;
           }
         } else if (member is ir.Field) {
           _memberMap[member.name.name] = member;
           if (member.isMutable) {
             _setterMap[member.name.name] = member;
           }
         } else {
           throw new SpannableAssertionFailure(
               NO_LOCATION_SPANNABLE, "Unexpected library member node: $member");
         }
       }
     }
-    return _memberMap[name];
+  }
+
+  /// Return the [ir.Member] for the member [name] in [library].
+  ir.Member lookupMember(String name, {bool setter: false}) {
+    _ensureMemberMaps();
+    return setter ? _setterMap[name] : _memberMap[name];
+  }
+
+  void forEachMember(void f(ir.Member member)) {
+    _ensureMemberMaps();
+    _memberMap.values.forEach(f);
+    for (ir.Member member in _setterMap.values) {
+      if (member is ir.Procedure) {
+        f(member);
+      } else {
+        // Skip fields; these are also in _memberMap.
+      }
+    }
   }
 }
 
 /// Environment for fast lookup of class members.
 class _KClassEnv {
   final ir.Class cls;
   final bool isUnnamedMixinApplication;
 
   InterfaceType thisType;
   InterfaceType rawType;
@@ skipping 58 matching lines @@
     _ensureMaps();
     return setter ? _setterMap[name] : _memberMap[name];
   }
 
   /// Return the [ir.Member] for the member [name] in [library].
   ir.Member lookupConstructor(String name) {
     _ensureMaps();
     return _constructorMap[name];
   }
 
-  void forEachMember(f(ir.Member member)) {
+  void forEachMember(void f(ir.Member member)) {
     _ensureMaps();
     _memberMap.values.forEach(f);
     for (ir.Member member in _setterMap.values) {
       if (member is ir.Procedure) {
         f(member);
       } else {
         // Skip fields; these are also in _memberMap.
       }
     }
   }
 
+  void forEachConstructor(void f(ir.Member member)) {
+    _ensureMaps();
+    _constructorMap.values.forEach(f);
+  }
+
   Iterable<ConstantValue> getMetadata(KernelToElementMapImpl elementMap) {
     return _metadata ??= elementMap.getMetadata(cls.annotations);
   }
 }
 
 class _MemberData {
   final ir.Member node;
   Iterable<ConstantValue> _metadata;
 
   _MemberData(this.node);
@@ skipping 177 matching lines @@
     elementMap._forEachMixin(cls, f);
   }
 
   @override
   void forEachClassMember(
       ClassEntity cls, void f(ClassEntity declarer, MemberEntity member)) {
     elementMap._forEachClassMember(cls, f);
   }
 
   @override
+  void forEachConstructor(
+      ClassEntity cls, void f(ConstructorEntity constructor)) {
+    elementMap._forEachConstructor(cls, f);
+  }
+
+  @override
+  void forEachLibraryMember(
+      LibraryEntity library, void f(MemberEntity member)) {
+    elementMap._forEachLibraryMember(library, f);
+  }
+
+  @override
   MemberEntity lookupLibraryMember(LibraryEntity library, String name,
       {bool setter: false, bool required: false}) {
     MemberEntity member =
         elementMap.lookupLibraryMember(library, name, setter: setter);
     if (member == null && required) {
       throw new SpannableAssertionFailure(CURRENT_ELEMENT_SPANNABLE,
           "The member '${name}' was not found in library '${library.name}'.");
     }
     return member;
   }
@@ skipping 328 matching lines @@
     return node.isExternal &&
         !elementMap.isForeignLibrary(node.enclosingLibrary);
   }
 
   @override
   bool isJsInteropMember(MemberEntity element) {
     // TODO(johnniwinther): Compute this.
     return false;
   }
 }