anchor.diff:            isGenericCovariantImpl = true;
           }
         }
  -      if (isGenericCovariantImpl != superTypeParameter.isGenericCovariantImpl) {
  -        createImplIfNeeded();
  -      }
  -      if (isGenericCovariantImpl != typeParameter.isGenericCovariantImpl) {
  -        fixes.add((FunctionNode function) => function
  -            .typeParameters[i].isGenericCovariantImpl = isGenericCovariantImpl);
  -      }
  -    }
  -
  -    if (debugCovariance && fixes.isNotEmpty) {
  -      print('  ${fixes.length} fix(es)');
  -    }
  +      if (isGenericCovariantImpl) {
  +        if (!superTypeParameter.isGenericCovariantImpl) {
  +          createImplIfNeeded();
  +        }
  +        if (!typeParameter.isGenericCovariantImpl) {
  +          createStubIfNeeded();
  +          stub.function.typeParameters[i].isGenericCovariantImpl = true;
  +        }
  +      }
  +    }
  +    return stub;
     }
   
     void _createForwardingImplIfNeeded(FunctionNode function) {
  
positive.code:   /// Does not create forwarding stubs.
    Procedure resolve() => _resolution ??= _resolve();
  
    /// Determines which covariance fixes need to be applied to the given
    /// [interfaceMember].
    ///
    /// [substitution] indicates the necessary substitutions to convert types
    /// named in [interfaceMember] to types in the target class.
    ///
    /// The fixes are not applied immediately (since [interfaceMember] might be
    /// a member of another class, and a forwarding stub may need to be
    /// generated).
    void _computeCovarianceFixes(Substitution substitution,
        Procedure interfaceMember, List<_CovarianceFix> fixes) {
      if (debugCovariance) {
        print('Considering covariance fixes for '
            '${_printProcedure(interfaceMember, enclosingClass)}');
        for (int i = _start; i < _end; i++) {
          print('  Candidate: ${_printProcedure(_candidates[i])}');
        }
      }
      var class_ = enclosingClass;
      var interfaceFunction = interfaceMember.function;
      var interfacePositionalParameters = interfaceFunction.positionalParameters;
      var interfaceNamedParameters = interfaceFunction.namedParameters;
      var interfaceTypeParameters = interfaceFunction.typeParameters;
      bool isImplCreated = false;
      void createImplIfNeeded() {
        if (isImplCreated) return;
        fixes.add(_createForwardingImplIfNeeded);
        isImplCreated = true;
      }
  
      IncludesTypeParametersCovariantly needsCheckVisitor =
          class_.typeParameters.isEmpty
              ? null
              : ShadowClass.getClassInferenceInfo(class_).needsCheckVisitor ??=
                  new IncludesTypeParametersCovariantly(class_.typeParameters);
      bool needsCheck(DartType type) => needsCheckVisitor == null
          ? false
          : substitution.substituteType(type).accept(needsCheckVisitor);
  
negative.code:           isCovariant = true;
          }
        }
        if (isGenericCovariantImpl) {
          if (!superParameter.isGenericCovariantImpl) {
            createImplIfNeeded();
          }
          if (!parameter.isGenericCovariantImpl) {
            createStubIfNeeded();
            stub.function.namedParameters[i].isGenericCovariantImpl = true;
          }
        }
        if (isCovariant) {
          if (!superParameter.isCovariant) {
            createImplIfNeeded();
          }
          if (!parameter.isCovariant) {
            createStubIfNeeded();
            stub.function.namedParameters[i].isCovariant = true;
          }
        }
      }
      for (int i = 0; i < interfaceTypeParameters.length; i++) {
  