Split TypedSelector into Selector and TypeMask.

pkg/compiler/lib/src/enqueue.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.
 
 part of dart2js;
 
 typedef ItemCompilationContext ItemCompilationContextCreator();
 
 class EnqueueTask extends CompilerTask {
   final ResolutionEnqueuer resolution;
@@ skipping 17 matching lines @@
 
   void forgetElement(Element element) {
     resolution.forgetElement(element);
     codegen.forgetElement(element);
   }
 }
 
 class WorldImpact {
   const WorldImpact();
 
-  Iterable<Selector> get dynamicInvocations => const <Selector>[];
-  Iterable<Selector> get dynamicGetters => const <Selector>[];
-  Iterable<Selector> get dynamicSetters => const <Selector>[];
+  Iterable<UniverseSelector> get dynamicInvocations =>
+      const <UniverseSelector>[];
+  Iterable<UniverseSelector> get dynamicGetters => const <UniverseSelector>[];
+  Iterable<UniverseSelector> get dynamicSetters => const <UniverseSelector>[];
 
   // TODO(johnniwinther): Split this into more precise subsets.
   Iterable<Element> get staticUses => const <Element>[];
 
   // TODO(johnniwinther): Replace this by called constructors with type
   // arguments.
   Iterable<InterfaceType> get instantiatedTypes => const <InterfaceType>[];
 
   // TODO(johnniwinther): Collect checked types for checked mode separately to
   // support serialization.
@@ skipping 85 matching lines @@
   }
 
   void processInstantiatedClassMembers(ClassElement cls) {
     cls.implementation.forEachMember(processInstantiatedClassMember);
   }
 
   void processInstantiatedClassMember(ClassElement cls, Element member) {
     assert(invariant(member, member.isDeclaration));
     if (isProcessed(member)) return;
     if (!member.isInstanceMember) return;
-
     String memberName = member.name;
 
     if (member.kind == ElementKind.FIELD) {
       // The obvious thing to test here would be "member.isNative",
       // however, that only works after metadata has been parsed/analyzed,
       // and that may not have happened yet.
       // So instead we use the enclosing class, which we know have had
       // its metadata parsed and analyzed.
       // Note: this assumes that there are no non-native fields on native
       // classes, which may not be the case when a native class is subclassed.
@@ skipping 112 matching lines @@
             cls, this, compiler.globalDependencies);
       }
       processClass(cls);
       for (Link<DartType> supertypes = cls.allSupertypes;
            !supertypes.isEmpty; supertypes = supertypes.tail) {
         processClass(supertypes.head.element);
       }
     });
   }
 
-  void registerNewSelector(Selector selector,
-                           Map<String, Set<Selector>> selectorsMap) {
-    String name = selector.name;
-    Set<Selector> selectors =
-        selectorsMap.putIfAbsent(name, () => new Setlet<Selector>());
-    if (!selectors.contains(selector)) {
-      selectors.add(selector);
-      handleUnseenSelector(name, selector);
-    }
-  }
-
-  void registerInvocation(Selector selector) {
+  void registerInvocation(UniverseSelector selector) {
     task.measure(() {
-      registerNewSelector(selector, universe.invokedNames);
+      if (universe.registerInvocation(selector)) {
+        handleUnseenSelector(selector);
+      }
     });
   }
 
-  void registerInvokedGetter(Selector selector) {
+  void registerInvokedGetter(UniverseSelector selector) {
     task.measure(() {
-      registerNewSelector(selector, universe.invokedGetters);
+      if (universe.registerInvokedGetter(selector)) {
+        handleUnseenSelector(selector);
+      }
     });
   }
 
-  void registerInvokedSetter(Selector selector) {
+  void registerInvokedSetter(UniverseSelector selector) {
     task.measure(() {
-      registerNewSelector(selector, universe.invokedSetters);
+      if (universe.registerInvokedSetter(selector)) {
+        handleUnseenSelector(selector);
+      }
     });
   }
 
   /**
    * Decides whether an element should be included to satisfy requirements
    * of the mirror system. [includedEnclosing] provides a hint whether the
    * enclosing element was included.
    *
    * The actual implementation depends on the current compiler phase.
    */
@@ skipping 33 matching lines @@
       if (element.isTypedef) {
         TypedefElement typedef = element;
         typedef.ensureResolved(compiler);
         compiler.world.allTypedefs.add(element);
       } else if (Elements.isStaticOrTopLevel(element)) {
         registerStaticUse(element.declaration);
       } else if (element.isInstanceMember) {
         // We need to enqueue all members matching this one in subclasses, as
         // well.
         // TODO(herhut): Use TypedSelector.subtype for enqueueing
-        Selector selector = new Selector.fromElement(element);
+        UniverseSelector selector = new UniverseSelector(
+            new Selector.fromElement(element), null);
         registerSelectorUse(selector);
         if (element.isField) {
-          Selector selector =
-              new Selector.setter(element.name, element.library);
+          UniverseSelector selector = new UniverseSelector(
+              new Selector.setter(element.name, element.library), null);
           registerInvokedSetter(selector);
         }
       }
     }
   }
 
   /// Enqeue the member [element] if it is required for reflection.
   ///
   /// [enclosingWasIncluded] provides a hint whether the enclosing element was
   /// needed for reflection.
@@ skipping 119 matching lines @@
   }
 
   processInstanceMembers(String n, bool f(Element e)) {
     processSet(instanceMembersByName, n, f);
   }
 
   processInstanceFunctions(String n, bool f(Element e)) {
     processSet(instanceFunctionsByName, n, f);
   }
 
-  void handleUnseenSelector(String methodName, Selector selector) {
+  void handleUnseenSelector(UniverseSelector universeSelector) {
+    Selector selector = universeSelector.selector;
+    String methodName = selector.name;
     processInstanceMembers(methodName, (Element member) {
-      if (selector.appliesUnnamed(member, compiler.world)) {
+      if (universeSelector.appliesUnnamed(member, compiler.world)) {
         if (member.isFunction && selector.isGetter) {
           registerClosurizedMember(member, compiler.globalDependencies);
         }
         if (member.isField && member.enclosingClass.isNative) {
           if (selector.isGetter || selector.isCall) {
             nativeEnqueuer.registerFieldLoad(member);
             // We have to also handle storing to the field because we only get
             // one look at each member and there might be a store we have not
             // seen yet.
             // TODO(sra): Process fields for storing separately.
             nativeEnqueuer.registerFieldStore(member);
           } else {
             assert(selector.isSetter);
             nativeEnqueuer.registerFieldStore(member);
             // We have to also handle loading from the field because we only get
             // one look at each member and there might be a load we have not
             // seen yet.
             // TODO(sra): Process fields for storing separately.
             nativeEnqueuer.registerFieldLoad(member);
           }
         }
         addToWorkList(member);
         return true;
       }
       return false;
     });
     if (selector.isGetter) {
       processInstanceFunctions(methodName, (Element member) {
-        if (selector.appliesUnnamed(member, compiler.world)) {
+        if (universeSelector.appliesUnnamed(member, compiler.world)) {
           registerClosurizedMember(member, compiler.globalDependencies);
           return true;
         }
         return false;
       });
     }
   }
 
   /**
    * Documentation wanted -- johnniwinther
@@ skipping 10 matching lines @@
     addToWorkList(element);
     compiler.backend.registerStaticUse(element, this);
   }
 
   void registerGetOfStaticFunction(FunctionElement element) {
     registerStaticUse(element);
     compiler.backend.registerGetOfStaticFunction(this);
     universe.staticFunctionsNeedingGetter.add(element);
   }
 
-  void registerDynamicInvocation(Selector selector) {
+  void registerDynamicInvocation(UniverseSelector selector) {
     assert(selector != null);
     registerInvocation(selector);
   }
 
-  void registerSelectorUse(Selector selector) {
-    if (selector.isGetter) {
-      registerInvokedGetter(selector);
-    } else if (selector.isSetter) {
-      registerInvokedSetter(selector);
+  void registerSelectorUse(UniverseSelector universeSelector) {
+    if (universeSelector.selector.isGetter) {
+      registerInvokedGetter(universeSelector);
+    } else if (universeSelector.selector.isSetter) {
+      registerInvokedSetter(universeSelector);
     } else {
-      registerInvocation(selector);
+      registerInvocation(universeSelector);
     }
   }
 
-  void registerDynamicGetter(Selector selector) {
+  void registerDynamicGetter(UniverseSelector selector) {
     registerInvokedGetter(selector);
   }
 
-  void registerDynamicSetter(Selector selector) {
+  void registerDynamicSetter(UniverseSelector selector) {
     registerInvokedSetter(selector);
   }
 
   void registerGetterForSuperMethod(Element element) {
     universe.methodsNeedingSuperGetter.add(element);
   }
 
   void registerFieldGetter(Element element) {
     universe.fieldGetters.add(element);
   }
@@ skipping 240 matching lines @@
 }
 
 /// [Enqueuer] which is specific to code generation.
 class CodegenEnqueuer extends Enqueuer {
   final Queue<CodegenWorkItem> queue;
   final Map<Element, js.Expression> generatedCode =
       new Map<Element, js.Expression>();
 
   final Set<Element> newlyEnqueuedElements;
 
-  final Set<Selector> newlySeenSelectors;
+  final Set<UniverseSelector> newlySeenSelectors;
 
   bool enabledNoSuchMethod = false;
 
   CodegenEnqueuer(Compiler compiler,
                   ItemCompilationContext itemCompilationContextCreator())
       : queue = new Queue<CodegenWorkItem>(),
         newlyEnqueuedElements = compiler.cacheStrategy.newSet(),
         newlySeenSelectors = compiler.cacheStrategy.newSet(),
         super('codegen enqueuer', compiler, itemCompilationContextCreator);
 
@@ skipping 55 matching lines @@
     generatedCode.remove(element);
     if (element is MemberElement) {
       for (Element closure in element.nestedClosures) {
         generatedCode.remove(closure);
         removeFromSet(instanceMembersByName, closure);
         removeFromSet(instanceFunctionsByName, closure);
       }
     }
   }
 
-  void handleUnseenSelector(String methodName, Selector selector) {
+  void handleUnseenSelector(UniverseSelector selector) {
     if (compiler.hasIncrementalSupport) {
       newlySeenSelectors.add(selector);
     }
-    super.handleUnseenSelector(methodName, selector);
+    super.handleUnseenSelector(selector);
   }
 }
 
 /// Parameterizes filtering of which work items are enqueued.
 class QueueFilter {
   bool checkNoEnqueuedInvokedInstanceMethods(Enqueuer enqueuer) {
     enqueuer.task.measure(() {
       // Run through the classes and see if we need to compile methods.
       for (ClassElement classElement in
                enqueuer.universe.directlyInstantiatedClasses) {
@@ skipping 10 matching lines @@
   void processWorkItem(void f(WorkItem work), WorkItem work) {
     f(work);
   }
 }
 
 void removeFromSet(Map<String, Set<Element>> map, Element element) {
   Set<Element> set = map[element.name];
   if (set == null) return;
   set.remove(element);
 }