Chore :: Remove #IF NULLABLE, MaybeNull and other leftovers from bootstrap times of Nullable feature (#19235)

* Create TASKLIST.md

* Remove BUILDING_WITH_LKG conditionals from FSharp.Core

Remove all #if BUILDING_WITH_LKG || BUILD_FROM_SOURCE conditionals from
prim-types.fsi (7 blocks), prim-types.fs (2 blocks), event.fsi (2 blocks),
and event.fs (2 blocks).

For each block, kept the #else branch which includes:
- IsError=true in CompilerMessage attributes (prim-types.fsi)
- 'not null' type constraints on delegate types (all files)

These conditionals were only needed during F# 9 development when the
shipped .NET SDK didn't yet understand NRT. Now that NRT is stable,
this code can be unconditionally included.

* Replace MaybeNull usages with 'T | null in Compiler/Utilities

- Update NullnessShims.fs: nullSafeEquality and NonEmptyString now use 'T | null
- Update lib.fs/fsi: dispose and DisposablesTracker.Register use 'T | null
- Update illib.fs: reportTime and DelayInitArrayMap use nullable types
- Update FileSystem.fs: isInvalidPath/Filename/Directory use pattern matching
- Update Activity.fs: escapeStringForCsv and appendWithLeadingComma use nullable
- Update Cancellable.fs: Using member uses _ | null
- Update LruCache.fs: removeCollected uses nullable LinkedListNode
- Minor formatting fix in event.fs (fantomas)

Note: Cancellable.fsi retains MaybeNull in signature for backwards compatibility
with consuming code (changing it causes FS3261 nullness errors downstream).
The MaybeNull type alias is kept in NullnessShims.fs for this purpose.

* Replace MaybeNull usages with 'T | null in FSharp.Build

Replace all MaybeNull<'T> usages with the canonical 'T | null syntax in
FSharp.Build implementation files:
- Fsc.fs: 33 replacements
- Fsi.fs: 11 replacements
- FSharpCommandLineBuilder.fs: 2 method signature replacements
- WriteCodeFragment.fs: 2 replacements

The MaybeNull type definition is retained for backward compatibility.
Type annotations added to match expressions returning null to ensure
proper type inference with nullable types.

* Remove unused (^) operator and cleanup MaybeNull type alias

- Remove unused MaybeNull type alias definition from FSharpCommandLineBuilder.fs
- Remove unused (^) null-propagation operator from NullnessShims.fs
- Inline (^) usage in fsi.fs with direct null check pattern
- All FSharp.Build files now use 'T | null syntax directly

* Cleanup NULLABLE guarded leftovers

* Delete TASKLIST.md

Author: T-Gro

src/Compiler/AbstractIL/ilnativeres.fs

@@ -27,7 +27,7 @@ type WORD = uint16
 
 let inline WORD s = uint16 s
 
-type ResourceException(name: string, ?inner: Exception MaybeNull) =
+type ResourceException(name: string, ?inner: (Exception | null)) =
     inherit Exception(name, Option.toObj inner)
 
 type RESOURCE_STRING() =

src/Compiler/AbstractIL/ilread.fs

@@ -226,7 +226,7 @@ type WeakByteFile(fileName: string, chunk: (int * int) option) =
     let fileStamp = FileSystem.GetLastWriteTimeShim fileName
 
     /// The weak handle to the bytes for the file
-    let weakBytes = WeakReference<byte[] MaybeNull>(null)
+    let weakBytes = WeakReference<byte[] | null>(null)
 
     member _.FileName = fileName
 

src/Compiler/AbstractIL/ilreflect.fs

@@ -550,7 +550,7 @@ let emEnv0 =
         delayedFieldInits = []
     }
 
-let envBindTypeRef emEnv (tref: ILTypeRef) (typT: Type MaybeNull, typB, typeDef) =
+let envBindTypeRef emEnv (tref: ILTypeRef) (typT: Type | null, typB, typeDef) =
     match typT with
     | Null -> failwithf "binding null type in envBindTypeRef: %s\n" tref.Name
     | NonNull typT ->
@@ -697,7 +697,7 @@ let rec convTypeSpec cenv emEnv preferCreated (tspec: ILTypeSpec) =
     let typT = convTypeRef cenv emEnv preferCreated tspec.TypeRef
     let tyargs = List.map (convTypeAux cenv emEnv preferCreated) tspec.GenericArgs
 
-    let res: Type MaybeNull =
+    let res: Type | null =
         match isNil tyargs, typT.IsGenericType with
         | _, true -> typT.MakeGenericType(List.toArray tyargs)
         | true, false -> typT
@@ -1013,7 +1013,7 @@ let queryableTypeGetMethod cenv emEnv parentT (mref: ILMethodRef) : MethodInfo =
     else
         queryableTypeGetMethodBySearch cenv emEnv parentT mref
 
-let nonQueryableTypeGetMethod (parentTI: Type) (methInfo: MethodInfo) : MethodInfo MaybeNull =
+let nonQueryableTypeGetMethod (parentTI: Type) (methInfo: MethodInfo) : MethodInfo | null =
     if
         (parentTI.IsGenericType
          && not (equalTypes parentTI (getTypeConstructor parentTI)))
@@ -1102,7 +1102,7 @@ let queryableTypeGetConstructor cenv emEnv (parentT: Type) (mref: ILMethodRef) =
         )
     | NonNull res -> res
 
-let nonQueryableTypeGetConstructor (parentTI: Type) (consInfo: ConstructorInfo) : ConstructorInfo MaybeNull =
+let nonQueryableTypeGetConstructor (parentTI: Type) (consInfo: ConstructorInfo) : ConstructorInfo | null =
     if parentTI.IsGenericType then
         TypeBuilder.GetConstructor(parentTI, consInfo)
     else

src/Compiler/AbstractIL/ilsign.fs

@@ -171,7 +171,7 @@ let RSAParametersFromBlob blob keyType =
     key.D <- reader.ReadBigInteger byteLen
     key
 
-let validateRSAField (field: byte array MaybeNull) expected (name: string) =
+let validateRSAField (field: byte array | null) expected (name: string) =
     match field with
     | Null -> ()
     | NonNull field ->
@@ -237,7 +237,7 @@ let toCLRKeyBlob (rsaParameters: RSAParameters) (algId: int) : byte array =
 
             buffer
 
-        let safeArrayRev (buffer: _ MaybeNull) =
+        let safeArrayRev (buffer: _ | null) =
             match buffer with
             | Null -> Array.empty<byte>
             | NonNull buffer -> buffer |> Array.rev

src/Compiler/Checking/AccessibilityLogic.fs

@@ -374,7 +374,7 @@ let IsPropInfoAccessible g amap m ad = function
     | ProvidedProp (amap, tppi, m) as pp-> 
         let access = 
             let a = tppi.PUntaint((fun ppi -> 
-                let tryGetILAccessForProvidedMethodBase (mi : ProvidedMethodInfo MaybeNull) =
+                let tryGetILAccessForProvidedMethodBase (mi : (ProvidedMethodInfo | null)) =
                     match mi with
                     | Null -> None
                     | NonNull mi -> 

src/Compiler/Checking/MethodCalls.fs

@@ -1871,7 +1871,7 @@ module ProvidedMethodCalls =
              allArgs: Exprs,
              paramVars: Tainted<ProvidedVar>[],
              g, amap, mut, isProp, isSuperInit, m,
-             expr: Tainted<ProvidedExpr MaybeNull>) = 
+             expr: Tainted<(ProvidedExpr | null)>) = 
 
         let varConv =
             // note: Assuming the size based on paramVars
@@ -1881,8 +1881,8 @@ module ProvidedMethodCalls =
                 dict.Add(v, (None, e))
             dict
 
-        let rec exprToExprAndWitness top (ea: Tainted<ProvidedExpr MaybeNull>) =
-            let fail() = error(Error(FSComp.SR.etUnsupportedProvidedExpression(ea.PUntaint((fun etree -> etree.UnderlyingExpressionString), m)), m))
+        let rec exprToExprAndWitness top (ea: Tainted<(ProvidedExpr | null)>) =
+            let fail() = error(Error(FSComp.SR.etUnsupportedProvidedExpression(ea.PUntaint((fun etree -> match etree with null -> "<null>" | e -> e.UnderlyingExpressionString), m)), m))
             match ea with
             | Tainted.Null -> error(Error(FSComp.SR.etNullProvidedExpression(ea.TypeProviderDesignation), m))
             | Tainted.NonNull ea ->

src/Compiler/Checking/import.fs

@@ -38,7 +38,7 @@ type AssemblyLoader =
     /// Get a flag indicating if an assembly is a provided assembly, plus the
     /// table of information recording remappings from type names in the provided assembly to type
     /// names in the statically linked, embedded assembly.
-    abstract GetProvidedAssemblyInfo : CompilationThreadToken * range * Tainted<ProvidedAssembly MaybeNull> -> bool * ProvidedAssemblyStaticLinkingMap option
+    abstract GetProvidedAssemblyInfo : CompilationThreadToken * range * Tainted<(ProvidedAssembly | null)> -> bool * ProvidedAssemblyStaticLinkingMap option
 
     /// Record a root for a [<Generate>] type to help guide static linking & type relocation
     abstract RecordGeneratedTypeRoot : ProviderGeneratedType -> unit

src/Compiler/Checking/import.fsi

@@ -28,7 +28,7 @@ type AssemblyLoader =
     /// table of information recording remappings from type names in the provided assembly to type
     /// names in the statically linked, embedded assembly.
     abstract GetProvidedAssemblyInfo:
-        CompilationThreadToken * range * Tainted<ProvidedAssembly MaybeNull> ->
+        CompilationThreadToken * range * Tainted<(ProvidedAssembly | null)> ->
             bool * ProvidedAssemblyStaticLinkingMap option
 
     /// Record a root for a [<Generate>] type to help guide static linking & type relocation

src/Compiler/Checking/infos.fs

@@ -341,7 +341,7 @@ let CrackParamAttribsInfo g (ty: TType, argInfo: ArgReprInfo) =
 type ILFieldInit with
 
     /// Compute the ILFieldInit for the given provided constant value for a provided enum type.
-    static member FromProvidedObj m (v: obj MaybeNull) =
+    static member FromProvidedObj m (v: obj | null) =
         match v with
         | Null -> ILFieldInit.Null
         | NonNull v ->
@@ -393,8 +393,8 @@ let OptionalArgInfoOfProvidedParameter (amap: ImportMap) m (provParam : Tainted<
         NotOptional
 
 /// Compute the ILFieldInit for the given provided constant value for a provided enum type.
-let GetAndSanityCheckProviderMethod m (mi: Tainted<'T :> ProvidedMemberInfo>) (get : 'T -> ProvidedMethodInfo MaybeNull) err = 
-    match mi.PApply((fun mi -> (get mi :> ProvidedMethodBase MaybeNull)),m) with 
+let GetAndSanityCheckProviderMethod m (mi: Tainted<'T :> ProvidedMemberInfo>) (get : 'T -> (ProvidedMethodInfo | null)) err = 
+    match mi.PApply((fun mi -> (get mi :> (ProvidedMethodBase | null))),m) with 
     | Tainted.Null -> error(Error(err(mi.PUntaint((fun mi -> mi.Name),m),mi.PUntaint((fun mi -> (nonNull mi.DeclaringType).Name), m)), m))
     | Tainted.NonNull meth -> meth
 

src/Compiler/CodeGen/IlxGen.fs

@@ -12194,7 +12194,7 @@ let LookupGeneratedValue (cenv: cenv) (ctxt: ExecutionContext) eenv (v: Val) =
                 if hasLiteralAttr then
                     let staticTy = ctxt.LookupTypeRef fspec.DeclaringTypeRef
                     // Checked: This FieldInfo (FieldBuilder) supports GetValue().
-                    (!!staticTy.GetField(fspec.Name)).GetValue(null: obj MaybeNull)
+                    (!!staticTy.GetField(fspec.Name)).GetValue(null: obj | null)
                 else
                     let staticTy = ctxt.LookupTypeRef ilContainerTy.TypeRef
                     // We can't call .Invoke on the ILMethodRef's MethodInfo,