anchor.diff:      _specializedConeType = null; // Reset cached specialization.
     }
   
  -  Member? getDispatchTarget(
  -      Selector selector, TypeFlowAnalysis typeFlowAnalysis) {
  -    Member? target = _dispatchTargets[selector];
  -    if (target == null) {
  -      target = typeFlowAnalysis.hierarchyCache.hierarchy.getDispatchTarget(
  -          classNode, selector.name,
  -          setter: selector.isSetter);
  -      target ??= _DispatchableInvocation.kNoSuchMethodMarker;
  -      _dispatchTargets[selector] = target;
  -    }
  -    return identical(target, _DispatchableInvocation.kNoSuchMethodMarker)
  -        ? null
  -        : target;
  +  Map<Name, Member> _initDispatchTargets(bool setters) {
  +    Map<Name, Member> targets;
  +    final superclass = this.superclass;
  +    if (superclass != null) {
  +      targets = Map.from(setters
  +          ? superclass._dispatchTargetsSetters
  +          : superclass._dispatchTargetsNonSetters);
  +    } else {
  +      targets = {};
  +    }
  +    for (Field f in classNode.fields) {
  +      if (!f.isStatic && !f.isAbstract) {
  +        if (!setters || f.hasSetter) {
  +          targets[f.name] = f;
  +        }
  +      }
  +    }
  +    for (Procedure p in classNode.procedures) {
  +      if (!p.isStatic && !p.isAbstract) {
  +        if (p.isSetter == setters) {
  +          targets[p.name] = p;
  +        }
  +      }
  +    }
  +    return targets;
  +  }
  +
  +  Member? getDispatchTarget(Selector selector) {
  +    return (selector.isSetter
  +        ? _dispatchTargetsSetters
  +        : _dispatchTargetsNonSetters)[selector.name];
     }
   
     String dump() => "$this {supers: $supertypes}";
  
positive.code:   /// Lazy initialized by ClassHierarchyCache.hasNonTrivialNoSuchMethod().
    bool? hasNonTrivialNoSuchMethod;
  
    _TFClassImpl(int id, Class classNode, this.supertypes)
        : super(id, classNode) {
      supertypes.add(this);
    }
  
negative.code:     for (var sup in c.supers) {
        supertypes.addAll(getTFClass(sup.classNode).supertypes);
      }
      Class? superclassNode = c.superclass;
      _TFClassImpl? superclass =
          superclassNode != null ? getTFClass(superclassNode) : null;
      return new _TFClassImpl(++_classIdCounter, c, superclass, supertypes);
    }
  
    ConcreteType addAllocatedClass(Class cl) {
  