Add a type kind to TypedSelector. A typed selector can either be

sdk/lib/_internal/compiler/implementation/universe/universe.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.
 
 library universe;
 
 import '../closure.dart';
 import '../elements/elements.dart';
 import '../dart2jslib.dart';
 import '../dart_types.dart';
@@ skipping 23 matching lines @@
   final Set<FunctionElement> staticFunctionsNeedingGetter;
   final Map<SourceString, Set<Selector>> invokedNames;
   final Map<SourceString, Set<Selector>> invokedGetters;
   final Map<SourceString, Set<Selector>> invokedSetters;
 
   /**
    * Fields accessed. Currently only the codegen knows this
    * information. The resolver is too conservative when seeing a
    * getter and only registers an invoked getter.
    */
-  final Map<SourceString, Set<Selector>> fieldGetters;
+  final Set<Element> fieldGetters;
 
   /**
    * Fields set. See comment in [fieldGetters].
    */
-  final Map<SourceString, Set<Selector>> fieldSetters;
+  final Set<Element> fieldSetters;
   final Set<DartType> isChecks;
 
   Universe() : instantiatedClasses = new Set<ClassElement>(),
                instantiatedTypes = new Set<DartType>(),
                staticFunctionsNeedingGetter = new Set<FunctionElement>(),
                invokedNames = new Map<SourceString, Set<Selector>>(),
                invokedGetters = new Map<SourceString, Set<Selector>>(),
-               fieldGetters = new Map<SourceString, Set<Selector>>(),
-               fieldSetters = new Map<SourceString, Set<Selector>>(),
                invokedSetters = new Map<SourceString, Set<Selector>>(),
+               fieldGetters = new Set<Element>(),
+               fieldSetters = new Set<Element>(),
                isChecks = new Set<DartType>();
 
   bool hasMatchingSelector(Set<Selector> selectors,
                            Element member,
                            Compiler compiler) {
     if (selectors == null) return false;
     for (Selector selector in selectors) {
       if (selector.appliesUnnamed(member, compiler)) return true;
     }
     return false;
   }
 
   bool hasInvocation(Element member, Compiler compiler) {
     return hasMatchingSelector(invokedNames[member.name], member, compiler);
   }
 
   bool hasInvokedGetter(Element member, Compiler compiler) {
     return hasMatchingSelector(invokedGetters[member.name], member, compiler);
   }
 
   bool hasInvokedSetter(Element member, Compiler compiler) {
     return hasMatchingSelector(invokedSetters[member.name], member, compiler);
   }
 
   bool hasFieldGetter(Element member, Compiler compiler) {
-    return hasMatchingSelector(fieldGetters[member.name], member, compiler);
+    return fieldGetters.contains(member);
   }
 
   bool hasFieldSetter(Element member, Compiler compiler) {
-    return hasMatchingSelector(fieldSetters[member.name], member, compiler);
+    return fieldSetters.contains(member);
   }
 }
 
 class SelectorKind {
   final String name;
   const SelectorKind(this.name);
 
   static const SelectorKind GETTER = const SelectorKind('getter');
   static const SelectorKind SETTER = const SelectorKind('setter');
   static const SelectorKind CALL = const SelectorKind('call');
   static const SelectorKind OPERATOR = const SelectorKind('operator');
   static const SelectorKind INDEX = const SelectorKind('index');
 
-  toString() => name;
+  String toString() => name;
+}
+
+class TypedSelectorKind {
+  final String name;
+  const TypedSelectorKind(this.name);
+
+  /// Unknown type: used for untyped selector.
+  static const TypedSelectorKind UNKNOWN = const TypedSelectorKind('unknown');
+
+  // Exact type: the selector knows the exact type of the receiver.
+  // For example [:new Map():].
+  static const TypedSelectorKind EXACT = const TypedSelectorKind('exact');
+
+  // Subclass type: the receiver type is in a subclass hierarchy.
+  // For example [:this:].
+  static const TypedSelectorKind SUBCLASS = const TypedSelectorKind('subclass');
+
+  // Interface type: any type that implements the receiver type.
+  // For example [(foo as Foo).bar()], or any type annotation in
+  // checked mode.
+  static const TypedSelectorKind INTERFACE =
+      const TypedSelectorKind('interface');
+
+  String toString() => name;
 }
 
 class Selector {
   final SelectorKind kind;
   final SourceString name;
   final LibraryElement library; // Library is null for non-private selectors.
 
   // The numbers of arguments of the selector. Includes named arguments.
   final int argumentCount;
   final List<SourceString> namedArguments;
   final List<SourceString> orderedNamedArguments;
+  TypedSelectorKind get typeKind => TypedSelectorKind.UNKNOWN;
 
   Selector(
       this.kind,
       SourceString name,
       LibraryElement library,
       this.argumentCount,
       [List<SourceString> namedArguments = const <SourceString>[]])
     : this.name = name,
       this.library = name.isPrivate() ? library : null,
       this.namedArguments = namedArguments,
@@ skipping 236 matching lines @@
 
   bool operator ==(other) {
     if (other is !Selector) return false;
     return identical(receiverType, other.receiverType)
         && equalsUntyped(other);
   }
 
   bool equalsUntyped(Selector other) {
     return name == other.name
            && kind == other.kind
+           && typeKind == other.typeKind
            && identical(library, other.library)
            && argumentCount == other.argumentCount
            && namedArguments.length == other.namedArguments.length
            && sameNames(namedArguments, other.namedArguments);
   }
 
   List<SourceString> getOrderedNamedArguments() {
     if (namedArguments.isEmpty) return namedArguments;
     if (!orderedNamedArguments.isEmpty) return orderedNamedArguments;
 
@@ skipping 13 matching lines @@
       }
       return "[$result]";
     }
     return '';
   }
 
   String toString() {
     String named = '';
     String type = '';
     if (namedArgumentCount > 0) named = ', named=${namedArgumentsToString()}';
-    if (receiverType != null) type = ', type=$receiverType';
+    if (receiverType != null) type = ', type=$typeKind $receiverType';
     return 'Selector($kind, ${name.slowToString()}, '
            'arity=$argumentCount$named$type)';
   }
 }
 
 class TypedSelector extends Selector {
   /**
-   * The type of the receiver. Any subtype of that type can be the
-   * target of the invocation.
+   * The type of the receiver.
    */
   final DartType receiverType;
+  final TypedSelectorKind typeKind;
 
   final Selector asUntyped;
 
-  TypedSelector(DartType this.receiverType, Selector selector)
+  TypedSelector(DartType this.receiverType, this.typeKind, Selector selector)
       : asUntyped = selector.asUntyped,
         super(selector.kind,
               selector.name,
               selector.library,
               selector.argumentCount,
               selector.namedArguments) {
     // Invariant: Typed selector can not be based on a malformed type.
     assert(!identical(receiverType.kind, TypeKind.MALFORMED_TYPE));
     assert(asUntyped.receiverType == null);
+    assert(typeKind != TypedSelectorKind.UNKNOWN);
   }
 
+  TypedSelector.subclass(DartType receiverType, Selector selector)
+      : this(receiverType, TypedSelectorKind.SUBCLASS, selector);
+
+  TypedSelector.exact(DartType receiverType, Selector selector)
+      : this(receiverType, TypedSelectorKind.EXACT, selector);
+
+  TypedSelector.subtype(DartType receiverType, Selector selector)
+      : this(receiverType, TypedSelectorKind.INTERFACE, selector);
+
   /**
    * Check if [element] will be the one used at runtime when being
    * invoked on an instance of [cls].
    */
   bool hasElementIn(ClassElement cls, Element element) {
     // Use the selector for the lookup instead of [:element.name:]
     // because the selector has the right privacy information.
     Element resolved = cls.lookupSelector(this);
     if (resolved == element) return true;
     if (resolved == null) return false;
     if (resolved.isAbstractField()) {
       AbstractFieldElement field = resolved;
       if (element == field.getter || element == field.setter) {
         return true;
       } else {
-        ClassElement otherCls = field.getEnclosingClass();
         // We have not found a match, but another class higher in the
         // hierarchy may define the getter or the setter.
-        return hasElementIn(otherCls.superclass, element);
+        ClassElement otherCls = field.getEnclosingClass().superclass;
+        if (otherCls == null) return false;
+        return hasElementIn(otherCls, element);
       }
     }
     return false;
   }
 
   bool appliesUnnamed(Element element, Compiler compiler) {
     assert(sameNameHack(element, compiler));
     // [TypedSelector] are only used when compiling.
     assert(compiler.phase == Compiler.PHASE_COMPILING);
     if (!element.isMember()) return false;
 
     // A closure can be called through any typed selector:
     // class A {
     //   get foo => () => 42;
     //   bar() => foo(); // The call to 'foo' is a typed selector.
     // }
     ClassElement other = element.getEnclosingClass();
     if (identical(other.superclass, compiler.closureClass)) {
       return appliesUntyped(element, compiler);
     }
 
     Element self = receiverType.element;
     if (self.isTypedef()) {
       // A typedef is a function type that doesn't have any
       // user-defined members.
       return false;
     }
 
-    if (other.implementsInterface(self)
-        || other.isSubclassOf(self)
-        || compiler.world.hasAnySubclassThatImplements(other, receiverType)) {
-      return appliesUntyped(element, compiler);
-    }
+    if (typeKind == TypedSelectorKind.EXACT) {
+      return hasElementIn(self, element) && appliesUntyped(element, compiler);
+    } else if (typeKind == TypedSelectorKind.SUBCLASS) {
+      return (hasElementIn(self, element) || other.isSubclassOf(self))
+          && appliesUntyped(element, compiler);
+    } else {
+      assert(typeKind == TypedSelectorKind.INTERFACE);
+      if (other.implementsInterface(self)
+          || other.isSubclassOf(self)
+          || compiler.world.hasAnySubclassThatImplements(other, receiverType)) {
+        return appliesUntyped(element, compiler);
+      }
 
-    // If [self] is a subclass of [other], it inherits the
-    // implementation of [element].
-    ClassElement cls = self;
-    if (cls.isSubclassOf(other)) {
-      // Resolve an invocation of [element.name] on [self]. If it
-      // is found, this selector is a candidate.
-      return hasElementIn(self, element) && appliesUntyped(element, compiler);
+      // If [self] is a subclass of [other], it inherits the
+      // implementation of [element].
+      ClassElement cls = self;
+      if (cls.isSubclassOf(other)) {
+        // Resolve an invocation of [element.name] on [self]. If it
+        // is found, this selector is a candidate.
+        return hasElementIn(self, element) && appliesUntyped(element, compiler);
+      }
     }
 
     return false;
   }
 }