anchor.diff:    /// 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;
  +  /// Tag the parameters of [interfaceMember] that need type checks
  +  ///
  +  /// Parameters can need type checks for calls coming from statically typed
  +  /// call sites, due to covariant generics and overrides with explicit
  +  /// `covariant` parameters.
  +  ///
  +  /// Tag parameters of [interfaceMember] that need such checks when the member
  +  /// occurs in [enclosingClass]'s interface.  If parameters need checks but
  +  /// they would not be checked in an inherited implementation, a forwarding
  +  /// stub is introduced as a place to put the checks.
  +  Procedure _computeCovarianceFixes(Procedure interfaceMember) {
  +    assert(_interfaceResolver.strongMode);
  +    var substitution =
  +        _interfaceResolver._substitutionFor(interfaceMember, enclosingClass);
  +    // We always create a forwarding stub when we've inherited a member from an
  +    // interface other than the first override candidate.  This is to work
  +    // around a bug in the Kernel type checker where it chooses the first
  +    // override candidate.
  +    //
  +    // TODO(kmillikin): Fix the Kernel type checker and stop creating these
  +    // extra stubs.
  +    var stub = interfaceMember.enclosingClass == enclosingClass ||
  +            interfaceMember == _resolvedCandidate(_start)
  +        ? interfaceMember
  +        : _createForwardingStub(substitution, interfaceMember);
  +
       var interfaceFunction = interfaceMember.function;
       var interfacePositionalParameters = interfaceFunction.positionalParameters;
       var interfaceNamedParameters = interfaceFunction.namedParameters;
       var interfaceTypeParameters = interfaceFunction.typeParameters;
  +
  +    void createStubIfNeeded() {
  +      if (stub != interfaceMember) return;
  +      if (interfaceMember.enclosingClass == enclosingClass) return;
  +      stub = _createForwardingStub(substitution, interfaceMember);
  +    }
  +
       bool isImplCreated = false;
       void createImplIfNeeded() {
         if (isImplCreated) return;
  -      fixes.add(_createForwardingImplIfNeeded);
  +      createStubIfNeeded();
  +      _createForwardingImplIfNeeded(stub.function);
         isImplCreated = true;
       }
   
       IncludesTypeParametersCovariantly needsCheckVisitor =
  -        class_.typeParameters.isEmpty
  +        enclosingClass.typeParameters.isEmpty
               ? null
  -            : ShadowClass.getClassInferenceInfo(class_).needsCheckVisitor ??=
  -                new IncludesTypeParametersCovariantly(class_.typeParameters);
  +            : ShadowClass
  +                    .getClassInferenceInfo(enclosingClass)
  +                    .needsCheckVisitor ??=
  +                new IncludesTypeParametersCovariantly(
  +                    enclosingClass.typeParameters);
       bool needsCheck(DartType type) => needsCheckVisitor == null
           ? false
           : substitution.substituteType(type).accept(needsCheckVisitor);
  
positive.code:             _interfaceResolver.isTypeInferencePrepared
          ? candidate.finalize()
          : candidate;
    }
  
    /// Returns a string describing the signature of [procedure], along with the
    /// class it's in.
    ///
    /// Only used if [debugCovariance] is `true`.
    ///
    /// If [class_] is provided, it is used instead of [procedure]'s enclosing
    /// class.
    String _printProcedure(Procedure procedure, [Class class_]) {
      class_ ??= procedure.enclosingClass;
      var buffer = new StringBuffer();
      if (procedure.function == null) {
        buffer.write(procedure.toString());
      } else {
        procedure.accept(new Printer(buffer));
      }
      var text = buffer.toString();
      var newlineIndex = text.indexOf('\n');
      if (newlineIndex != -1) {
        text = text.substring(0, newlineIndex);
      }
      return '$class_: $text';
    }
  
    /// Determines which inherited member this node resolves to, and also performs
  
negative.code:           isCovariant = true;
          }
        }
        if (isGenericCovariantImpl) {
          if (!superParameter.isGenericCovariantImpl) {
            createImplIfNeeded();
          }
          if (!parameter.isGenericCovariantImpl) {
            createStubIfNeeded();
            stub.function.positionalParameters[i].isGenericCovariantImpl = true;
          }
        }
        if (isCovariant) {
          if (!superParameter.isCovariant) {
            createImplIfNeeded();
          }
          if (!parameter.isCovariant) {
            createStubIfNeeded();
            stub.function.positionalParameters[i].isCovariant = true;
          }
        }
      }
      for (int i = 0; i < interfaceNamedParameters.length; i++) {
  