anchor.diff:      void visitImmediateSuper(InterfaceType type) {
         // For members of mixins/supertypes, check them against new interfaces,
         // and also record any existing checks they already had.
  -      var oldCovariant = _findAllGenericInterfaces(type);
  +      var oldCovariant = _findAllGenericInterfaces(type.element);
         var newCovariant = allCovariant.difference(oldCovariant);
         if (newCovariant.isEmpty) return;
   
  
positive.code: 
        // The member may be from a superclass, so we need to ensure the type
        // parameters are properly substituted.
        var classType = targetType.element.type;
        var classLowerBound = classType.instantiate(new List.filled(
            classType.typeParameters.length, BottomTypeImpl.instance));
        var memberLowerBound = inheritance.getMember(
            classLowerBound, Name(element.librarySource.uri, element.name));
        if (memberLowerBound == null &&
            element.enclosingElement is ExtensionElement) {
          return;
  
negative.code:     return x == y;
    }
  
    /// Find all generic interfaces that are implemented by [element], including
    /// [element] itself if it is generic.
    ///
    /// This represents the complete set of unsafe covariant interfaces that could
    /// be used to call members of [element].
    ///
    /// Because we're going to instantiate these to their upper bound, we don't
    /// have to track type parameters.
    static Set<ClassElement> _findAllGenericInterfaces(ClassElement element) {
      var visited = <ClassElement>{};
      var genericSupertypes = <ClassElement>{};
  
      void visitClassAndSupertypes(ClassElement element) {
        if (visited.add(element)) {
          if (element.typeParameters.isNotEmpty) {
            genericSupertypes.add(element);
          }
  
          var supertype = element.supertype;
          if (supertype != null) {
            visitClassAndSupertypes(supertype.element);
          }
  
          for (var interface in element.mixins) {
            visitClassAndSupertypes(interface.element);
          }
  
          for (var interface in element.interfaces) {
            visitClassAndSupertypes(interface.element);
          }
        }
      }
  
      visitClassAndSupertypes(element);
  
      return genericSupertypes;
    }
  