anchor.diff:    ConcreteType _concreteType;
     ConcreteType get concreteType =>
         _concreteType ??= new ConcreteType(this, class_.rawType);
  +
  +  Type _specializedConeType;
  +  Type get specializedConeType =>
  +      _specializedConeType ??= _calculateConeTypeSpecialization();
  +
  +  Type _calculateConeTypeSpecialization() {
  +    final int numSubTypes = _allocatedSubtypes.length;
  +    if (numSubTypes == 0) {
  +      return new Type.empty();
  +    } else if (numSubTypes == 1) {
  +      return _allocatedSubtypes.single.concreteType;
  +    } else {
  +      List<ConcreteType> types = new List<ConcreteType>();
  +      for (var sub in _allocatedSubtypes) {
  +        types.add(sub.concreteType);
  +      }
  +      // SetType constructor expects a list of ConcreteTypes sorted by classId
  +      // (for faster intersections and unions).
  +      types.sort();
  +      return new SetType(types);
  +    }
  +  }
  +
  +  void addAllocatedSubtype(_ClassData subType) {
  +    _allocatedSubtypes.add(subType);
  +    _specializedConeType = null; // Reset cached specialization.
  +  }
   
     @override
     int get hashCode => _id;
  
positive.code:   final int _id;
    final Class class_;
    final Set<_ClassData> supertypes; // List of super-types including this.
    final Set<_ClassData> allocatedSubtypes = new Set<_ClassData>();
  
    /// Flag indicating if this class has a noSuchMethod() method not inherited
    /// from Object.
  
negative.code: 
      _ClassData classData = getClassData(baseClass);
  
      if (!_sealed) {
        classData.addDependentInvocation(_typeFlowAnalysis.currentInvocation);
      }
  
      return classData.specializedConeType;
    }
  
    bool hasNonTrivialNoSuchMethod(Class c) {
  