Remove more unneeded support for winmds in the assembly loader.

src/coreclr/src/debug/daccess/dacdbiimpl.cpp

@@ -5780,13 +5780,6 @@ HRESULT DacDbiInterfaceImpl::IsWinRTModule(VMPTR_Module vmModule, BOOL& isWinRT)
     HRESULT hr = S_OK;
     isWinRT = FALSE;
 
-    EX_TRY
-    {
-        Module* pModule = vmModule.GetDacPtr();
-        isWinRT = pModule->GetFile()->GetAssembly()->IsWindowsRuntime();
-    }
-    EX_CATCH_HRESULT(hr);
-
     return hr;
 }
 

src/coreclr/src/vm/assembly.cpp

@@ -1043,10 +1043,6 @@ Module * Assembly::FindModuleByTypeRef(
             // Do this first because it has a strong contract
             Assembly * pAssembly = NULL;
 
-#if defined(FEATURE_COMINTEROP) || !defined(DACCESS_COMPILE)
-            LPCUTF8 szNamespace = NULL;
-            LPCUTF8 szClassName = NULL;
-#endif
             if (loadFlag == Loader::SafeLookup)
             {
                 pAssembly = pModule->LookupAssemblyRef(tkType);
@@ -1070,10 +1066,7 @@ Module * Assembly::FindModuleByTypeRef(
             }
 
 
-            DomainAssembly * pDomainAssembly = pModule->LoadAssembly(
-                    tkType,
-                    szNamespace,
-                    szClassName);
+            DomainAssembly * pDomainAssembly = pModule->LoadAssembly(tkType);
 
 
             if (pDomainAssembly == NULL)

src/coreclr/src/vm/assemblyspec.hpp

@@ -250,15 +250,6 @@ class AssemblySpec  : public BaseAssemblySpec
         }
     }
 
-    // Returns true if the object can be used to bind to the target assembly.
-    // One case in which this is not true is when the content type is WinRT
-    // but no type name has been set.
-    inline bool HasBindableIdentity() const
-    {
-        STATIC_CONTRACT_LIMITED_METHOD;
-        return TRUE;
-    }
-
     inline BOOL CanUseWithBindingCache() const
     {
         STATIC_CONTRACT_LIMITED_METHOD;

src/coreclr/src/vm/ceeload.cpp

@@ -4813,14 +4813,7 @@ Module::GetAssemblyRefFlags(
 } // Module::GetAssemblyRefFlags
 
 #ifndef DACCESS_COMPILE
-
-// Arguments:
-//   szWinRtTypeNamespace ... Namespace of WinRT type.
-//   szWinRtTypeClassName ... Name of WinRT type, NULL for non-WinRT (classic) types.
-DomainAssembly * Module::LoadAssembly(
-    mdAssemblyRef kAssemblyRef,
-    LPCUTF8       szWinRtTypeNamespace,
-    LPCUTF8       szWinRtTypeClassName)
+DomainAssembly * Module::LoadAssembly(mdAssemblyRef kAssemblyRef)
 {
     CONTRACT(DomainAssembly *)
     {
@@ -4830,7 +4823,6 @@ DomainAssembly * Module::LoadAssembly(
         if (FORBIDGC_LOADER_USE_ENABLED()) FORBID_FAULT; else { INJECT_FAULT(COMPlusThrowOM();); }
         MODE_ANY;
         POSTCONDITION(CheckPointer(RETVAL, NULL_NOT_OK));
-        //POSTCONDITION((CheckPointer(GetAssemblyIfLoaded(kAssemblyRef, szWinRtTypeNamespace, szWinRtTypeClassName)), NULL_NOT_OK));
     }
     CONTRACT_END;
 
@@ -4844,22 +4836,18 @@ DomainAssembly * Module::LoadAssembly(
     Assembly * pAssembly = LookupAssemblyRef(kAssemblyRef);
     if (pAssembly != NULL)
     {
-        _ASSERTE(HasBindableIdentity(kAssemblyRef));
-
         pDomainAssembly = pAssembly->GetDomainAssembly();
         ::GetAppDomain()->LoadDomainFile(pDomainAssembly, FILE_LOADED);
 
         RETURN pDomainAssembly;
     }
 
-    bool fHasBindableIdentity = HasBindableIdentity(kAssemblyRef);
+    bool fHasBindableIdentity = true;
 
     {
         PEAssemblyHolder pFile = GetDomainAssembly()->GetFile()->LoadAssembly(
                 kAssemblyRef,
-                NULL,
-                szWinRtTypeNamespace,
-                szWinRtTypeClassName);
+                NULL);
         AssemblySpec spec;
         spec.InitializeSpec(kAssemblyRef, GetMDImport(), GetDomainAssembly());
         // Set the binding context in the AssemblySpec if one is available. This can happen if the LoadAssembly ended up

src/coreclr/src/vm/ceeload.h

@@ -2159,21 +2159,12 @@ class Module
     Assembly *GetAssemblyIfLoadedFromNativeAssemblyRefWithRefDefMismatch(mdAssemblyRef kAssemblyRef, BOOL *pfDiscoveredAssemblyRefMatchesTargetDefExactly);
 public:
 
-    DomainAssembly * LoadAssembly(
-            mdAssemblyRef kAssemblyRef,
-            LPCUTF8       szWinRtTypeNamespace = NULL,
-            LPCUTF8       szWinRtTypeClassName = NULL);
+    DomainAssembly * LoadAssembly(mdAssemblyRef kAssemblyRef);
     Module *GetModuleIfLoaded(mdFile kFile, BOOL onlyLoadedInAppDomain, BOOL loadAllowed);
     DomainFile *LoadModule(AppDomain *pDomain, mdFile kFile, BOOL loadResources = TRUE, BOOL bindOnly = FALSE);
     PTR_Module LookupModule(mdToken kFile, BOOL loadResources = TRUE); //wrapper over GetModuleIfLoaded, takes modulerefs as well
     DWORD GetAssemblyRefFlags(mdAssemblyRef tkAssemblyRef);
 
-    bool HasBindableIdentity(mdAssemblyRef tkAssemblyRef)
-    {
-        WRAPPER_NO_CONTRACT;
-        return !IsAfContentType_WindowsRuntime(GetAssemblyRefFlags(tkAssemblyRef));
-    }
-
     // RID maps
     TypeHandle LookupTypeDef(mdTypeDef token, ClassLoadLevel *pLoadLevel = NULL)
     {

src/coreclr/src/vm/compile.cpp

@@ -1296,38 +1296,17 @@ void CEECompileInfo::EncodeModuleAsIndex(CORINFO_MODULE_HANDLE  fromHandle,
         if (!pRefCache)
             ThrowOutOfMemory();
 
+        result = pRefCache->m_sAssemblyRefMap.LookupValue((UPTR)assembly, NULL);
 
-        if (!assembly->GetManifestFile()->HasBindableIdentity())
-        {
-            // If the module that we'd like to encode for a later fixup doesn't have
-            // a bindable identity, then this will fail at runtime. So, we ask the
-            // compilation domain for a matching assembly with a bindable identity.
-            // This is possible because this module must have been bound in the past,
-            // and the compilation domain will keep track of at least one corresponding
-            // bindable identity.
-            AssemblySpec defSpec;
-            defSpec.InitializeSpec(assembly->GetManifestFile());
-
-            AssemblySpec* pRefSpec = pDomain->FindAssemblyRefSpecForDefSpec(&defSpec);
-            _ASSERTE(pRefSpec != nullptr);
-
-            IfFailThrow(pRefSpec->EmitToken(pAssemblyEmit, &token, TRUE, TRUE));
-            token += fromModule->GetAssemblyRefMax();
-        }
+        if (result == (UPTR)INVALIDENTRY)
+            token = fromModule->FindAssemblyRef(assembly);
         else
-        {
-            result = pRefCache->m_sAssemblyRefMap.LookupValue((UPTR)assembly, NULL);
-
-            if (result == (UPTR)INVALIDENTRY)
-                token = fromModule->FindAssemblyRef(assembly);
-            else
-                token = (mdAssemblyRef) result;
+            token = (mdAssemblyRef) result;
 
-            if (IsNilToken(token))
-            {
-                token = fromAssembly->AddAssemblyRef(assembly, pAssemblyEmit);
-                token += fromModule->GetAssemblyRefMax();
-            }
+        if (IsNilToken(token))
+        {
+            token = fromAssembly->AddAssemblyRef(assembly, pAssemblyEmit);
+            token += fromModule->GetAssemblyRefMax();
         }
 
         *pIndex = RidFromToken(token);

src/coreclr/src/vm/domainfile.cpp

@@ -998,13 +998,6 @@ void DomainFile::FinishLoad()
 
     // Are we absolutely required to use a native image?
     CheckZapRequired();
-
-    // If this is a winmd file, throw a bad image format exeption. We don't support winmds.
-    PEFile* peFile = GetFile();
-    if (peFile && peFile->AsAssembly()->IsWindowsRuntime() && peFile->HasHostAssembly())
-    {
-        ThrowHR(COR_E_BADIMAGEFORMAT);
-    }
 #endif // FEATURE_PREJIT
 
     // Flush any log messages

src/coreclr/src/vm/pefile.cpp

@@ -1510,9 +1510,7 @@ void PEFile::GetEmbeddedResource(DWORD dwOffset, DWORD *cbResource, PBYTE *pbInM
 PEAssembly *
 PEFile::LoadAssembly(
     mdAssemblyRef       kAssemblyRef,
-    IMDInternalImport * pImport,                // = NULL
-    LPCUTF8             szWinRtTypeNamespace,   // = NULL
-    LPCUTF8             szWinRtTypeClassName)   // = NULL
+    IMDInternalImport * pImport)
 {
     CONTRACT(PEAssembly *)
     {

src/coreclr/src/vm/pefile.h

@@ -381,9 +381,7 @@ class PEFile
 
     PEAssembly * LoadAssembly(
             mdAssemblyRef       kAssemblyRef,
-            IMDInternalImport * pImport = NULL,
-            LPCUTF8             szWinRtTypeNamespace = NULL,
-            LPCUTF8             szWinRtTypeClassName = NULL);
+            IMDInternalImport * pImport = NULL);
 
     // ------------------------------------------------------------
     // Logging
@@ -720,20 +718,11 @@ class PEAssembly : public PEFile
     PTR_PEFile GetCreator()
     { LIMITED_METHOD_CONTRACT; return m_creator; }
 
-    // Returns TRUE if the assembly is .winmd file (WinRT assembly)
-    bool IsWindowsRuntime();
-
-    // Used to determine if this assembly has an identity that may be used for
-    // binding purposes. Currently this is true for standard .NET assemblies
-    // and false for WinRT assemblies (where assemblies are identified by their
-    // member types).
-    bool HasBindableIdentity();
-
     // Indicates if the assembly can be cached in a binding cache such as AssemblySpecBindingCache.
     inline bool CanUseWithBindingCache()
     {
         STATIC_CONTRACT_WRAPPER;
-        return (HasBindableIdentity());
+        return true;
     }
 };
 

src/coreclr/src/vm/pefile.inl

@@ -1445,34 +1445,4 @@ inline PEFile* PEFile::Dummy()
 {
     return (PEFile*)(-1);
 }
-
-inline bool PEAssembly::HasBindableIdentity()
-{
-    CONTRACTL
-    {
-        INSTANCE_CHECK;
-        if (FORBIDGC_LOADER_USE_ENABLED()) NOTHROW; else THROWS;
-        if (FORBIDGC_LOADER_USE_ENABLED()) GC_NOTRIGGER; else GC_TRIGGERS;
-        if (FORBIDGC_LOADER_USE_ENABLED()) FORBID_FAULT; else { INJECT_FAULT(COMPlusThrowOM()); }
-        MODE_ANY;
-        SUPPORTS_DAC;
-    }
-    CONTRACTL_END
-
-    return !IsAfContentType_WindowsRuntime(GetFlags());
-}
-
-inline bool PEAssembly::IsWindowsRuntime()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    return IsAfContentType_WindowsRuntime(GetFlags());
-}
-
 #endif  // PEFILE_INL_