Add LookupTable class for finding classes and members by name.

pkg/kernel/lib/transformations/treeshaker.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 kernel.tree_shaker;
 
 import '../ast.dart';
 import '../class_hierarchy.dart';
 import '../core_types.dart';
 import '../type_environment.dart';
+import '../lookup_table.dart';
 
 Program transformProgram(Program program, {List<ProgramRoot> programRoots}) {
   new TreeShaker(program, programRoots: programRoots).transform(program);
   return program;
 }
 
 enum ProgramRootKind {
   /// The root is a class which will be instantiated by
   /// external / non-Dart code.
   ExternallyInstantiatedClass,
@@ skipping 21 matching lines @@
 
   /// The name of the member inside the library (or class, optional).
   final String member;
 
   /// The kind of this program root.
   final ProgramRootKind kind;
 
   ProgramRoot(this.library, this.klass, this.member, this.kind);
 
   String toString() => "ProgramRoot($library, $klass, $member, $kind)";
+
+  String get disambiguatedName {
+    if (kind == ProgramRootKind.Getter) return 'get:$member';
+    if (kind == ProgramRootKind.Setter) return 'set:$member';
+    return member;
+  }
+
+  Member getMember(LookupTable table) {
+    assert(klass != null);
+    assert(member != null);
+    return table.getMember(
+        library, klass ?? LookupTable.topLevel, disambiguatedName);
+  }
+
+  Class getClass(LookupTable table) {
+    assert(klass != null);
+    return table.getClass(library, klass);
+  }
 }
 
 /// Tree shaking based on class hierarchy analysis.
 ///
 /// Any dynamic dispatch not on `this` is conservatively assumed to target
 /// any instantiated class that implements a member matching the selector.
 ///
 /// Member bodies are analyzed relative to a given "host class" which is the
 /// concrete type of `this` (or null if in static context), so dispatches on
 /// `this` can be resolved more precisely.
@@ skipping 134 matching lines @@
         this._usedMembersWithHost =
             new List<Set<Member>>(hierarchy.classes.length),
         this._classRetention = new List<ClassRetention>.filled(
             hierarchy.classes.length, ClassRetention.None) {
     _visitor = new _TreeShakerVisitor(this);
     _covariantVisitor = new _ExternalTypeVisitor(this, isCovariant: true);
     _contravariantVisitor =
         new _ExternalTypeVisitor(this, isContravariant: true);
     _invariantVisitor = new _ExternalTypeVisitor(this,
         isCovariant: true, isContravariant: true);
-    _mirrorsLibrary = coreTypes.getCoreLibrary('dart:mirrors');
+    _mirrorsLibrary = coreTypes.getLibrary('dart:mirrors');
     try {
       _build();
     } on _UsingMirrorsException {
       isUsingMirrors = true;
     }
   }
 
   void _build() {
     if (program.mainMethod == null) {
       throw 'Cannot perform tree shaking on a program without a main method';
     }
     if (program.mainMethod.function.positionalParameters.length > 0) {
       // The main method takes a List<String> as argument.
       _addInstantiatedExternalSubclass(coreTypes.listClass);
       _addInstantiatedExternalSubclass(coreTypes.stringClass);
     }
     _addDispatchedName(hierarchy.rootClass, new Name('noSuchMethod'));
     _addPervasiveUses();
     _addUsedMember(null, program.mainMethod);
-    programRoots?.forEach(_addUsedRoot);
+    if (programRoots != null) {
+      var table = new LookupTable(program, programRoots.map((r) => r.library));
+      for (var root in programRoots) {
+        _addUsedRoot(root, table);
+      }
+    }
 
     _iterateWorklist();
 
     // Mark overridden members in order to preserve abstract members as
     // necessary.
     if (strongMode) {
       for (int i = hierarchy.classes.length - 1; i >= 0; --i) {
         Class class_ = hierarchy.classes[i];
         if (isHierarchyUsed(class_)) {
           hierarchy.forEachOverridePair(class_,
@@ skipping 173 matching lines @@
   /// Ensures that all annotations on the class are analyzed.
   void _propagateClassNamespaceLevel(
       Class classNode, ClassRetention oldRetention) {
     if (oldRetention.index >= ClassRetention.Namespace.index) {
       return;
     }
     visitList(classNode.annotations, _visitor);
   }
 
   /// Registers the given root as being used.
-  void _addUsedRoot(ProgramRoot root) {
-    Library rootLibrary = _findLibraryRoot(root, program);
-
+  void _addUsedRoot(ProgramRoot root, LookupTable table) {
     if (root.kind == ProgramRootKind.ExternallyInstantiatedClass) {
-      Class rootClass = _findClassRoot(root, rootLibrary);
+      Class class_ = root.getClass(table);
 
       // This is a class which will be instantiated by non-Dart code (whether it
       // has a valid generative construtor or not).
-      _addInstantiatedClass(rootClass);
+      _addInstantiatedClass(class_);
 
       // We keep all the constructors of externally instantiated classes.
       // Sometimes the runtime might do a constructor call and sometimes it
       // might just allocate the class without invoking the constructor.
       // So we try to be on the safe side here!
-      for (var constructor in rootClass.constructors) {
-        _addUsedMember(rootClass, constructor);
+      for (var constructor in class_.constructors) {
+        _addUsedMember(class_, constructor);
       }
 
       // We keep all factory constructors as well for the same reason.
-      for (var member in rootClass.procedures) {
+      for (var member in class_.procedures) {
         if (member.isStatic && member.kind == ProcedureKind.Factory) {
-          _addUsedMember(rootClass, member);
+          _addUsedMember(class_, member);
         }
       }
     } else {
-      if (root.klass != null) {
-        // For class members we mark the Field/Procedure/Constructor as used.
-        // We also mark it as instantiated if it's a constructor.
-        Class rootClass = _findClassRoot(root, rootLibrary);
-        Member rootMember = _findMemberRoot(root, rootClass.members);
-        _addUsedMember(rootClass, rootMember);
-        if (rootMember is Constructor) {
-          _addInstantiatedClass(rootClass);
-        }
-      } else {
-        // For library members we mark the Field/Procedure as used.
-        Member rootMember = _findMemberRoot(root, rootLibrary.members);
-        _addUsedMember(null, rootMember);
+      var member = root.getMember(table);
+      _addUsedMember(member.enclosingClass, member);
+      if (member is Constructor) {
+        _addInstantiatedClass(member.enclosingClass);
       }
     }
   }
 
   /// Registers the given class as being used in a type annotation.
   void _addClassUsedInType(Class classNode) {
     int index = hierarchy.getClassIndex(classNode);
     ClassRetention retention = _classRetention[index];
     if (retention.index < ClassRetention.Hierarchy.index) {
       _classRetention[index] = ClassRetention.Hierarchy;
@@ skipping 595 matching lines @@
         classNode == coreTypes.futureClass ||
         classNode == coreTypes.streamClass ||
         classNode == coreTypes.listClass ||
         classNode == coreTypes.mapClass;
   }
 }
 
 /// Exception that is thrown to stop the tree shaking analysis when a use
 /// of `dart:mirrors` is found.
 class _UsingMirrorsException {}
-
-Library _findLibraryRoot(ProgramRoot root, Program program) {
-  for (var library in program.libraries) {
-    if (library.importUri.toString() == root.library) {
-      return library;
-    }
-  }
-
-  throw "$root not found!";
-}
-
-Class _findClassRoot(ProgramRoot root, Library rootLibrary) {
-  for (var klass in rootLibrary.classes) {
-    if (klass.name == root.klass) {
-      return klass;
-    }
-  }
-  throw "$root not found!";
-}
-
-Member _findMemberRoot(ProgramRoot root, Iterable<Member> membersToSearch) {
-  for (var member in membersToSearch) {
-    if (member.name.name == root.member) {
-      switch (root.kind) {
-        case ProgramRootKind.Constructor:
-          if (member is Procedure && member.kind == ProcedureKind.Factory ||
-              member is Constructor) {
-            return member;
-          }
-          break;
-        case ProgramRootKind.Setter:
-          if (member is Procedure && member.kind == ProcedureKind.Setter ||
-              member is Field) {
-            return member;
-          }
-          break;
-        case ProgramRootKind.Getter:
-          if (member is Procedure && member.kind == ProcedureKind.Getter ||
-              member is Field) {
-            return member;
-          }
-          break;
-        case ProgramRootKind.Other:
-          return member;
-        default:
-      }
-    }
-  }
-  throw "$root not found!";
-}