anchor.diff:    /// [candidates] a list containing the procedures overridden by [procedure],
     /// if any.  [start] is the index of the first such procedure, and [end] is
     /// the past-the-end index of the last such procedure.
  -  InferenceNode _createInferenceNode(Class class_, Procedure procedure,
  -      List<Member> candidates, int start, int end) {
  +  ///
  +  /// For getters and setters, [crossStart] and [crossEnd] are the start and end
  +  /// indices of the corresponding overridden setters/getters, respectively.
  +  InferenceNode _createInferenceNode(
  +      Class class_,
  +      Procedure procedure,
  +      List<Member> candidates,
  +      int start,
  +      int end,
  +      int crossStart,
  +      int crossEnd) {
       if (!_requiresTypeInference(procedure)) return null;
       switch (procedure.kind) {
         case ProcedureKind.Getter:
  
positive.code:         //     non-optional parameter), the inference result is not defined and
          //     tools are free to either emit an error, or to defer the error to
          //     override checking.
          positionalParameters[i].type = matchTypes(
              overriddenTypes.map((type) => getPositionalParameterType(type, i)));
        }
      }
      var namedParameters = _declaredMethod.function.namedParameters;
      for (int i = 0; i < namedParameters.length; i++) {
        if (ShadowVariableDeclaration.isImplicitlyTyped(namedParameters[i])) {
          var name = namedParameters[i].name;
          namedParameters[i].type = matchTypes(
              overriddenTypes.map((type) => getNamedParameterType(type, name)));
        }
      }
  
negative.code: /// need to be added before creating a forwarding stub, but the covariance
  /// annotations themselves need to be applied to the forwarding stub.
  typedef void _CovarianceFix(FunctionNode function);
  
  /// Concrete class derived from [InferenceNode] to represent type inference of
  /// getters, setters, and fields based on inheritance.
  class AccessorInferenceNode extends MemberInferenceNode {
    AccessorInferenceNode(InterfaceResolver interfaceResolver,
        Procedure declaredMethod, List<Member> candidates, int start, int end)
        : super(interfaceResolver, declaredMethod, candidates, start, end);
  
    @override
    void resolveInternal() {
      var declaredMethod = _declaredMethod;
      var kind = declaredMethod.kind;
      var overriddenTypes = _computeAccessorOverriddenTypes();
      if (!isCircular) {
        var inferredType = _matchTypes(overriddenTypes);
        if (declaredMethod is SyntheticAccessor) {
          declaredMethod._field.type = inferredType;
        } else {
          if (kind == ProcedureKind.Getter) {
            declaredMethod.function.returnType = inferredType;
          } else {
            declaredMethod.function.positionalParameters[0].type = inferredType;
          }
        }
      }
    }
  
    /// Computes the types of the getters and setters overridden by
    /// [_declaredMethod], with appropriate type parameter substitutions.
    List<DartType> _computeAccessorOverriddenTypes() {
      var overriddenTypes = <DartType>[];
      for (int i = _start; i < _end; i++) {
        var candidate = _candidates[i];
        Member resolvedCandidate;
        if (candidate is ForwardingNode) {
          _candidates[i] = resolvedCandidate = candidate.resolve();
        } else {
          resolvedCandidate = candidate;
        }
        DartType overriddenType;
        if (resolvedCandidate is SyntheticAccessor) {
          var field = resolvedCandidate._field;
          if (field is ShadowField) {
            ShadowMember.getInferenceNode(field)?.resolve();
          }
          overriddenType = field.type;
        } else if (resolvedCandidate.function != null &&
            resolvedCandidate is Procedure) {
          switch (resolvedCandidate.kind) {
            case ProcedureKind.Getter:
              overriddenType = resolvedCandidate.function.returnType;
              break;
            case ProcedureKind.Setter:
              overriddenType =
                  resolvedCandidate.function.positionalParameters[0].type;
              break;
            default:
              // Illegal override (error will be reported elsewhere).  Just skip
              // this override.
              continue;
          }
        } else {
          // This can happen if there are errors.  Just skip this override.
          continue;
        }
        overriddenTypes.add(_interfaceResolver
            ._substitutionFor(resolvedCandidate, _declaredMethod.enclosingClass)
            .substituteType(overriddenType));
      }
      return overriddenTypes;
    }
  }
  
  /// A [ForwardingNode] represents a method, getter, or setter within a class's
  /// interface that is either implemented in the class directly or inherited from
  