Runtime support for upcoming .NET Core WinRT Host (#23402)

* First pass at adding winrt host entry-point.

* There's no way to specify HResult-swapping on a function called via hosted-interop so just return the HResult instead.

* Use the WindowsRuntimeMarshal class to create the activation factory and initialize it.

* Implement loading the dependent assemblies of a WinRT assembly into an isolated load context.

* PR Feedback.

* Fail to get the activation factory if the found type is not a managed type exported from a winmd.

* Rearrange parameters based on PR feedback.

* Remove unneeded include.

* Make ActivationFactoryLoader internal.

* Fix null-ref in WinRT-dependent-assembly loading

* Remove extraneous "System."

22 files changed, 187 insertions, 27 deletions

diff --git a/src/System.Private.CoreLib/ILLinkTrim.xml b/src/System.Private.CoreLib/ILLinkTrim.xml
index e334c3703e..5820e2be13 100644
--- a/src/System.Private.CoreLib/ILLinkTrim.xml
+++ b/src/System.Private.CoreLib/ILLinkTrim.xml
@@ -50,5 +50,7 @@
     <!-- Accessed via native code. -->
     <type fullname="System.Runtime.InteropServices.ComTypes.IEnumerable" />
     <type fullname="System.Runtime.InteropServices.CustomMarshalers.*" />
+    <!-- Accessed by the WinRT Host -->
+    <type fullname="Internal.Runtime.InteropServices.WindowsRuntime.ActivationFactoryLoader" />
   </assembly>
 </linker>
diff --git a/src/System.Private.CoreLib/System.Private.CoreLib.csproj b/src/System.Private.CoreLib/System.Private.CoreLib.csproj
index defcc7a6f6..93d24e4ef6 100644
--- a/src/System.Private.CoreLib/System.Private.CoreLib.csproj
+++ b/src/System.Private.CoreLib/System.Private.CoreLib.csproj
@@ -294,6 +294,7 @@
   </ItemGroup>
   <ItemGroup Condition="'$(FeatureCominterop)' == 'true'">
     <Compile Include="$(BclSourcesRoot)\Internal\Runtime\InteropServices\WindowsRuntime\ExceptionSupport.cs" />
+    <Compile Include="$(BclSourcesRoot)\Internal\Runtime\InteropServices\WindowsRuntime\ActivationFactoryLoader.cs" Condition="'$(FeatureCominteropWinRTManagedActivation)' == 'true'" />
     <Compile Include="$(BclSourcesRoot)\Internal\Runtime\InteropServices\ComActivator.cs" Condition="'$(FeatureCominteropUnmanagedActivation)' == 'true'" />
     <Compile Include="$(BclSourcesRoot)\Microsoft\Win32\OAVariantLib.cs" Condition="'$(FeatureClassicCominterop)' == 'true'" />
     <Compile Include="$(BclSourcesRoot)\System\__ComObject.cs" />
diff --git a/src/System.Private.CoreLib/src/Internal/Runtime/InteropServices/WindowsRuntime/ActivationFactoryLoader.cs b/src/System.Private.CoreLib/src/Internal/Runtime/InteropServices/WindowsRuntime/ActivationFactoryLoader.cs
new file mode 100644
index 0000000000..eb1c584b6c
--- /dev/null
+++ b/src/System.Private.CoreLib/src/Internal/Runtime/InteropServices/WindowsRuntime/ActivationFactoryLoader.cs
@@ -0,0 +1,74 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Runtime.InteropServices.WindowsRuntime;
+using System.Runtime.Loader;
+
+namespace Internal.Runtime.InteropServices.WindowsRuntime
+{
+    internal static class ActivationFactoryLoader
+    {
+        // Collection of all ALCs used for WinRT activation.
+        // Since each of the assemblies that act as the "key" here are WinRT assemblies
+        // we don't need to share this dictionary with the COM activation dictionary
+        // since there will be no overlap.
+        private static Dictionary<string, AssemblyLoadContext> s_AssemblyLoadContexts = new Dictionary<string, AssemblyLoadContext>(StringComparer.InvariantCultureIgnoreCase);
+        
+        private static AssemblyLoadContext GetALC(string assemblyPath)
+        {
+            AssemblyLoadContext alc;
+
+            lock (s_AssemblyLoadContexts)
+            {
+                if (!s_AssemblyLoadContexts.TryGetValue(assemblyPath, out alc))
+                {
+                    alc = new IsolatedComponentLoadContext(assemblyPath);
+                    s_AssemblyLoadContexts.Add(assemblyPath, alc);
+                }
+            }
+
+            return alc;
+        }
+
+        /// <summary>Get a WinRT activation factory for a given type name.</summary>
+        /// <param name="componentPath">The path to the WinRT component that the type is expected to be defined in.</param>
+        /// <param name="typeName">The name of the component type to activate</param>
+        /// <param name="activationFactory">The activation factory</param>
+        public unsafe static int GetActivationFactory(
+            char* componentPath,
+            [MarshalAs(UnmanagedType.HString)] string typeName,
+            [MarshalAs(UnmanagedType.Interface)] out IActivationFactory activationFactory)
+        {
+            activationFactory = null;
+            try
+            {
+                if (typeName is null)
+                {
+                    throw new ArgumentNullException(nameof(typeName));
+                }
+
+                AssemblyLoadContext context = GetALC(Marshal.PtrToStringUni((IntPtr)componentPath));
+                
+                Type winRTType = context.LoadTypeForWinRTTypeNameInContext(typeName);
+
+                if (winRTType is null || !winRTType.IsExportedToWindowsRuntime)
+                {
+                    throw new TypeLoadException(typeName);
+                }
+                activationFactory = WindowsRuntimeMarshal.GetManagedActivationFactory(winRTType);
+            }
+            catch (Exception ex)
+            {
+                return ex.HResult;
+            }
+            return 0;
+        }
+    }
+}
diff --git a/src/System.Private.CoreLib/src/System/RtType.cs b/src/System.Private.CoreLib/src/System/RtType.cs
index 3d03771258..c3e8d09066 100644
--- a/src/System.Private.CoreLib/src/System/RtType.cs
+++ b/src/System.Private.CoreLib/src/System/RtType.cs
@@ -3364,14 +3364,15 @@ namespace System
 #if FEATURE_COMINTEROP
         internal override bool IsWindowsRuntimeObjectImpl() => IsWindowsRuntimeObjectType(this);
 
-        internal override bool IsExportedToWindowsRuntimeImpl() => IsTypeExportedToWindowsRuntime(this);
-
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         private static extern bool IsWindowsRuntimeObjectType(RuntimeType type);
 
+#if FEATURE_COMINTEROP_WINRT_MANAGED_ACTIVATION
+        internal override bool IsExportedToWindowsRuntimeImpl() => IsTypeExportedToWindowsRuntime(this);
+
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         private static extern bool IsTypeExportedToWindowsRuntime(RuntimeType type);
-
+#endif // FEATURE_COMINTEROP_WINRT_MANAGED_ACTIVATION
 #endif // FEATURE_COMINTEROP
 
         internal bool IsDelegate() => GetBaseType() == typeof(MulticastDelegate);
diff --git a/src/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs b/src/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs
index 61bef8e478..5cabe5158e 100644
--- a/src/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs
+++ b/src/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs
@@ -219,6 +219,26 @@ namespace System.Runtime.Loader
         }
         
         [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
+        private static extern void LoadTypeForWinRTTypeNameInContextInternal(IntPtr ptrNativeAssemblyLoadContext, string typeName, ObjectHandleOnStack loadedType);
+
+        internal Type LoadTypeForWinRTTypeNameInContext(string typeName)
+        {
+            if (typeName is null)
+            {
+                throw new ArgumentNullException(nameof(typeName));
+            }
+
+            lock (_unloadLock)
+            {
+                VerifyIsAlive();
+
+                Type type = null;
+                LoadTypeForWinRTTypeNameInContextInternal(_nativeAssemblyLoadContext, typeName, JitHelpers.GetObjectHandleOnStack(ref type));
+                return type;
+            }
+        }
+        
+        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
         private static extern IntPtr GetLoadContextForAssembly(RuntimeAssembly assembly);
 
         // Returns the load context in which the specified assembly has been loaded
diff --git a/src/vm/appdomain.cpp b/src/vm/appdomain.cpp
index ea69f41ee6..abb9ac15d6 100644
--- a/src/vm/appdomain.cpp
+++ b/src/vm/appdomain.cpp
@@ -5298,6 +5298,9 @@ PEAssembly * AppDomain::BindAssemblySpec(
             hr = BindAssemblySpecForHostedBinder(pSpec, pAssemblyName, m_pWinRtBinder, &pAssembly);
             if (FAILED(hr))
                 goto EndTry2; // Goto end of try block.
+
+            PTR_CLRPrivAssemblyWinRT assem = dac_cast<PTR_CLRPrivAssemblyWinRT>(pAssembly->GetHostAssembly());
+            assem->SetFallbackBinder(pSpec->GetHostBinder());
 EndTry2:;
         }
         // The combination of this conditional catch/ the following if statement which will throw reduces the count of exceptions 
diff --git a/src/vm/assemblynative.cpp b/src/vm/assemblynative.cpp
index eed310aaa6..9c1e467f2f 100644
--- a/src/vm/assemblynative.cpp
+++ b/src/vm/assemblynative.cpp
@@ -426,6 +426,26 @@ void QCALLTYPE AssemblyNative::GetLocation(QCall::AssemblyHandle pAssembly, QCal
     END_QCALL;
 }
 
+
+#ifdef FEATURE_COMINTEROP_WINRT_MANAGED_ACTIVATION
+void QCALLTYPE AssemblyNative::LoadTypeForWinRTTypeNameInContext(INT_PTR ptrAssemblyLoadContext, LPCWSTR pwzTypeName, QCall::ObjectHandleOnStack retType)
+{
+    QCALL_CONTRACT;
+
+    BEGIN_QCALL;
+
+    TypeHandle loadedType = WinRTTypeNameConverter::LoadManagedTypeForWinRTTypeName(pwzTypeName, (ICLRPrivBinder*)ptrAssemblyLoadContext, /* pbIsPrimitive */ nullptr);
+
+    if (!loadedType.IsNull())
+    {
+         GCX_COOP();
+         retType.Set(loadedType.GetManagedClassObject());
+    }
+
+    END_QCALL;
+}
+#endif
+
 void QCALLTYPE AssemblyNative::GetType(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, BOOL bThrowOnError, BOOL bIgnoreCase, QCall::ObjectHandleOnStack retType, QCall::ObjectHandleOnStack keepAlive)
 {
     CONTRACTL
diff --git a/src/vm/assemblynative.hpp b/src/vm/assemblynative.hpp
index 13db261359..0ce2fb2327 100644
--- a/src/vm/assemblynative.hpp
+++ b/src/vm/assemblynative.hpp
@@ -124,6 +124,9 @@ public:
     static void QCALLTYPE LoadFromInMemoryModule(INT_PTR ptrNativeAssemblyLoadContext, INT_PTR hModule, QCall::ObjectHandleOnStack retLoadedAssembly);
 #endif
     static Assembly* LoadFromPEImage(ICLRPrivBinder* pBinderContext, PEImage *pILImage, PEImage *pNIImage);
+#ifdef FEATURE_COMINTEROP_WINRT_MANAGED_ACTIVATION
+    static void QCALLTYPE LoadTypeForWinRTTypeNameInContext(INT_PTR ptrAssemblyLoadContext, LPCWSTR pwzTypeName, QCall::ObjectHandleOnStack retType);
+#endif
     static INT_PTR QCALLTYPE GetLoadContextForAssembly(QCall::AssemblyHandle pAssembly);
 
     static BOOL QCALLTYPE InternalTryGetRawMetadata(QCall::AssemblyHandle assembly, UINT8 **blobRef, INT32 *lengthRef);
diff --git a/src/vm/assemblyspec.cpp b/src/vm/assemblyspec.cpp
index a2323afe6b..a044456ff9 100644
--- a/src/vm/assemblyspec.cpp
+++ b/src/vm/assemblyspec.cpp
@@ -870,8 +870,18 @@ ICLRPrivBinder* AssemblySpec::GetBindingContextFromParentAssembly(AppDomain *pDo
             // types being referenced from Windows.Foundation.Winmd).
             //
             // If the AssemblySpec does not correspond to WinRT type but our parent assembly binder is a WinRT binder,
-            // then such an assembly will not be found by the binder. In such a case, we reset our binder reference.
+            // then such an assembly will not be found by the binder.
+            // In such a case, the parent binder should be the fallback binder for the WinRT assembly if one exists.
+            ICLRPrivBinder* pParentWinRTBinder = pParentAssemblyBinder;
             pParentAssemblyBinder = NULL;
+            ReleaseHolder<ICLRPrivAssemblyID_WinRT> assembly;
+            if (SUCCEEDED(pParentWinRTBinder->QueryInterface<ICLRPrivAssemblyID_WinRT>(&assembly)))
+            {
+                pParentAssemblyBinder = dac_cast<PTR_CLRPrivAssemblyWinRT>(assembly.GetValue())->GetFallbackBinder();
+
+                // The fallback binder should not be a WinRT binder.
+                _ASSERTE(!AreSameBinderInstance(pWinRTBinder, pParentAssemblyBinder));
+            }
         }
     }
 #endif // defined(FEATURE_COMINTEROP)
diff --git a/src/vm/clrprivbinderwinrt.cpp b/src/vm/clrprivbinderwinrt.cpp
index 2441dae399..83cdf88473 100644
--- a/src/vm/clrprivbinderwinrt.cpp
+++ b/src/vm/clrprivbinderwinrt.cpp
@@ -985,7 +985,8 @@ CLRPrivAssemblyWinRT::CLRPrivAssemblyWinRT(
       m_pIResourceNI(nullptr),
       m_pIBindResult(nullptr),
       m_fShareable(fShareable),
-      m_dwImageTypes(0)
+      m_dwImageTypes(0),
+      m_FallbackBinder(nullptr)
 {
     STANDARD_VM_CONTRACT;
     VALIDATE_ARG_THROW((pBinder != nullptr) && (pResourceIL != nullptr) && (pIBindResult != nullptr));
diff --git a/src/vm/clrprivbinderwinrt.h b/src/vm/clrprivbinderwinrt.h
index e9cc1dfe9a..da6f0d53f7 100644
--- a/src/vm/clrprivbinderwinrt.h
+++ b/src/vm/clrprivbinderwinrt.h
@@ -323,6 +323,16 @@ public:
         DWORD               dwImageType, 
         DWORD *             pdwImageType, 
         ICLRPrivResource ** ppIResource);
+
+    void SetFallbackBinder(ICLRPrivBinder* fallbackBinder)
+    {
+        m_FallbackBinder = clr::SafeAddRef(fallbackBinder);
+    }
+
+    ICLRPrivBinder* GetFallbackBinder()
+    {
+        return m_FallbackBinder;
+    }
     
 private:
     //=============================================================================================
@@ -336,4 +346,5 @@ private:
     ReleaseHolder<IBindResult> m_pIBindResult;
     BOOL m_fShareable;
     Volatile<DWORD> m_dwImageTypes;
+    ReleaseHolder<ICLRPrivBinder> m_FallbackBinder;
 };  // class CLRPrivAssemblyWinRT
diff --git a/src/vm/corhost.cpp b/src/vm/corhost.cpp
index 8255f9aa4b..b42fc28a85 100644
--- a/src/vm/corhost.cpp
+++ b/src/vm/corhost.cpp
@@ -2410,7 +2410,7 @@ HRESULT STDMETHODCALLTYPE DllGetActivationFactoryImpl(LPCWSTR wszAssemblyName,
         GCX_COOP();
 
         bool bIsPrimitive;
-        TypeHandle typeHandle = WinRTTypeNameConverter::GetManagedTypeFromWinRTTypeName(wszTypeName, &bIsPrimitive);
+        TypeHandle typeHandle = WinRTTypeNameConverter::LoadManagedTypeForWinRTTypeName(wszTypeName, /* pLoadBinder */ nullptr, &bIsPrimitive);
         if (!bIsPrimitive && !typeHandle.IsNull() && !typeHandle.IsTypeDesc() && typeHandle.AsMethodTable()->IsExportedToWinRT())
         {
             struct _gc {
diff --git a/src/vm/ecalllist.h b/src/vm/ecalllist.h
index ae98cff196..7f617caca5 100644
--- a/src/vm/ecalllist.h
+++ b/src/vm/ecalllist.h
@@ -520,6 +520,9 @@ FCFuncStart(gAssemblyLoadContextFuncs)
     QCFuncElement("LoadFromPath", AssemblyNative::LoadFromPath)
     QCFuncElement("InternalLoadUnmanagedDllFromPath", AssemblyNative::InternalLoadUnmanagedDllFromPath)
     QCFuncElement("LoadFromStream", AssemblyNative::LoadFromStream)
+#ifdef FEATURE_COMINTEROP_WINRT_MANAGED_ACTIVATION
+    QCFuncElement("LoadTypeForWinRTTypeNameInContextInternal", AssemblyNative::LoadTypeForWinRTTypeNameInContext)
+#endif
 #ifndef FEATURE_PAL
     QCFuncElement("LoadFromInMemoryModuleInternal", AssemblyNative::LoadFromInMemoryModule)
 #endif
diff --git a/src/vm/interoputil.cpp b/src/vm/interoputil.cpp
index 5c000569d6..7cca714a14 100644
--- a/src/vm/interoputil.cpp
+++ b/src/vm/interoputil.cpp
@@ -5103,7 +5103,7 @@ void InitializeComInterop()
 }
 
 // Try to load a WinRT type.
-TypeHandle GetWinRTType(SString* ssTypeName, BOOL bThrowIfNotFound)
+TypeHandle LoadWinRTType(SString* ssTypeName, BOOL bThrowIfNotFound, ICLRPrivBinder* loadBinder /* =nullptr */)
 {
     CONTRACT (TypeHandle)
     {
@@ -5116,8 +5116,8 @@ TypeHandle GetWinRTType(SString* ssTypeName, BOOL bThrowIfNotFound)
     TypeHandle typeHandle;
 
     SString ssAssemblyName(SString::Utf8Literal, "WindowsRuntimeAssemblyName, ContentType=WindowsRuntime");
-    DomainAssembly *pAssembly = LoadDomainAssembly(&ssAssemblyName, NULL, 
-                                                   NULL, 
+    DomainAssembly *pAssembly = LoadDomainAssembly(&ssAssemblyName, nullptr, 
+                                                   loadBinder, 
                                                    bThrowIfNotFound, ssTypeName);
     if (pAssembly != NULL)
     {
@@ -6669,7 +6669,7 @@ TypeHandle GetClassFromIInspectable(IUnknown* pUnk, bool *pfSupportsIInspectable
         EX_TRY
         {
             LPCWSTR pszWinRTTypeName = (ssTmpClassName.IsEmpty() ? ssClassName  : ssTmpClassName);
-            classTypeHandle = WinRTTypeNameConverter::GetManagedTypeFromWinRTTypeName(pszWinRTTypeName, /*pbIsPrimitive = */ NULL);
+            classTypeHandle = WinRTTypeNameConverter::LoadManagedTypeForWinRTTypeName(pszWinRTTypeName, /* pLoadBinder */ nullptr, /*pbIsPrimitive = */ nullptr);
         }
         EX_CATCH
         {
diff --git a/src/vm/interoputil.h b/src/vm/interoputil.h
index 872848b9df..311cedd102 100644
--- a/src/vm/interoputil.h
+++ b/src/vm/interoputil.h
@@ -443,7 +443,7 @@ MethodTable* GetClassFromIProvideClassInfo(IUnknown* pUnk);
 
 //--------------------------------------------------------------------------------
 // Try to load a WinRT type.
-TypeHandle GetWinRTType(SString* ssTypeName, BOOL bThrowIfNotFound);
+TypeHandle LoadWinRTType(SString* ssTypeName, BOOL bThrowIfNotFound, ICLRPrivBinder* loadBinder = nullptr);
 
 //--------------------------------------------------------------------------------
 // Try to get the class from IInspectable.
diff --git a/src/vm/runtimecallablewrapper.cpp b/src/vm/runtimecallablewrapper.cpp
index 48554086da..540536ef5f 100644
--- a/src/vm/runtimecallablewrapper.cpp
+++ b/src/vm/runtimecallablewrapper.cpp
@@ -911,7 +911,7 @@ void WinRTClassFactory::Init()
                 IfFailThrow(cap.GetNonNullString(&szFactoryInterfaceName, &cbFactoryInterfaceName));
 
                 StackSString strFactoryInterface(SString::Utf8, szFactoryInterfaceName, cbFactoryInterfaceName);
-                MethodTable *pMTFactoryInterface = GetWinRTType(&strFactoryInterface, /* bThrowIfNotFound = */ TRUE).GetMethodTable();
+                MethodTable *pMTFactoryInterface = LoadWinRTType(&strFactoryInterface, /* bThrowIfNotFound = */ TRUE).GetMethodTable();
 
                 _ASSERTE(pMTFactoryInterface);
                 m_factoryInterfaces.Append(pMTFactoryInterface);
@@ -951,7 +951,7 @@ void WinRTClassFactory::Init()
             
                 // copy the name to a temporary buffer and NULL terminate it
                 StackSString ss(SString::Utf8, szName, cbName);
-                TypeHandle th = GetWinRTType(&ss, /* bThrowIfNotFound = */ TRUE);
+                TypeHandle th = LoadWinRTType(&ss, /* bThrowIfNotFound = */ TRUE);
 
                 MethodTable *pMTStaticInterface = th.GetMethodTable();
                 m_staticInterfaces.Append(pMTStaticInterface);
diff --git a/src/vm/runtimehandles.cpp b/src/vm/runtimehandles.cpp
index 083423b025..9acb47f195 100644
--- a/src/vm/runtimehandles.cpp
+++ b/src/vm/runtimehandles.cpp
@@ -384,6 +384,7 @@ FCIMPL1(FC_BOOL_RET, RuntimeTypeHandle::IsWindowsRuntimeObjectType, ReflectClass
 }
 FCIMPLEND
 
+#ifdef FEATURE_COMINTEROP_WINRT_MANAGED_ACTIVATION
 FCIMPL1(FC_BOOL_RET, RuntimeTypeHandle::IsTypeExportedToWindowsRuntime, ReflectClassBaseObject *rtTypeUNSAFE)
 {
     FCALL_CONTRACT;
@@ -401,6 +402,7 @@ FCIMPL1(FC_BOOL_RET, RuntimeTypeHandle::IsTypeExportedToWindowsRuntime, ReflectC
     FC_RETURN_BOOL(isExportedToWinRT);
 }
 FCIMPLEND
+#endif
 #endif // FEATURE_COMINTEROP
 
 NOINLINE static MethodDesc * RestoreMethodHelper(MethodDesc * pMethod, LPVOID __me)
diff --git a/src/vm/runtimehandles.h b/src/vm/runtimehandles.h
index 1db16917fc..4c2ebdf52d 100644
--- a/src/vm/runtimehandles.h
+++ b/src/vm/runtimehandles.h
@@ -160,8 +160,10 @@ public:
 
 #ifdef FEATURE_COMINTEROP
     static FCDECL1(FC_BOOL_RET, IsWindowsRuntimeObjectType, ReflectClassBaseObject *rtTypeUNSAFE);
+#ifdef FEATURE_COMINTEROP_WINRT_MANAGED_ACTIVATION
     static FCDECL1(FC_BOOL_RET, IsTypeExportedToWindowsRuntime, ReflectClassBaseObject *rtTypeUNSAFE);
-#endif // FEATURE_COMINTEROP
+#endif
+#endif //FEATURE_COMINTEROP
 
     static
     void QCALLTYPE PrepareMemberInfoCache(EnregisteredTypeHandle pMemberInfoCache);
diff --git a/src/vm/stdinterfaces.cpp b/src/vm/stdinterfaces.cpp
index 1a9d0e2db1..15da1c8c22 100644
--- a/src/vm/stdinterfaces.cpp
+++ b/src/vm/stdinterfaces.cpp
@@ -3121,7 +3121,7 @@ HRESULT __stdcall IStringable_ToString(IUnknown* pStringable,
 
         // Get the MethodTable for Windows.Foundation.IStringable.
         StackSString strIStringable(SString::Utf8, W("Windows.Foundation.IStringable"));
-        MethodTable *pMTIStringable = GetWinRTType(&strIStringable, /* bThrowIfNotFound = */ FALSE).GetMethodTable();
+        MethodTable *pMTIStringable = LoadWinRTType(&strIStringable, /* bThrowIfNotFound = */ FALSE).GetMethodTable();
 
         if (pMT != NULL && pMTIStringable != NULL && pMT->ImplementsInterface(pMTIStringable))
         {
diff --git a/src/vm/stubhelpers.cpp b/src/vm/stubhelpers.cpp
index 72265b0584..9cd2cf927c 100644
--- a/src/vm/stubhelpers.cpp
+++ b/src/vm/stubhelpers.cpp
@@ -705,6 +705,9 @@ FCIMPL4(IUnknown*, StubHelpers::InterfaceMarshaler__ConvertToNative, Object* pOb
     // This is only called in IL stubs which are in CER, so we don't need to worry about ThreadAbort
     HELPER_METHOD_FRAME_BEGIN_RET_ATTRIB_1(Frame::FRAME_ATTR_NO_THREAD_ABORT, pObj);
 
+    // We're going to be making some COM calls, better initialize COM.
+    EnsureComStarted();
+
     pIntf = MarshalObjectToInterface(&pObj, pItfMT, pClsMT, dwFlags);
 
     // No exception will be thrown here (including thread abort as it is delayed in IL stubs)
@@ -725,6 +728,9 @@ FCIMPL4(Object*, StubHelpers::InterfaceMarshaler__ConvertToManaged, IUnknown **p
     
     OBJECTREF pObj = NULL;
     HELPER_METHOD_FRAME_BEGIN_RET_1(pObj);
+    
+    // We're going to be making some COM calls, better initialize COM.
+    EnsureComStarted();
 
     UnmarshalObjectFromInterface(&pObj, ppUnk, pItfMT, pClsMT, dwFlags);
 
@@ -893,7 +899,7 @@ FCIMPL2(ReflectClassBaseObject *, StubHelpers::WinRTTypeNameConverter__GetTypeFr
     HELPER_METHOD_FRAME_BEGIN_RET_2(refClass, refString);
 
     bool isPrimitive;
-    TypeHandle th = WinRTTypeNameConverter::GetManagedTypeFromWinRTTypeName(refString->GetBuffer(), &isPrimitive);
+    TypeHandle th = WinRTTypeNameConverter::LoadManagedTypeForWinRTTypeName(refString->GetBuffer(), /* pLoadBinder */ nullptr, &isPrimitive);
     *pbIsPrimitive = isPrimitive;
     
     refClass = th.GetManagedClassObject();
diff --git a/src/vm/winrttypenameconverter.cpp b/src/vm/winrttypenameconverter.cpp
index e30128b5df..e9fd3c7ea0 100644
--- a/src/vm/winrttypenameconverter.cpp
+++ b/src/vm/winrttypenameconverter.cpp
@@ -828,7 +828,7 @@ bool WinRTTypeNameConverter::IsRedirectedWinRTSourceType(MethodTable *pMT)
 // Get TypeHandle from a WinRT type name
 // Parse the WinRT type name in the form of WinRTType=TypeName[<WinRTType[, WinRTType, ...]>]
 //
-TypeHandle WinRTTypeNameConverter::GetManagedTypeFromWinRTTypeName(LPCWSTR wszWinRTTypeName, bool *pbIsPrimitive)
+TypeHandle WinRTTypeNameConverter::LoadManagedTypeForWinRTTypeName(LPCWSTR wszWinRTTypeName, ICLRPrivBinder * loadBinder, bool *pbIsPrimitive)
 {
     CONTRACTL
     {
@@ -842,7 +842,7 @@ TypeHandle WinRTTypeNameConverter::GetManagedTypeFromWinRTTypeName(LPCWSTR wszWi
 
     SString ssTypeName(SString::Literal, wszWinRTTypeName);
     
-    TypeHandle th = GetManagedTypeFromWinRTTypeNameInternal(&ssTypeName, pbIsPrimitive);
+    TypeHandle th = LoadManagedTypeForWinRTTypeNameInternal(&ssTypeName, loadBinder, pbIsPrimitive);
     if (th.IsNull())
     {
         COMPlusThrowArgumentException(W("typeName"), NULL);    
@@ -900,7 +900,7 @@ extern "C" HRESULT WINAPI CrossgenRoParseTypeName(SString* typeName, DWORD *part
 // Return TypeHandle for the specified WinRT type name (supports generic type)
 // Updates wszWinRTTypeName pointer as it parse the string    
 //
-TypeHandle WinRTTypeNameConverter::GetManagedTypeFromWinRTTypeNameInternal(SString *ssTypeName, bool *pbIsPrimitive)
+TypeHandle WinRTTypeNameConverter::LoadManagedTypeForWinRTTypeNameInternal(SString *ssTypeName, ICLRPrivBinder* loadBinder, bool *pbIsPrimitive)
 {
     CONTRACTL
     {
@@ -944,7 +944,7 @@ TypeHandle WinRTTypeNameConverter::GetManagedTypeFromWinRTTypeNameInternal(SStri
             PCWSTR wszPart = WindowsGetStringRawBuffer(rhsPartNames[i], &cchPartLength);
 
             StackSString ssPartName(wszPart, cchPartLength);
-            rqPartTypes[i] = GetManagedTypeFromSimpleWinRTNameInternal(&ssPartName, NULL);
+            rqPartTypes[i] = GetManagedTypeFromSimpleWinRTNameInternal(&ssPartName, loadBinder, nullptr);
         }
 
 #else //CROSSGEN_COMPILE
@@ -963,7 +963,7 @@ TypeHandle WinRTTypeNameConverter::GetManagedTypeFromWinRTTypeNameInternal(SStri
         // load the components
         for (DWORD i = 0; i < dwPartsCount; i++)
         {
-            rqPartTypes[i] = GetManagedTypeFromSimpleWinRTNameInternal(&rhsPartNames[i], NULL);
+            rqPartTypes[i] = GetManagedTypeFromSimpleWinRTNameInternal(&rhsPartNames[i], loadBinder, NULL);
         }
 
         delete[] rhsPartNames;
@@ -980,7 +980,7 @@ TypeHandle WinRTTypeNameConverter::GetManagedTypeFromWinRTTypeNameInternal(SStri
     }
     else
     {
-        return GetManagedTypeFromSimpleWinRTNameInternal(ssTypeName, pbIsPrimitive);
+        return GetManagedTypeFromSimpleWinRTNameInternal(ssTypeName, loadBinder, pbIsPrimitive);
     }
 }
 
@@ -988,7 +988,7 @@ TypeHandle WinRTTypeNameConverter::GetManagedTypeFromWinRTTypeNameInternal(SStri
 // Return MethodTable* for the specified WinRT primitive type name (non-generic type)
 // Updates wszWinRTTypeName pointer as it parse the string
 //
-TypeHandle WinRTTypeNameConverter::GetManagedTypeFromSimpleWinRTNameInternal(SString *ssTypeName, bool *pbIsPrimitive)
+TypeHandle WinRTTypeNameConverter::GetManagedTypeFromSimpleWinRTNameInternal(SString *ssTypeName, ICLRPrivBinder* loadBinder, bool *pbIsPrimitive)
 {
     CONTRACTL
     {
@@ -1042,7 +1042,7 @@ TypeHandle WinRTTypeNameConverter::GetManagedTypeFromSimpleWinRTNameInternal(SSt
         //
         // A regular WinRT type
         //
-        return GetWinRTType(ssTypeName, TRUE);
+        return LoadWinRTType(ssTypeName, TRUE, loadBinder);
     }
 }
 
diff --git a/src/vm/winrttypenameconverter.h b/src/vm/winrttypenameconverter.h
index c3d139d87a..28dd3b6f7c 100644
--- a/src/vm/winrttypenameconverter.h
+++ b/src/vm/winrttypenameconverter.h
@@ -17,6 +17,7 @@
 #pragma once
 
 #include "..\md\winmd\inc\adapter.h"
+#include "clrprivbinding.h"
 
 struct WinRTTypeNameInfo;
 
@@ -90,7 +91,7 @@ public :
     // Get TypeHandle from a WinRT type name
     // Parse the WinRT type name in the form of WinRTType=TypeName[<WinRTType[, WinRTType, ...]>]
     //
-    static TypeHandle GetManagedTypeFromWinRTTypeName(LPCWSTR wszWinRTTypeName, bool *pbIsPrimitive);
+    static TypeHandle LoadManagedTypeForWinRTTypeName(LPCWSTR wszWinRTTypeName, ICLRPrivBinder * loadBinder, bool *pbIsPrimitive);
     
 private :
     
@@ -108,13 +109,13 @@ private :
     // Return TypeHandle for the specified WinRT type name (supports generic type)
     // Updates wszWinRTTypeName pointer as it parse the string    
     //
-    static TypeHandle GetManagedTypeFromWinRTTypeNameInternal(SString *ssTypeName, bool *pbIsPrimitive);
+    static TypeHandle LoadManagedTypeForWinRTTypeNameInternal(SString *ssTypeName, ICLRPrivBinder* loadBinder, bool *pbIsPrimitive);
     
     //
     // Return MethodTable* for the specified WinRT primitive type name (non-generic type)
     // Updates wszWinRTTypeName pointer as it parse the string
     //
-    static TypeHandle GetManagedTypeFromSimpleWinRTNameInternal(SString *ssTypeName, bool *pbIsPrimitive);
+    static TypeHandle GetManagedTypeFromSimpleWinRTNameInternal(SString *ssTypeName, ICLRPrivBinder* loadBinder, bool *pbIsPrimitive);
 
     static bool AppendWinRTTypeNameForManagedType(
         TypeHandle          thManagedType,