anchor.diff:            : legacy
                 ? Nullability.legacy
                 : Nullability.nonNullable;
  -      return _emitInterfaceType(
  -          typeArgument.withDeclaredNullability(nullability));
  +      return typeArgument.withDeclaredNullability(nullability);
       } else if (typeArgument is NeverType) {
         // FutureOr<Never> --> Future<Never>
  -      return _emitInterfaceType(InterfaceType(
  -          _coreTypes.futureClass, futureOr.nullability, [typeArgument]));
  +      return InterfaceType(
  +          _coreTypes.futureClass, futureOr.nullability, [typeArgument]);
       } else if (typeArgument is NullType) {
         // FutureOr<Null> --> Future<Null>?
  -      return _emitInterfaceType(InterfaceType(
  -          _coreTypes.futureClass, Nullability.nullable, [typeArgument]));
  +      return 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);
  +      return futureOr.withDeclaredNullability(Nullability.nonNullable);
  +    }
  +    return futureOr;
     }
   
     @override
  
positive.code:       type.onType.accept(this);
  
    @override
    js_ast.Expression visitFutureOrType(FutureOrType type) =>
        _normalizeFutureOr(type);
  
    /// Emits the representation of [type].
    ///
  
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 &&
  