Remove nullability annotation from MetadataLoadContext.CoreAssembly.

src/libraries/System.Reflection.MetadataLoadContext/ref/System.Reflection.MetadataLoadContext.cs

@@ -14,7 +14,7 @@ protected MetadataAssemblyResolver() { }
     public sealed partial class MetadataLoadContext : System.IDisposable
     {
         public MetadataLoadContext(System.Reflection.MetadataAssemblyResolver resolver, string? coreAssemblyName = null) { }
-        public System.Reflection.Assembly? CoreAssembly { get { throw null; } }
+        public System.Reflection.Assembly CoreAssembly { get { throw null; } }
         public void Dispose() { }
         public System.Collections.Generic.IEnumerable<System.Reflection.Assembly> GetAssemblies() { throw null; }
         public System.Reflection.Assembly LoadFromAssemblyName(System.Reflection.AssemblyName assemblyName) { throw null; }

src/libraries/System.Reflection.MetadataLoadContext/src/System/Reflection/MetadataLoadContext.Apis.cs

@@ -116,7 +116,8 @@ public MetadataLoadContext(MetadataAssemblyResolver resolver, string? coreAssemb
             }
 
             // Resolve the core assembly now
-            _coreTypes = new CoreTypes(this, coreAssemblyName);
+            _coreAssembly = LoadCoreAssembly(coreAssemblyName);
+            _coreTypes = new CoreTypes(_coreAssembly);
         }
 
         /// <summary>
@@ -205,8 +206,7 @@ public Assembly LoadFromAssemblyName(AssemblyName assemblyName)
         /// The core assembly is treated differently than other assemblies because references to these well-known types do
         /// not include the assembly reference, unlike normal types.
         ///
-        /// Typically, this assembly is named "mscorlib", or "netstandard". If the core assembly cannot be found, the value will be
-        /// null and many other reflection methods, including those that parse method signatures, will throw.
+        /// Typically, this assembly is named "System.Runtime", "mscorlib", or "netstandard".
         ///
         /// The CoreAssembly is determined by passing the coreAssemblyName parameter passed to the MetadataAssemblyResolver constructor
         /// to the MetadataAssemblyResolver's Resolve method.
@@ -220,13 +220,6 @@ public Assembly LoadFromAssemblyName(AssemblyName assemblyName)
         /// such as DllImportAttribute. However, it can serve if you have no interest in those attributes. The CustomAttributes api
         /// will skip those attributes if the core assembly does not include the necessary types.
         ///
-        /// The CoreAssembly is not loaded until necessary. These APIs do not trigger the search for the core assembly:
-        ///    MetadataLoadContext.LoadFromStream(), LoadFromAssemblyPath(), LoadFromByteArray()
-        ///    Assembly.GetName(), Assembly.FullName, Assembly.GetReferencedAssemblies()
-        ///    Assembly.GetTypes(), Assembly.DefinedTypes, Assembly.GetExportedTypes(), Assembly.GetForwardedTypes()
-        ///    Assembly.GetType(string, bool, bool)
-        ///    Type.Name, Type.FullName, Type.AssemblyQualifiedName
-        ///
         /// If a core assembly cannot be found or if the core assembly is missing types, this will affect the behavior of the MetadataLoadContext as follows:
         ///
         /// - Apis that need to parse signatures or typespecs and return the results as Types will throw. For example,
@@ -240,7 +233,7 @@ public Assembly LoadFromAssemblyName(AssemblyName assemblyName)
         ///   type, the necessary constructor or any of the parameter types of the constructor, the MetadataLoadContext will not throw. It will omit the pseudo-custom
         ///   attribute from the list of returned attributes.
         /// </summary>
-        public Assembly? CoreAssembly
+        public Assembly CoreAssembly
         {
             get
             {

src/libraries/System.Reflection.MetadataLoadContext/src/System/Reflection/MetadataLoadContext.CoreAssembly.cs

@@ -11,21 +11,25 @@ public sealed partial class MetadataLoadContext
     {
         private static readonly string[] s_CoreNames = { "mscorlib", "System.Runtime", "netstandard" };
 
-        // Cache loaded coreAssembly and core types.
-        internal RoAssembly? TryGetCoreAssembly(string? coreAssemblyName, out Exception? e)
+        internal RoAssembly LoadCoreAssembly(string? coreAssemblyName)
         {
-            Debug.Assert(_coreAssembly == null);
+            RoAssembly? coreAssembly;
+            Exception? e;
             if (coreAssemblyName == null)
             {
-                _coreAssembly = TryGetDefaultCoreAssembly(out e);
+                coreAssembly = TryGetDefaultCoreAssembly(out e);
             }
             else
             {
                 RoAssemblyName roAssemblyName = new AssemblyName(coreAssemblyName).ToRoAssemblyName();
-                _coreAssembly = TryResolveAssembly(roAssemblyName, out e);
+                coreAssembly = TryResolveAssembly(roAssemblyName, out e);
             }
 
-            return _coreAssembly;
+            if (coreAssembly == null)
+            {
+                throw e!;
+            }
+            return coreAssembly;
         }
 
         private RoAssembly? TryGetDefaultCoreAssembly(out Exception? e)
@@ -47,7 +51,7 @@ public sealed partial class MetadataLoadContext
             return null;
         }
 
-        private RoAssembly? _coreAssembly;
+        private readonly RoAssembly _coreAssembly;
 
         /// <summary>
         /// Returns a lazily created and cached Type instance corresponding to the indicated core type. This method throws

src/libraries/System.Reflection.MetadataLoadContext/src/System/Reflection/TypeLoading/General/CoreTypes.cs

@@ -11,28 +11,19 @@ internal sealed class CoreTypes
         private readonly RoType?[] _coreTypes;
         private readonly Exception?[] _exceptions;
 
-        internal CoreTypes(MetadataLoadContext loader, string? coreAssemblyName)
+        internal CoreTypes(RoAssembly coreAssembly)
         {
             int numCoreTypes = (int)CoreType.NumCoreTypes;
             RoType?[] coreTypes = new RoType[numCoreTypes];
             Exception?[] exceptions = new Exception[numCoreTypes];
-            RoAssembly? coreAssembly = loader.TryGetCoreAssembly(coreAssemblyName, out Exception? e);
-            if (coreAssembly == null)
+            for (int i = 0; i < numCoreTypes; i++)
             {
-                // If the core assembly was not found, don't continue.
-                throw e!;
-            }
-            else
-            {
-                for (int i = 0; i < numCoreTypes; i++)
+                ((CoreType)i).GetFullName(out ReadOnlySpan<byte> ns, out ReadOnlySpan<byte> name);
+                RoType? type = coreAssembly.GetTypeCore(ns, name, ignoreCase: false, out Exception? e);
+                coreTypes[i] = type;
+                if (type == null)
                 {
-                    ((CoreType)i).GetFullName(out ReadOnlySpan<byte> ns, out ReadOnlySpan<byte> name);
-                    RoType? type = coreAssembly.GetTypeCore(ns, name, ignoreCase: false, out e);
-                    coreTypes[i] = type;
-                    if (type == null)
-                    {
-                        exceptions[i] = e;
-                    }
+                    exceptions[i] = e;
                 }
             }
             _coreTypes = coreTypes;