anchor.diff:        helperCall = 'fnType(#)';
       }
       var typeRep = runtimeCall(helperCall, [typeParts]);
  -    // Avoid caching the nullability of the function type itself so it can be
  -    // shared by nullable, non-nullable, and legacy versions at the use site.
  +    // First add the type to the type table in its non-nullable form. It can be
  +    // reused by the nullable and legacy versions.
       typeRep = _cacheTypes
  +        ? _typeTable.nameFunctionType(
  +            type.withNullability(Nullability.nonNullable), typeRep,
  +            lazy: lazy)
  +        : typeRep;
  +
  +    if (type.nullability == Nullability.nonNullable) return typeRep;
  +
  +    // Hoist the nullable or legacy versions of the type to the top level and
  +    // use it everywhere it appears.
  +    typeRep = _emitNullabilityWrapper(typeRep, type.nullability);
  +    return _cacheTypes
           ? _typeTable.nameFunctionType(type, typeRep, lazy: lazy)
           : typeRep;
  -
  -    return _emitNullabilityWrapper(typeRep, type.nullability);
     }
   
     /// Emits an expression that lets you access statics on a [type] from code.
  
positive.code:       throw UnsupportedError('Undetermined Nullability');
      }
  
      return _emitNullabilityWrapper(typeRep, type.nullability);
    }
  
    /// Wraps [typeRep] in the appropriate wrapper for the given [nullability].
  
negative.code:   js_ast.Expression _emitTypeParameterType(TypeParameterType type,
        {bool emitNullability = true}) {
      var typeParam = _emitTypeParameter(type.parameter);
      if (!emitNullability ||
          !_cacheTypes ||
          // Emit non-nullable version directly.
          type.isPotentiallyNonNullable) {
        return typeParam;
      }
  
      // Hoist the wrapped version to the top level and use it everywhere this
      // type appears.
      return _typeTable.nameType(
          type, _emitNullabilityWrapper(typeParam, type.nullability));
    }
  
    js_ast.Identifier _emitTypeParameter(TypeParameter t) =>
  