Remove ILGlobals dependency on ILMetadataReader (#8041)

* First step to get rid of ilglobals

* Added ILScopeRef.PrimaryAssembly

* almost

* Fixed

* Fixing build

* Revert ilwrite changes from last commit

* some cleanup

* Trying to fix build

* Trying to fix build

* Adjusting a few cases that use QualifiedName

* Refactor a bit on normalize

* Some cleanup

* Put ctok in local function

* Minor touch up for ILScopeRef matching

* Do not need this function anymore

* Remove ILGlobals dep on getNameOfScopeRef

* Added possiblePrimaryAssemblyRefs

* Fixed build

* Hopefully this fixes the build

* Added EqualsIgnoringVersion to ILAssemblyRef

* Added RemapAssemblyRef

* Use EqualsIgnoringVersion on primaryAssemblyRef check in remap

* Cleanup

* nit style feedback changes

* Removed RemapAssemblyRef. Added stamp that ignores version.

* Fixed build

* Minor format change

* minor name refactoring

* minimizing diff

Author: TIHan

src/absil/il.fs

@@ -66,10 +66,6 @@ type PrimaryAssembly =
         | Mscorlib -> "mscorlib"
         | System_Runtime -> "System.Runtime"
         | NetStandard -> "netstandard"
-    static member IsSomePrimaryAssembly n =
-      n = PrimaryAssembly.Mscorlib.Name
-      || n = PrimaryAssembly.System_Runtime.Name
-      || n = PrimaryAssembly.NetStandard.Name
 
 // --------------------------------------------------------------------
 // Utilities: type names
@@ -373,6 +369,7 @@ let isMscorlib data =
 [<Sealed>]
 type ILAssemblyRef(data) =
     let uniqueStamp = AssemblyRefUniqueStampGenerator.Encode data
+    let uniqueIgnoringVersionStamp = AssemblyRefUniqueStampGenerator.Encode { data with assemRefVersion = None }
 
     member x.Name=data.assemRefName
 
@@ -388,6 +385,11 @@ type ILAssemblyRef(data) =
 
     member x.UniqueStamp=uniqueStamp
 
+    member x.UniqueIgnoringVersionStamp=uniqueIgnoringVersionStamp
+
+    member x.EqualsIgnoringVersion (aref: ILAssemblyRef) =
+        aref.UniqueIgnoringVersionStamp = uniqueIgnoringVersionStamp
+
     override x.GetHashCode() = uniqueStamp
 
     override x.Equals yobj = ((yobj :?> ILAssemblyRef).UniqueStamp = uniqueStamp)
@@ -490,6 +492,7 @@ type ILScopeRef =
     | Local
     | Module of ILModuleRef
     | Assembly of ILAssemblyRef
+    | PrimaryAssembly
 
     member x.IsLocalRef = match x with ILScopeRef.Local -> true | _ -> false
 
@@ -498,6 +501,7 @@ type ILScopeRef =
         | ILScopeRef.Local -> ""
         | ILScopeRef.Module mref -> "module "+mref.Name
         | ILScopeRef.Assembly aref -> aref.QualifiedName
+        | ILScopeRef.PrimaryAssembly -> ""
 
 type ILArrayBound = int32 option
 
@@ -2193,6 +2197,11 @@ and ILExportedTypesAndForwarders =
 
     member x.AsList = let (ILExportedTypesAndForwarders ltab) = x in Map.foldBack (fun _x y r -> y :: r) (ltab.Force()) []
 
+    member x.TryFindByName nm =
+        match x with
+        | ILExportedTypesAndForwarders ltab ->
+            ltab.Value.TryFind nm
+
 [<RequireQualifiedAccess>]
 type ILResourceAccess =
     | Public
@@ -2593,62 +2602,55 @@ let tname_IntPtr = "System.IntPtr"
 [<Literal>]
 let tname_UIntPtr = "System.UIntPtr"
 
+[<Literal>]
+let tname_TypedReference = "System.TypedReference"
+
 [<NoEquality; NoComparison; StructuredFormatDisplay("{DebugText}")>]
-// This data structure needs an entirely delayed implementation
-type ILGlobals(primaryScopeRef) =
-
-    let m_mkSysILTypeRef nm = mkILTyRef (primaryScopeRef, nm)
-
-    let m_typ_Object = mkILBoxedType (mkILNonGenericTySpec (m_mkSysILTypeRef tname_Object))
-    let m_typ_String = mkILBoxedType (mkILNonGenericTySpec (m_mkSysILTypeRef tname_String))
-    let m_typ_Array = mkILBoxedType (mkILNonGenericTySpec (m_mkSysILTypeRef tname_Array))
-    let m_typ_Type = mkILBoxedType (mkILNonGenericTySpec (m_mkSysILTypeRef tname_Type))
-    let m_typ_SByte = ILType.Value (mkILNonGenericTySpec (m_mkSysILTypeRef tname_SByte))
-    let m_typ_Int16 = ILType.Value (mkILNonGenericTySpec (m_mkSysILTypeRef tname_Int16))
-    let m_typ_Int32 = ILType.Value (mkILNonGenericTySpec (m_mkSysILTypeRef tname_Int32))
-    let m_typ_Int64 = ILType.Value (mkILNonGenericTySpec (m_mkSysILTypeRef tname_Int64))
-    let m_typ_Byte = ILType.Value (mkILNonGenericTySpec (m_mkSysILTypeRef tname_Byte))
-    let m_typ_UInt16 = ILType.Value (mkILNonGenericTySpec (m_mkSysILTypeRef tname_UInt16))
-    let m_typ_UInt32 = ILType.Value (mkILNonGenericTySpec (m_mkSysILTypeRef tname_UInt32))
-    let m_typ_UInt64 = ILType.Value (mkILNonGenericTySpec (m_mkSysILTypeRef tname_UInt64))
-    let m_typ_Single = ILType.Value (mkILNonGenericTySpec (m_mkSysILTypeRef tname_Single))
-    let m_typ_Double = ILType.Value (mkILNonGenericTySpec (m_mkSysILTypeRef tname_Double))
-    let m_typ_Bool = ILType.Value (mkILNonGenericTySpec (m_mkSysILTypeRef tname_Bool))
-    let m_typ_Char = ILType.Value (mkILNonGenericTySpec (m_mkSysILTypeRef tname_Char))
-    let m_typ_IntPtr = ILType.Value (mkILNonGenericTySpec (m_mkSysILTypeRef tname_IntPtr))
-    let m_typ_UIntPtr = ILType.Value (mkILNonGenericTySpec (m_mkSysILTypeRef tname_UIntPtr))
-
-    member x.primaryAssemblyScopeRef = m_typ_Object.TypeRef.Scope
-    member x.primaryAssemblyName = 
-        match m_typ_Object.TypeRef.Scope with 
-        | ILScopeRef.Assembly aref -> aref.Name 
+type ILGlobals(primaryScopeRef: ILScopeRef, assembliesThatForwardToPrimaryAssembly: ILAssemblyRef list) =
+
+    let assembliesThatForwardToPrimaryAssembly = Array.ofList assembliesThatForwardToPrimaryAssembly
+
+    let mkSysILTypeRef nm = mkILTyRef (primaryScopeRef, nm)
+
+    member _.primaryAssemblyScopeRef = primaryScopeRef
+    member x.primaryAssemblyRef = 
+        match primaryScopeRef with 
+        | ILScopeRef.Assembly aref -> aref
         | _ -> failwith "Invalid primary assembly"
-    member x.typ_Object = m_typ_Object
-    member x.typ_String = m_typ_String
-    member x.typ_Array = m_typ_Array
-    member x.typ_Type = m_typ_Type
-    member x.typ_IntPtr = m_typ_IntPtr
-    member x.typ_UIntPtr = m_typ_UIntPtr
-    member x.typ_Byte = m_typ_Byte
-    member x.typ_Int16 = m_typ_Int16
-    member x.typ_Int32 = m_typ_Int32
-    member x.typ_Int64 = m_typ_Int64
-    member x.typ_SByte = m_typ_SByte
-    member x.typ_UInt16 = m_typ_UInt16
-    member x.typ_UInt32 = m_typ_UInt32
-    member x.typ_UInt64 = m_typ_UInt64
-    member x.typ_Single = m_typ_Single
-    member x.typ_Double = m_typ_Double
-    member x.typ_Bool = m_typ_Bool
-    member x.typ_Char = m_typ_Char
+    member x.primaryAssemblyName = x.primaryAssemblyRef.Name
+
+    member val typ_Object = mkILBoxedType (mkILNonGenericTySpec (mkSysILTypeRef tname_Object))
+    member val typ_String = mkILBoxedType (mkILNonGenericTySpec (mkSysILTypeRef tname_String))
+    member val typ_Array = mkILBoxedType (mkILNonGenericTySpec (mkSysILTypeRef tname_Array))
+    member val typ_Type = mkILBoxedType (mkILNonGenericTySpec (mkSysILTypeRef tname_Type))
+    member val typ_SByte = ILType.Value (mkILNonGenericTySpec (mkSysILTypeRef tname_SByte))
+    member val typ_Int16 = ILType.Value (mkILNonGenericTySpec (mkSysILTypeRef tname_Int16))
+    member val typ_Int32 = ILType.Value (mkILNonGenericTySpec (mkSysILTypeRef tname_Int32))
+    member val typ_Int64 = ILType.Value (mkILNonGenericTySpec (mkSysILTypeRef tname_Int64))
+    member val typ_Byte = ILType.Value (mkILNonGenericTySpec (mkSysILTypeRef tname_Byte))
+    member val typ_UInt16 = ILType.Value (mkILNonGenericTySpec (mkSysILTypeRef tname_UInt16))
+    member val typ_UInt32 = ILType.Value (mkILNonGenericTySpec (mkSysILTypeRef tname_UInt32))
+    member val typ_UInt64 = ILType.Value (mkILNonGenericTySpec (mkSysILTypeRef tname_UInt64))
+    member val typ_Single = ILType.Value (mkILNonGenericTySpec (mkSysILTypeRef tname_Single))
+    member val typ_Double = ILType.Value (mkILNonGenericTySpec (mkSysILTypeRef tname_Double))
+    member val typ_Bool = ILType.Value (mkILNonGenericTySpec (mkSysILTypeRef tname_Bool))
+    member val typ_Char = ILType.Value (mkILNonGenericTySpec (mkSysILTypeRef tname_Char))
+    member val typ_IntPtr = ILType.Value (mkILNonGenericTySpec (mkSysILTypeRef tname_IntPtr))
+    member val typ_UIntPtr = ILType.Value (mkILNonGenericTySpec (mkSysILTypeRef tname_UIntPtr))
+    member val typ_TypedReference = ILType.Value (mkILNonGenericTySpec (mkSysILTypeRef tname_TypedReference))
+
+    member x.IsPossiblePrimaryAssemblyRef(aref: ILAssemblyRef) =
+        aref.EqualsIgnoringVersion x.primaryAssemblyRef ||
+        assembliesThatForwardToPrimaryAssembly
+        |> Array.exists aref.EqualsIgnoringVersion
 
     /// For debugging
     [<DebuggerBrowsable(DebuggerBrowsableState.Never)>]
     member x.DebugText = x.ToString()
 
     override x.ToString() = "<ILGlobals>"
 
-let mkILGlobals primaryScopeRef = ILGlobals primaryScopeRef
+let mkILGlobals (primaryScopeRef, assembliesThatForwardToPrimaryAssembly) = ILGlobals (primaryScopeRef, assembliesThatForwardToPrimaryAssembly)
 
 let mkNormalCall mspec = I_call (Normalcall, mspec, None)
 
@@ -2693,54 +2695,55 @@ let isILBoxedTy = function ILType.Boxed _ -> true | _ -> false
 
 let isILValueTy = function ILType.Value _ -> true | _ -> false
 
-let isPrimaryAssemblyTySpec (tspec: ILTypeSpec) n =
+let isBuiltInTySpec (ilg: ILGlobals) (tspec: ILTypeSpec) n =
     let tref = tspec.TypeRef
     let scoref = tref.Scope
-    (tref.Name = n) &&
-    match scoref with
-    | ILScopeRef.Assembly n -> PrimaryAssembly.IsSomePrimaryAssembly n.Name
-    | ILScopeRef.Module _ -> false
-    | ILScopeRef.Local -> true
+    tref.Name = n && 
+    (match scoref with
+     | ILScopeRef.Local
+     | ILScopeRef.Module _ -> false
+     | ILScopeRef.Assembly aref -> ilg.IsPossiblePrimaryAssemblyRef aref
+     | ILScopeRef.PrimaryAssembly -> true)
 
-let isILBoxedPrimaryAssemblyTy (ty: ILType) n =
-  isILBoxedTy ty && isPrimaryAssemblyTySpec ty.TypeSpec n
+let isILBoxedBuiltInTy ilg (ty: ILType) n =
+    isILBoxedTy ty && isBuiltInTySpec ilg ty.TypeSpec n
 
-let isILValuePrimaryAssemblyTy (ty: ILType) n =
-  isILValueTy ty && isPrimaryAssemblyTySpec ty.TypeSpec n
+let isILValueBuiltInTy ilg (ty: ILType) n =
+    isILValueTy ty && isBuiltInTySpec ilg ty.TypeSpec n
 
-let isILObjectTy ty = isILBoxedPrimaryAssemblyTy ty tname_Object
+let isILObjectTy ilg ty = isILBoxedBuiltInTy ilg ty tname_Object
 
-let isILStringTy ty = isILBoxedPrimaryAssemblyTy ty tname_String
+let isILStringTy ilg ty = isILBoxedBuiltInTy ilg ty tname_String
 
-let isILTypedReferenceTy ty = isILValuePrimaryAssemblyTy ty "System.TypedReference"
+let isILTypedReferenceTy ilg ty = isILValueBuiltInTy ilg ty tname_TypedReference
 
-let isILSByteTy ty = isILValuePrimaryAssemblyTy ty tname_SByte
+let isILSByteTy ilg ty = isILValueBuiltInTy ilg ty tname_SByte
 
-let isILByteTy ty = isILValuePrimaryAssemblyTy ty tname_Byte
+let isILByteTy ilg ty = isILValueBuiltInTy ilg ty tname_Byte
 
-let isILInt16Ty ty = isILValuePrimaryAssemblyTy ty tname_Int16
+let isILInt16Ty ilg ty = isILValueBuiltInTy ilg ty tname_Int16
 
-let isILUInt16Ty ty = isILValuePrimaryAssemblyTy ty tname_UInt16
+let isILUInt16Ty ilg ty = isILValueBuiltInTy ilg ty tname_UInt16
 
-let isILInt32Ty ty = isILValuePrimaryAssemblyTy ty tname_Int32
+let isILInt32Ty ilg ty = isILValueBuiltInTy ilg ty tname_Int32
 
-let isILUInt32Ty ty = isILValuePrimaryAssemblyTy ty tname_UInt32
+let isILUInt32Ty ilg ty = isILValueBuiltInTy ilg ty tname_UInt32
 
-let isILInt64Ty ty = isILValuePrimaryAssemblyTy ty tname_Int64
+let isILInt64Ty ilg ty = isILValueBuiltInTy ilg ty tname_Int64
 
-let isILUInt64Ty ty = isILValuePrimaryAssemblyTy ty tname_UInt64
+let isILUInt64Ty ilg ty = isILValueBuiltInTy ilg ty tname_UInt64
 
-let isILIntPtrTy ty = isILValuePrimaryAssemblyTy ty tname_IntPtr
+let isILIntPtrTy ilg ty = isILValueBuiltInTy ilg ty tname_IntPtr
 
-let isILUIntPtrTy ty = isILValuePrimaryAssemblyTy ty tname_UIntPtr
+let isILUIntPtrTy ilg ty = isILValueBuiltInTy ilg ty tname_UIntPtr
 
-let isILBoolTy ty = isILValuePrimaryAssemblyTy ty tname_Bool
+let isILBoolTy ilg ty = isILValueBuiltInTy ilg ty tname_Bool
 
-let isILCharTy ty = isILValuePrimaryAssemblyTy ty tname_Char
+let isILCharTy ilg ty = isILValueBuiltInTy ilg ty tname_Char
 
-let isILSingleTy ty = isILValuePrimaryAssemblyTy ty tname_Single
+let isILSingleTy ilg ty = isILValueBuiltInTy ilg ty tname_Single
 
-let isILDoubleTy ty = isILValuePrimaryAssemblyTy ty tname_Double
+let isILDoubleTy ilg ty = isILValueBuiltInTy ilg ty tname_Double
 
 // --------------------------------------------------------------------
 // Rescoping
@@ -3710,7 +3713,7 @@ let getCustomAttrData (ilg: ILGlobals) cattr =
 
 let MscorlibScopeRef = ILScopeRef.Assembly (ILAssemblyRef.Create ("mscorlib", None, Some ecmaPublicKey, true, None, None))
 
-let EcmaMscorlibILGlobals = mkILGlobals MscorlibScopeRef
+let EcmaMscorlibILGlobals = mkILGlobals (MscorlibScopeRef, [])
 
 // ILSecurityDecl is a 'blob' having the following format:
 // - A byte containing a period (.).
@@ -4006,7 +4009,8 @@ type ILReferences =
       ModuleReferences: ILModuleRef list }
 
 type ILReferencesAccumulator =
-    { refsA: HashSet<ILAssemblyRef>
+    { ilg: ILGlobals
+      refsA: HashSet<ILAssemblyRef>
       refsM: HashSet<ILModuleRef> }
 
 let emptyILRefs =
@@ -4023,6 +4027,7 @@ let refs_of_scoref s x =
     | ILScopeRef.Local -> ()
     | ILScopeRef.Assembly assemblyRef -> refs_of_assemblyRef s assemblyRef
     | ILScopeRef.Module modref -> refs_of_modref s modref
+    | ILScopeRef.PrimaryAssembly -> refs_of_assemblyRef s s.ilg.primaryAssemblyRef
 
 let refs_of_tref s (x: ILTypeRef) = refs_of_scoref s x.Scope
 
@@ -4219,9 +4224,10 @@ and refs_of_manifest s (m: ILAssemblyManifest) =
     refs_of_custom_attrs s m.CustomAttrs
     refs_of_exported_types s m.ExportedTypes
 
-let computeILRefs modul =
+let computeILRefs ilg modul =
     let s =
-      { refsA = HashSet<_>(HashIdentity.Structural)
+      { ilg = ilg
+        refsA = HashSet<_>(HashIdentity.Structural)
         refsM = HashSet<_>(HashIdentity.Structural) }
 
     refs_of_modul s modul

src/absil/il.fsi

@@ -79,6 +79,9 @@ type ILAssemblyRef =
     member Retargetable: bool
     member Version: ILVersionInfo option
     member Locale: string option
+
+    member EqualsIgnoringVersion: ILAssemblyRef -> bool
+
     interface System.IComparable
 
 [<Sealed>]
@@ -97,7 +100,9 @@ type ILScopeRef =
     /// A reference to a type in a module in the same assembly
     | Module of ILModuleRef   
     /// A reference to a type in another assembly
-    | Assembly of ILAssemblyRef  
+    | Assembly of ILAssemblyRef
+    /// A reference to a type in the primary assembly
+    | PrimaryAssembly
     member IsLocalRef: bool
     member QualifiedName: string
 
@@ -1393,7 +1398,8 @@ type ILExportedTypeOrForwarder =
 [<NoEquality; NoComparison>]
 [<Sealed>]
 type ILExportedTypesAndForwarders =
-    member AsList: ILExportedTypeOrForwarder  list
+    member AsList: ILExportedTypeOrForwarder list
+    member TryFindByName: string -> ILExportedTypeOrForwarder option
 
 [<RequireQualifiedAccess>]
 type ILResourceAccess = 
@@ -1571,6 +1577,7 @@ val isTypeNameForGlobalFunctions: string -> bool
 [<NoEquality; NoComparison; Class>]
 type ILGlobals = 
     member primaryAssemblyScopeRef: ILScopeRef
+    member primaryAssemblyRef: ILAssemblyRef
     member primaryAssemblyName: string
     member typ_Object: ILType
     member typ_String: ILType
@@ -1590,10 +1597,20 @@ type ILGlobals =
     member typ_Double: ILType
     member typ_Bool: ILType
     member typ_Char: ILType
-
+    member typ_TypedReference: ILType
+
+    /// Is the given assembly possibly a primary assembly?
+    /// In practice, a primary assembly is an assembly that contains the System.Object type definition
+    /// and has no referenced assemblies. 
+    /// However, we must consider assemblies that forward the System.Object type definition
+    /// to be possible primary assemblies.
+    /// Therefore, this will return true if the given assembly is the real primary assembly or an assembly that forwards
+    /// the System.Object type definition.
+    /// Assembly equivalency ignores the version here.
+    member IsPossiblePrimaryAssemblyRef: ILAssemblyRef -> bool
 
 /// Build the table of commonly used references given functions to find types in system assemblies
-val mkILGlobals: ILScopeRef -> ILGlobals
+val mkILGlobals: primaryScopeRef: ILScopeRef * assembliesThatForwardToPrimaryAssembly: ILAssemblyRef list -> ILGlobals
 
 val EcmaMscorlibILGlobals: ILGlobals
 
@@ -1944,23 +1961,23 @@ val instILType: ILGenericArgs -> ILType -> ILType
 val ecmaPublicKey: PublicKey
 
 /// Discriminating different important built-in types.
-val isILObjectTy: ILType -> bool
-val isILStringTy: ILType -> bool
-val isILSByteTy: ILType -> bool
-val isILByteTy: ILType -> bool
-val isILInt16Ty: ILType -> bool
-val isILUInt16Ty: ILType -> bool
-val isILInt32Ty: ILType -> bool
-val isILUInt32Ty: ILType -> bool
-val isILInt64Ty: ILType -> bool
-val isILUInt64Ty: ILType -> bool
-val isILIntPtrTy: ILType -> bool
-val isILUIntPtrTy: ILType -> bool
-val isILBoolTy: ILType -> bool
-val isILCharTy: ILType -> bool
-val isILTypedReferenceTy: ILType -> bool
-val isILDoubleTy: ILType -> bool
-val isILSingleTy: ILType -> bool
+val isILObjectTy: ILGlobals -> ILType -> bool
+val isILStringTy: ILGlobals -> ILType -> bool
+val isILSByteTy: ILGlobals -> ILType -> bool
+val isILByteTy: ILGlobals -> ILType -> bool
+val isILInt16Ty: ILGlobals -> ILType -> bool
+val isILUInt16Ty: ILGlobals -> ILType -> bool
+val isILInt32Ty: ILGlobals -> ILType -> bool
+val isILUInt32Ty: ILGlobals -> ILType -> bool
+val isILInt64Ty: ILGlobals -> ILType -> bool
+val isILUInt64Ty: ILGlobals -> ILType -> bool
+val isILIntPtrTy: ILGlobals -> ILType -> bool
+val isILUIntPtrTy: ILGlobals -> ILType -> bool
+val isILBoolTy: ILGlobals -> ILType -> bool
+val isILCharTy: ILGlobals -> ILType -> bool
+val isILTypedReferenceTy: ILGlobals -> ILType -> bool
+val isILDoubleTy: ILGlobals -> ILType -> bool
+val isILSingleTy: ILGlobals -> ILType -> bool
 
 val sha1HashInt64 : byte[] -> int64
 /// Get a public key token from a public key.
@@ -2002,6 +2019,6 @@ type ILReferences =
       ModuleReferences: ILModuleRef list }
 
 /// Find the full set of assemblies referenced by a module.
-val computeILRefs: ILModuleDef -> ILReferences
+val computeILRefs: ILGlobals -> ILModuleDef -> ILReferences
 val emptyILRefs: ILReferences