anchor.diff:        // given t1 is Future<A> | A, then:
         // (Future<A> | A) <: t2 iff Future<A> <: t2 and A <: t2.
         var subtypeFuture = futureType(subtypeArg);
  -      return performNullabilityAwareSubtypeCheck(subtypeFuture, supertype) ==
  -                  IsSubtypeOf.always &&
  -              performNullabilityAwareSubtypeCheck(subtypeArg, supertype) ==
  -                  IsSubtypeOf.always
  -          ? IsSubtypeOf.always
  -          : IsSubtypeOf.never;
  +      return performNullabilityAwareSubtypeCheck(subtypeFuture, supertype)
  +                  .isSubtypeWhenIgnoringNullabilities() &&
  +              performNullabilityAwareSubtypeCheck(subtypeArg, supertype)
  +                  .isSubtypeWhenIgnoringNullabilities()
  +          ? const IsSubtypeOf.always()
  +          : const IsSubtypeOf.never();
       }
   
       if (supertype is InterfaceType &&
  
positive.code:         ++subtypeNameIndex;
        }
        if (subtypeNameIndex == subtype.namedParameters.length) {
          return IsSubtypeOf.never;
        }
        NamedType subtypeParameter = subtype.namedParameters[subtypeNameIndex];
        // Termination: Both types shrink in size.
        if (!isSubtypeOf(supertypeParameter.type, subtypeParameter.type)) {
          return IsSubtypeOf.never;
        }
      }
      return IsSubtypeOf.always;
    }
  }
  
negative.code:         // recursive call can only occur a finite number of times before
          // reaching a shrinking recursive call (or terminating).
          // TODO(dmitryas): Replace it with one recursive descent instead of two.
          if (!performNullabilityAwareSubtypeCheck(superParameter.bound, subBound)
                  .isSubtypeWhenIgnoringNullabilities() ||
              !performNullabilityAwareSubtypeCheck(subBound, superParameter.bound)
                  .isSubtypeWhenIgnoringNullabilities()) {
            return const IsSubtypeOf.never();
          }
        }
        subtype = substitute(subtype.withoutTypeParameters, substitution);
      }
      if (!performNullabilityAwareSubtypeCheck(
              subtype.returnType, supertype.returnType)
          .isSubtypeWhenIgnoringNullabilities()) {
        return const IsSubtypeOf.never();
      }
      for (int i = 0; i < supertype.positionalParameters.length; ++i) {
        var supertypeParameter = supertype.positionalParameters[i];
        var subtypeParameter = subtype.positionalParameters[i];
        // Termination: Both types shrink in size.
        if (!performNullabilityAwareSubtypeCheck(
                supertypeParameter, subtypeParameter)
            .isSubtypeWhenIgnoringNullabilities()) {
          return const IsSubtypeOf.never();
        }
      }
      int subtypeNameIndex = 0;
  