diff --git a/src/System.Private.CoreLib/ILLinkTrim.xml b/src/System.Private.CoreLib/ILLinkTrim.xml
index e334c3703e53..5820e2be13b1 100644
--- a/src/System.Private.CoreLib/ILLinkTrim.xml
+++ b/src/System.Private.CoreLib/ILLinkTrim.xml
@@ -50,5 +50,7 @@
+
+
diff --git a/src/System.Private.CoreLib/System.Private.CoreLib.csproj b/src/System.Private.CoreLib/System.Private.CoreLib.csproj
index e75a0fc2e4f3..35d4659751e0 100644
--- a/src/System.Private.CoreLib/System.Private.CoreLib.csproj
+++ b/src/System.Private.CoreLib/System.Private.CoreLib.csproj
@@ -293,6 +293,7 @@
+
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 000000000000..eb1c584b6c0d
--- /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 s_AssemblyLoadContexts = new Dictionary(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;
+ }
+
+ /// Get a WinRT activation factory for a given type name.
+ /// The path to the WinRT component that the type is expected to be defined in.
+ /// The name of the component type to activate
+ /// The activation factory
+ 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 3d037712586b..c3e8d09066dd 100644
--- a/src/System.Private.CoreLib/src/System/RtType.cs
+++ b/src/System.Private.CoreLib/src/System/RtType.cs
@@ -3364,14 +3364,15 @@ public override Guid GUID
#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 61bef8e47804..5cabe5158ea8 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
@@ -218,6 +218,26 @@ private IntPtr GetResolvedUnmanagedDll(Assembly assembly, string unmanagedDllNam
return IntPtr.Zero;
}
+ [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);
diff --git a/src/vm/appdomain.cpp b/src/vm/appdomain.cpp
index bcffb3b8aa92..85f778ea8a9f 100644
--- a/src/vm/appdomain.cpp
+++ b/src/vm/appdomain.cpp
@@ -5962,6 +5962,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(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 6cbb8afc1797..dfa88405b186 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 13db261359a5..0ce2fb232776 100644
--- a/src/vm/assemblynative.hpp
+++ b/src/vm/assemblynative.hpp
@@ -124,6 +124,9 @@ class AssemblyNative
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 a2323afe6b1b..a044456ff994 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 assembly;
+ if (SUCCEEDED(pParentWinRTBinder->QueryInterface(&assembly)))
+ {
+ pParentAssemblyBinder = dac_cast(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 2441dae39996..83cdf88473f3 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 e9cc1dfe9af9..da6f0d53f783 100644
--- a/src/vm/clrprivbinderwinrt.h
+++ b/src/vm/clrprivbinderwinrt.h
@@ -323,6 +323,16 @@ class CLRPrivAssemblyWinRT :
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 @@ class CLRPrivAssemblyWinRT :
ReleaseHolder m_pIBindResult;
BOOL m_fShareable;
Volatile m_dwImageTypes;
+ ReleaseHolder m_FallbackBinder;
}; // class CLRPrivAssemblyWinRT
diff --git a/src/vm/corhost.cpp b/src/vm/corhost.cpp
index 40d8fff2dcbe..769f99d63810 100644
--- a/src/vm/corhost.cpp
+++ b/src/vm/corhost.cpp
@@ -2420,7 +2420,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 ae98cff19633..7f617caca512 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 5c000569d681..7cca714a1463 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 872848b9df2e..311cedd102ff 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 48554086daca..540536ef5f5b 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 c8782db7efed..f4e1e1d906b4 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 66a27f4626b4..99ea03d37a23 100644
--- a/src/vm/runtimehandles.h
+++ b/src/vm/runtimehandles.h
@@ -160,8 +160,10 @@ class RuntimeTypeHandle {
#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 1a9d0e2db132..15da1c8c2210 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 72265b058496..9cd2cf927cf8 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 e30128b5df39..e9fd3c7ea058 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[]
//
-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 c3d139d87aa4..28dd3b6f7c06 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[]
//
- 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,