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, coreAssemblyName);
         }
 
         /// <summary>
@@ -240,7 +241,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

@@ -12,20 +12,26 @@ 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 +53,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, string? coreAssemblyName)
         {
             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;