anchor.diff:      // Find all generic interfaces that could be used to call into members of
       // this class. This will help us identify which parameters need checks
       // for soundness.
  -    var allCovariant = _findAllGenericInterfaces(element.type);
  +    var allCovariant = _findAllGenericInterfaces(element);
       if (allCovariant.isEmpty) return;
   
       var seenConcreteMembers = new HashSet<String>();
  -    var members = _getConcreteMembers(element.type, seenConcreteMembers);
  +    var members = _getConcreteMembers(element.thisType, seenConcreteMembers);
   
       // For members on this class, check them against all generic interfaces.
       var checks = _findCovariantChecks(members, allCovariant);
  
positive.code:     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 newCovariant = allCovariant.difference(oldCovariant);
        if (newCovariant.isEmpty) 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;
    }
  