anchor.diff:      return false;
     }
   
  -  @override
  -  bool isOverrideSubtypeOf(FunctionType f1, FunctionType f2) {
  -    return FunctionTypeImpl.relate(f1, f2, isSubtypeOf,
  -        parameterRelation: isOverrideSubtypeOfParameter,
  -        // Type parameter bounds are invariant.
  -        boundsRelation: (t1, t2, p1, p2) =>
  -            isSubtypeOf(t1, t2) && isSubtypeOf(t2, t1));
  -  }
  -
  -  /// Check that parameter [p2] is a subtype of [p1], given that we are
  -  /// checking `f1 <: f2` where `p1` is a parameter of `f1` and `p2` is a
  -  /// parameter of `f2`.
  -  ///
  -  /// Parameters are contravariant, so we must check `p2 <: p1` to
  -  /// determine if `f1 <: f2`. This is used by [isOverrideSubtypeOf].
  -  bool isOverrideSubtypeOfParameter(ParameterElement p1, ParameterElement p2) {
  -    return isSubtypeOf(p2.type, p1.type) ||
  -        p1.isCovariant && isSubtypeOf(p1.type, p2.type);
  -  }
  -
     /// Check if [_T0] is a subtype of [_T1].
     ///
     /// Implements:
  
positive.code:     return false;
    }
  
    /// Check that [f1] is a subtype of [f2] for a member override.
    ///
    /// This is different from the normal function subtyping in two ways:
    /// - we know the function types are strict arrows,
    /// - it allows opt-in covariant parameters.
    bool isOverrideSubtypeOf(FunctionType f1, FunctionType f2);
  
    @override
    bool isPotentiallyNonNullable(DartType type) => !isNullable(type);
  
  
negative.code:     }
      return super
          .refineBinaryExpressionType(leftType, operator, rightType, currentType);
    }
  
    /// Return `true` if runtime types [T1] and [T2] are equal.
    ///
    /// nnbd/feature-specification.md#runtime-type-equality-operator
    bool runtimeTypesEqual(DartType T1, DartType T2) {
      return RuntimeTypeEqualityHelper(this).equal(T1, T2);
    }
  
    DartType toLegacyType(DartType type) {
  