anchor.diff:        type.onType.accept(this);
   
     @override
  -  js_ast.Expression visitFutureOrType(FutureOrType type) =>
  -      _normalizeFutureOr(type);
  +  js_ast.Expression visitFutureOrType(FutureOrType type) {
  +    var normalizedType = _normalizeFutureOr(type);
  +    return normalizedType is FutureOrType
  +        ? _emitFutureOrType(normalizedType)
  +        : normalizedType.accept(this);
  +  }
   
     /// Emits the representation of [type].
     ///
  
positive.code:           : legacy
                ? Nullability.legacy
                : Nullability.nonNullable;
        return _emitInterfaceType(
            typeArgument.withDeclaredNullability(nullability));
      } else if (typeArgument is NeverType) {
        // FutureOr<Never> --> Future<Never>
        return _emitInterfaceType(InterfaceType(
            _coreTypes.futureClass, futureOr.nullability, [typeArgument]));
      } else if (typeArgument is NullType) {
        // FutureOr<Null> --> Future<Null>?
        return _emitInterfaceType(InterfaceType(
            _coreTypes.futureClass, Nullability.nullable, [typeArgument]));
      } else if (futureOr.declaredNullability == Nullability.nullable &&
          typeArgument.nullability == Nullability.nullable) {
        // FutureOr<T?>? --> FutureOr<T?>
        return _emitFutureOrType(
            futureOr.withDeclaredNullability(Nullability.nonNullable));
      }
      return _emitFutureOrType(futureOr);
    }
  
    @override
  
negative.code:           ? visitNullType(const NullType())
            : _emitNullabilityWrapper(runtimeCall('Never'), type.nullability);
  
    /// Normalizes `FutureOr` types.
    ///
    /// Any changes to the normalization logic here should be mirrored in the
    /// classes.dart runtime library method named `normalizeFutureOr`.
    DartType _normalizeFutureOr(FutureOrType futureOr) {
      var typeArgument = futureOr.typeArgument;
      if (typeArgument is DynamicType) {
        // FutureOr<dynamic> --> dynamic
        return typeArgument;
      }
      if (typeArgument is VoidType) {
        // FutureOr<void> --> void
        return typeArgument;
      }
  
      if (typeArgument is InterfaceType &&
  