Split TypedSelector into Selector and TypeMask.

pkg/compiler/lib/src/world.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;
 
 abstract class ClassWorld {
   // TODO(johnniwinther): Refine this into a `BackendClasses` interface.
   Backend get backend;
 
@@ skipping 93 matching lines @@
 
 class World implements ClassWorld {
   ClassElement get objectClass => compiler.objectClass;
   ClassElement get functionClass => compiler.functionClass;
   ClassElement get boolClass => compiler.boolClass;
   ClassElement get numClass => compiler.numClass;
   ClassElement get intClass => compiler.intClass;
   ClassElement get doubleClass => compiler.doubleClass;
   ClassElement get stringClass => compiler.stringClass;
 
-  Map<Selector, Map<ti.TypeMask, TypedSelector>> canonicalizedValues =
-     new Map<Selector, Map<ti.TypeMask, TypedSelector>>();
+  List<Map<ClassElement, ti.TypeMask>> canonicalizedTypeMasks =
+      new List<Map<ClassElement, ti.TypeMask>>.filled(8, null);

[herhut, 2015/06/24 15:19:29]

I don't like the magic 8 here but I also have no suggestion how to derive it
from the use of flags in FlatTypeMask.

[Johnni Winther, 2015/06/25 07:25:28]

Added a comment explaining the relation.

 
   bool checkInvariants(ClassElement cls, {bool mustBeInstantiated: true}) {
     return
       invariant(cls, cls.isDeclaration,
                 message: '$cls must be the declaration.') &&
       invariant(cls, cls.isResolved,
                 message: '$cls must be resolved.') &&
       (!mustBeInstantiated ||
        invariant(cls, isInstantiated(cls),
                  message: '$cls is not instantiated.'));
@@ skipping 272 matching lines @@
                         ClassElement mixin) {
     // TODO(johnniwinther): Add map restricted to live classes.
     // We don't support patch classes as mixin.
     assert(mixin.isDeclaration);
     List<MixinApplicationElement> users =
         _mixinUses.putIfAbsent(mixin, () =>
                                new List<MixinApplicationElement>());
     users.add(mixinApplication);
   }
 
-  bool hasAnyUserDefinedGetter(Selector selector) {
-    return allFunctions.filter(selector).any((each) => each.isGetter);
+  bool hasAnyUserDefinedGetter(Selector selector, ti.TypeMask mask) {
+    return allFunctions.filter(selector, mask).any((each) => each.isGetter);
   }
 
   void registerUsedElement(Element element) {
     if (element.isInstanceMember && !element.isAbstract) {
       allFunctions.add(element);
     }
   }
 
-  VariableElement locateSingleField(Selector selector) {
-    Element result = locateSingleElement(selector);
+  VariableElement locateSingleField(Selector selector, ti.TypeMask mask) {
+    Element result = locateSingleElement(selector, mask);
     return (result != null && result.isField) ? result : null;
   }
 
-  Element locateSingleElement(Selector selector) {
-    ti.TypeMask mask = selector.mask == null
+  Element locateSingleElement(Selector selector, ti.TypeMask mask) {
+    mask = mask == null
         ? compiler.typesTask.dynamicType
-        : selector.mask;
-    return mask.locateSingleElement(selector, compiler);
+        : mask;
+    return mask.locateSingleElement(selector, mask, compiler);
+  }
+
+  ti.TypeMask extendMaskIfReachesAll(Selector selector, ti.TypeMask mask) {
+    bool canReachAll = true;
+    if (mask != null) {
+      canReachAll =
+          compiler.enabledInvokeOn &&
+          mask.needsNoSuchMethodHandling(selector, this);
+    }
+    return canReachAll ? compiler.typesTask.dynamicType : mask;
   }
 
   void addFunctionCalledInLoop(Element element) {
     functionsCalledInLoop.add(element.declaration);
   }
 
   bool isCalledInLoop(Element element) {
     return functionsCalledInLoop.contains(element.declaration);
   }
 
@@ skipping 30 matching lines @@
   void registerSideEffects(Element element, SideEffects effects) {
     if (sideEffectsFreeElements.contains(element)) return;
     sideEffects[element.declaration] = effects;
   }
 
   void registerSideEffectsFree(Element element) {
     sideEffects[element.declaration] = new SideEffects.empty();
     sideEffectsFreeElements.add(element);
   }
 
-  SideEffects getSideEffectsOfSelector(Selector selector) {
+  SideEffects getSideEffectsOfSelector(Selector selector, ti.TypeMask mask) {
     // We're not tracking side effects of closures.
     if (selector.isClosureCall) return new SideEffects();
     SideEffects sideEffects = new SideEffects.empty();
-    for (Element e in allFunctions.filter(selector)) {
+    for (Element e in allFunctions.filter(selector, mask)) {
       if (e.isField) {
         if (selector.isGetter) {
           if (!fieldNeverChanges(e)) {
             sideEffects.setDependsOnInstancePropertyStore();
           }
         } else if (selector.isSetter) {
           sideEffects.setChangesInstanceProperty();
         } else {
           assert(selector.isCall);
           sideEffects.setAllSideEffects();
@@ skipping 31 matching lines @@
     // function expressions's element.
     // TODO(herhut): Generate classes for function expressions earlier.
     if (element is closureMapping.SynthesizedCallMethodElementX) {
       return getMightBePassedToApply(element.expression);
     }
     return functionsThatMightBePassedToApply.contains(element);
   }
 
   bool get hasClosedWorldAssumption => !compiler.hasIncrementalSupport;
 }