Make RuntimeType sealed and deleted support for introspection only loads (#19427)

- Sealed Runtime makes `is RuntimeType` and similar checks faster. These checks are fairly common in reflection.
- Delete support for introspection only loads from the runtime. We do not plan to use in .NET Core. The support for introspection loads inherited from RuntimeType and thus it is incompatible with sealed RuntimeType.

55 files changed, 167 insertions, 749 deletions

diff --git a/src/vm/appdomain.cpp b/src/vm/appdomain.cpp
index 3ca7ec7e24..47aeb103eb 100644
--- a/src/vm/appdomain.cpp
+++ b/src/vm/appdomain.cpp
@@ -1039,7 +1039,7 @@ void AppDomain::DeleteNativeCodeRanges()
         return;
 
     // Shutdown assemblies
-    AssemblyIterator i = IterateAssembliesEx( (AssemblyIterationFlags)(kIncludeLoaded | kIncludeLoading | kIncludeExecution | kIncludeIntrospection | kIncludeFailedToLoad) );
+    AssemblyIterator i = IterateAssembliesEx( (AssemblyIterationFlags)(kIncludeLoaded | kIncludeLoading | kIncludeExecution | kIncludeFailedToLoad) );
     CollectibleAssemblyHolder<DomainAssembly *> pDomainAssembly;
 
     while (i.Next(pDomainAssembly.This()))
@@ -1071,7 +1071,7 @@ void AppDomain::ShutdownAssemblies()
 
     // Stage 1: call code:Assembly::Terminate
     AssemblyIterator i = IterateAssembliesEx((AssemblyIterationFlags)(
-        kIncludeLoaded | kIncludeLoading | kIncludeExecution | kIncludeIntrospection | kIncludeFailedToLoad | kIncludeCollected));
+        kIncludeLoaded | kIncludeLoading | kIncludeExecution | kIncludeFailedToLoad | kIncludeCollected));
     DomainAssembly * pDomainAssembly = NULL;
 
     while (i.Next_UnsafeNoAddRef(&pDomainAssembly))
@@ -1086,7 +1086,7 @@ void AppDomain::ShutdownAssemblies()
     
     // Stage 2: Clear the list of assemblies
     i = IterateAssembliesEx((AssemblyIterationFlags)(
-        kIncludeLoaded | kIncludeLoading | kIncludeExecution | kIncludeIntrospection | kIncludeFailedToLoad | kIncludeCollected));
+        kIncludeLoaded | kIncludeLoading | kIncludeExecution | kIncludeFailedToLoad | kIncludeCollected));
     while (i.Next_UnsafeNoAddRef(&pDomainAssembly))
     {
         // We are in shutdown path, no one else can get to the list anymore
@@ -1207,7 +1207,7 @@ void AppDomain::ReleaseFiles()
 
     // Shutdown assemblies
     AssemblyIterator i = IterateAssembliesEx((AssemblyIterationFlags)(
-        kIncludeLoaded  | kIncludeExecution | kIncludeIntrospection | kIncludeFailedToLoad | kIncludeLoading));
+        kIncludeLoaded  | kIncludeExecution | kIncludeFailedToLoad | kIncludeLoading));
     CollectibleAssemblyHolder<DomainAssembly *> pAsm;
 
     while (i.Next(pAsm.This()))
@@ -4861,8 +4861,7 @@ BOOL AppDomain::ContainsAssembly(Assembly * assem)
 {
     WRAPPER_NO_CONTRACT;
     AssemblyIterator i = IterateAssembliesEx((AssemblyIterationFlags)(
-        kIncludeLoaded | 
-        (assem->IsIntrospectionOnly() ? kIncludeIntrospection : kIncludeExecution)));
+        kIncludeLoaded | kIncludeExecution));
     CollectibleAssemblyHolder<DomainAssembly *> pDomainAssembly;
 
     while (i.Next(pDomainAssembly.This()))
@@ -6163,7 +6162,7 @@ DomainAssembly * AppDomain::FindAssembly(PEAssembly * pFile, FindAssemblyOptions
     AssemblyIterator i = IterateAssembliesEx((AssemblyIterationFlags)(
         kIncludeLoaded | 
         (includeFailedToLoad ? kIncludeFailedToLoad : 0) |
-        (pFile->IsIntrospectionOnly() ? kIncludeIntrospection : kIncludeExecution)));
+        kIncludeExecution));
     CollectibleAssemblyHolder<DomainAssembly *> pDomainAssembly;
 
     while (i.Next(pDomainAssembly.This()))
@@ -6765,8 +6764,7 @@ AppDomain::BindHostedPrivAssembly(
     PEAssembly *       pParentAssembly,
     ICLRPrivAssembly * pPrivAssembly, 
     IAssemblyName *    pAssemblyName, 
-    PEAssembly **      ppAssembly, 
-    BOOL               fIsIntrospectionOnly) // = FALSE
+    PEAssembly **      ppAssembly)
 {
     STANDARD_VM_CONTRACT;
 
@@ -6824,7 +6822,7 @@ AppDomain::BindHostedPrivAssembly(
     _ASSERTE(pPEImageIL != nullptr);
     
     // Create a PEAssembly using the IL and NI images.
-    PEAssemblyHolder pPEAssembly = PEAssembly::Open(pParentAssembly, pPEImageIL, pPEImageNI, pPrivAssembly, fIsIntrospectionOnly);
+    PEAssemblyHolder pPEAssembly = PEAssembly::Open(pParentAssembly, pPEImageIL, pPEImageNI, pPrivAssembly);
 
 
     // Ask the binder to verify.
@@ -6840,7 +6838,6 @@ AppDomain::BindHostedPrivAssembly(
 PEAssembly * AppDomain::BindAssemblySpec(
     AssemblySpec *         pSpec, 
     BOOL                   fThrowOnFileNotFound, 
-    BOOL                   fRaisePrebindEvents, 
     StackCrawlMark *       pCallerStackMark, 
     BOOL                   fUseHostBinderIfAvailable)
 {
@@ -6959,7 +6956,7 @@ EndTry2:;
                         {
                             // IsSystem on the PEFile should be false, even for mscorlib satellites
                             result = PEAssembly::Open(&bindResult,
-                                                      FALSE, pSpec->IsIntrospectionOnly());
+                                                      FALSE);
                         }
                         fAddFileToCache = true;
                         
@@ -9853,7 +9850,6 @@ Assembly* AppDomain::RaiseResourceResolveEvent(DomainAssembly* pAssembly, LPCSTR
 Assembly * 
 AppDomain::RaiseAssemblyResolveEvent(
     AssemblySpec * pSpec, 
-    BOOL           fIntrospection, 
     BOOL           fPreBind)
 {
     CONTRACT(Assembly*)
@@ -9931,12 +9927,6 @@ AppDomain::RaiseAssemblyResolveEvent(
 
     if (pAssembly != NULL)
     {
-        if  ((!(pAssembly->IsIntrospectionOnly())) != (!fIntrospection))
-        {
-            // Cannot return an introspection assembly from an execution callback or vice-versa
-            COMPlusThrow(kFileLoadException, pAssembly->IsIntrospectionOnly() ? IDS_CLASSLOAD_ASSEMBLY_RESOLVE_RETURNED_INTROSPECTION : IDS_CLASSLOAD_ASSEMBLY_RESOLVE_RETURNED_EXECUTION);
-        }
-
         // Check that the public key token matches the one specified in the spec
         // MatchPublicKeys throws as appropriate
         pSpec->MatchPublicKeys(pAssembly);
@@ -10908,24 +10898,13 @@ AppDomain::AssemblyIterator::Next_Unlocked(
             }
         }
 
-        // Next, reject DomainAssemblies whose execution / introspection status is
+        // Next, reject DomainAssemblies whose execution status is
         // not to be included in the enumeration
         
-        if (pDomainAssembly->IsIntrospectionOnly())
+        // execution assembly
+        if (!(m_assemblyIterationFlags & kIncludeExecution))
         {
-            // introspection assembly
-            if (!(m_assemblyIterationFlags & kIncludeIntrospection))
-            {
-                continue; // reject
-            }
-        }
-        else
-        {
-            // execution assembly
-            if (!(m_assemblyIterationFlags & kIncludeExecution))
-            {
-                continue; // reject
-            }
+            continue; // reject
         }
 
         // Next, reject collectible assemblies
@@ -10996,7 +10975,7 @@ AppDomain::AssemblyIterator::Next_UnsafeNoAddRef(
     
     // Make sure we are iterating all assemblies (see the only caller code:AppDomain::ShutdownAssemblies)
     _ASSERTE(m_assemblyIterationFlags == 
-        (kIncludeLoaded | kIncludeLoading | kIncludeExecution | kIncludeIntrospection | kIncludeFailedToLoad | kIncludeCollected));
+        (kIncludeLoaded | kIncludeLoading | kIncludeExecution | kIncludeFailedToLoad | kIncludeCollected));
     // It also means that we do not exclude anything
     _ASSERTE((m_assemblyIterationFlags & kExcludeCollectible) == 0);
     
@@ -11402,7 +11381,7 @@ AppDomain::EnumMemoryRegions(CLRDataEnumMemoryFlags flags,
     }
 
     m_Assemblies.EnumMemoryRegions(flags);
-    AssemblyIterator assem = IterateAssembliesEx((AssemblyIterationFlags)(kIncludeLoaded | kIncludeExecution | kIncludeIntrospection));
+    AssemblyIterator assem = IterateAssembliesEx((AssemblyIterationFlags)(kIncludeLoaded | kIncludeExecution));
     CollectibleAssemblyHolder<DomainAssembly *> pDomainAssembly;
     
     while (assem.Next(pDomainAssembly.This()))
diff --git a/src/vm/appdomain.hpp b/src/vm/appdomain.hpp
index dabe46bc38..4990f75f33 100644
--- a/src/vm/appdomain.hpp
+++ b/src/vm/appdomain.hpp
@@ -1628,7 +1628,7 @@ typedef Wrapper <ADUnloadSink*,DoNothing,ADUnloadSink__Release,NULL> ADUnloadSin
 //
 // The flags can be combined so if you want all loaded assemblies, you must specify:
 //
-///     kIncludeLoaded|kIncludeExecution|kIncludeIntrospection
+///     kIncludeLoaded|kIncludeExecution
 
 enum AssemblyIterationFlags
 {
@@ -1643,7 +1643,6 @@ enum AssemblyIterationFlags
 
     // Execution / introspection flags
     kIncludeExecution     = 0x00000004, // include assemblies that are loaded for execution only
-    kIncludeIntrospection = 0x00000008, // include assemblies that are loaded for introspection only
     
     kIncludeFailedToLoad  = 0x00000010, // include assemblies that failed to load 
 
@@ -2484,7 +2483,6 @@ public:
     virtual PEAssembly * BindAssemblySpec(
         AssemblySpec *pSpec,
         BOOL fThrowOnFileNotFound,
-        BOOL fRaisePrebindEvents,
         StackCrawlMark *pCallerStackMark = NULL,
         BOOL fUseHostBinderIfAvailable = TRUE) DAC_EMPTY_RET(NULL);
 
@@ -2498,8 +2496,7 @@ public:
         PEAssembly *       pParentPEAssembly,
         ICLRPrivAssembly * pPrivAssembly, 
         IAssemblyName *    pAssemblyName, 
-        PEAssembly **      ppAssembly, 
-        BOOL               fIsIntrospectionOnly = FALSE) DAC_EMPTY_RET(S_OK);
+        PEAssembly **      ppAssembly) DAC_EMPTY_RET(S_OK);
 
 
     PEAssembly *TryResolveAssembly(AssemblySpec *pSpec, BOOL fPreBind);
@@ -3180,7 +3177,7 @@ public:
     static void RaiseExitProcessEvent();
     Assembly* RaiseResourceResolveEvent(DomainAssembly* pAssembly, LPCSTR szName);
     DomainAssembly* RaiseTypeResolveEventThrowing(DomainAssembly* pAssembly, LPCSTR szName, ASSEMBLYREF *pResultingAssemblyRef);
-    Assembly* RaiseAssemblyResolveEvent(AssemblySpec *pSpec, BOOL fIntrospection, BOOL fPreBind);
+    Assembly* RaiseAssemblyResolveEvent(AssemblySpec *pSpec, BOOL fPreBind);
 
 private:
     CrstExplicitInit    m_ReflectionCrst;
diff --git a/src/vm/appdomainnative.cpp b/src/vm/appdomainnative.cpp
index bfe07b3d35..713856f1d8 100644
--- a/src/vm/appdomainnative.cpp
+++ b/src/vm/appdomainnative.cpp
@@ -261,8 +261,7 @@ FCIMPL2(Object*, AppDomainNative::GetAssemblies, AppDomainBaseObject* refThisUNS
         //  to the array.  Quit when the array is full, in case assemblies have been
         //  loaded into this appdomain, on another thread.
         AppDomain::AssemblyIterator i = pApp->IterateAssembliesEx((AssemblyIterationFlags)(
-            kIncludeLoaded | 
-            (forIntrospection ? kIncludeIntrospection : kIncludeExecution)));
+            kIncludeLoaded | kIncludeExecution));
         CollectibleAssemblyHolder<DomainAssembly *> pDomainAssembly;
         
         while (i.Next(pDomainAssembly.This()) && (numAssemblies < nArrayElems))
@@ -448,8 +447,7 @@ FCIMPL2(StringObject*, AppDomainNative::nApplyPolicy, AppDomainBaseObject* refTh
     AssemblySpec spec;
     spec.InitializeSpec(&(pThread->m_MarshalAlloc), 
                         &gc.assemblyName,
-                        FALSE, /*fIsStringized*/ 
-                        FALSE /*fForIntrospection*/
+                        FALSE /*fIsStringized*/
                        );
 
     StackSString sDisplayName;
diff --git a/src/vm/assembly.cpp b/src/vm/assembly.cpp
index 6b2c3b8a15..e5e70ad91c 100644
--- a/src/vm/assembly.cpp
+++ b/src/vm/assembly.cpp
@@ -651,7 +651,7 @@ Assembly *Assembly::CreateDynamic(AppDomain *pDomain, CreateDynamicAssemblyArgs
         IfFailThrow(pAssemblyEmit->DefineAssembly(publicKey, publicKey.GetSize(), ulHashAlgId,
                                                    name, &assemData, dwFlags,
                                                    &ma));
-        pFile = PEAssembly::Create(pCallerAssembly->GetManifestFile(), pAssemblyEmit, args->access & ASSEMBLY_ACCESS_REFLECTION_ONLY);
+        pFile = PEAssembly::Create(pCallerAssembly->GetManifestFile(), pAssemblyEmit);
 
         // Dynamically created modules (aka RefEmit assemblies) do not have a LoadContext associated with them since they are not bound
         // using an actual binder. As a result, we will assume the same binding/loadcontext information for the dynamic assembly as its
@@ -878,12 +878,6 @@ DomainAssembly *Assembly::FindDomainAssembly(AppDomain *pDomain)
     RETURN GetManifestModule()->FindDomainAssembly(pDomain);
 }
 
-BOOL Assembly::IsIntrospectionOnly()
-{
-    WRAPPER_NO_CONTRACT;
-    return m_pManifestFile->IsIntrospectionOnly();
-}
-
 PTR_LoaderHeap Assembly::GetLowFrequencyHeap()
 {
     WRAPPER_NO_CONTRACT;
diff --git a/src/vm/assembly.hpp b/src/vm/assembly.hpp
index fdb885494c..7a25d03999 100644
--- a/src/vm/assembly.hpp
+++ b/src/vm/assembly.hpp
@@ -53,7 +53,6 @@ class FriendAssemblyDescriptor;
 // Bits in m_dwDynamicAssemblyAccess (see System.Reflection.Emit.AssemblyBuilderAccess.cs)
 #define ASSEMBLY_ACCESS_RUN     0x01
 #define ASSEMBLY_ACCESS_SAVE    0x02
-#define ASSEMBLY_ACCESS_REFLECTION_ONLY    0x04
 #define ASSEMBLY_ACCESS_COLLECT 0x8
 
 struct CreateDynamicAssemblyArgsGC
@@ -221,12 +220,6 @@ public:
     void SetParent(BaseDomain* pParent);
 
     //-----------------------------------------------------------------------------------------
-    // If true, this assembly is loaded only for introspection. We can load modules, types, etc,
-    // but no code execution or object instantiation is permitted.
-    //-----------------------------------------------------------------------------------------
-    BOOL IsIntrospectionOnly();
-
-    //-----------------------------------------------------------------------------------------
     // EnsureActive ensures that the assembly is properly prepped in the current app domain
     // for active uses like code execution, static field access, and instance allocation
     //-----------------------------------------------------------------------------------------
@@ -323,7 +316,7 @@ public:
     BOOL CanSkipPolicyResolution()
     {
         WRAPPER_NO_CONTRACT;
-        return IsSystem() || IsIntrospectionOnly() || (m_isDynamic && !(m_dwDynamicAssemblyAccess & ASSEMBLY_ACCESS_RUN));
+        return IsSystem() || (m_isDynamic && !(m_dwDynamicAssemblyAccess & ASSEMBLY_ACCESS_RUN));
     }
 
     PTR_LoaderHeap GetLowFrequencyHeap();
diff --git a/src/vm/assemblyname.cpp b/src/vm/assemblyname.cpp
index 4fd6e20ee8..090365f2d6 100644
--- a/src/vm/assemblyname.cpp
+++ b/src/vm/assemblyname.cpp
@@ -69,7 +69,7 @@ FCIMPL1(Object*, AssemblyNameNative::GetFileInformation, StringObject* filenameU
         pImage->VerifyIsAssembly();
 
     AssemblySpec spec;
-    spec.InitializeSpec(TokenFromRid(mdtAssembly,1),pImage->GetMDImport(),NULL,TRUE);
+    spec.InitializeSpec(TokenFromRid(mdtAssembly,1),pImage->GetMDImport(),NULL);
     spec.AssemblyNameInit(&gc.result, pImage);
     
     HELPER_METHOD_FRAME_END();
@@ -93,7 +93,7 @@ FCIMPL1(Object*, AssemblyNameNative::ToString, Object* refThisUNSAFE)
     CheckPointHolder cph(pThread->m_MarshalAlloc.GetCheckpoint()); //hold checkpoint for autorelease
 
     AssemblySpec spec;
-    spec.InitializeSpec(&(pThread->m_MarshalAlloc), (ASSEMBLYNAMEREF*) &pThis, FALSE, FALSE); 
+    spec.InitializeSpec(&(pThread->m_MarshalAlloc), (ASSEMBLYNAMEREF*) &pThis, FALSE); 
 
     StackSString name;
     spec.GetFileOrDisplayName(ASM_DISPLAYF_VERSION |
@@ -168,7 +168,7 @@ FCIMPL3(void, AssemblyNameNative::Init, Object * refThisUNSAFE, OBJECTREF * pAss
     CheckPointHolder cph(pThread->m_MarshalAlloc.GetCheckpoint()); //hold checkpoint for autorelease
 
     AssemblySpec spec;
-    hr = spec.InitializeSpec(&(pThread->m_MarshalAlloc), (ASSEMBLYNAMEREF *) &pThis, TRUE, FALSE); 
+    hr = spec.InitializeSpec(&(pThread->m_MarshalAlloc), (ASSEMBLYNAMEREF *) &pThis, TRUE); 
 
     if (SUCCEEDED(hr))
     {
@@ -176,7 +176,7 @@ FCIMPL3(void, AssemblyNameNative::Init, Object * refThisUNSAFE, OBJECTREF * pAss
     }
     else if ((hr == FUSION_E_INVALID_NAME) && fRaiseResolveEvent)
     {
-        Assembly * pAssembly = GetAppDomain()->RaiseAssemblyResolveEvent(&spec, FALSE, FALSE);
+        Assembly * pAssembly = GetAppDomain()->RaiseAssemblyResolveEvent(&spec, FALSE);
 
         if (pAssembly == NULL)
         {
diff --git a/src/vm/assemblynative.cpp b/src/vm/assemblynative.cpp
index b6650709d0..830cadffae 100644
--- a/src/vm/assemblynative.cpp
+++ b/src/vm/assemblynative.cpp
@@ -107,7 +107,6 @@ FCIMPL7(Object*, AssemblyNative::Load, AssemblyNameBaseObject* assemblyNameUNSAF
     AssemblySpec spec;
     spec.InitializeSpec(&(pThread->m_MarshalAlloc), 
                         &gc.assemblyName,
-                        FALSE,
                         FALSE);
     
     if (!spec.HasUniqueIdentity())
@@ -146,7 +145,7 @@ FCIMPL7(Object*, AssemblyNative::Load, AssemblyNameBaseObject* assemblyNameUNSAF
     
     {
         GCX_PREEMP();
-        pAssembly = spec.LoadAssembly(FILE_LOADED, fThrowOnFileNotFound, FALSE /*fRaisePrebindEvents*/, stackMark);
+        pAssembly = spec.LoadAssembly(FILE_LOADED, fThrowOnFileNotFound, stackMark);
     }
 
     if (pAssembly != NULL)
@@ -239,7 +238,7 @@ Assembly* AssemblyNative::LoadFromPEImage(ICLRPrivBinder* pBinderContext, PEImag
     BINDER_SPACE::Assembly* assem;
     assem = BINDER_SPACE::GetAssemblyFromPrivAssemblyFast(pAssembly);
     
-    PEAssemblyHolder pPEAssembly(PEAssembly::Open(pParentAssembly, assem->GetPEImage(), assem->GetNativePEImage(), pAssembly, FALSE));
+    PEAssemblyHolder pPEAssembly(PEAssembly::Open(pParentAssembly, assem->GetPEImage(), assem->GetNativePEImage(), pAssembly));
 
     DomainAssembly *pDomainAssembly = pCurDomain->LoadDomainAssembly(&spec, pPEAssembly, FILE_LOADED);
     RETURN pDomainAssembly->GetAssembly();
@@ -416,7 +415,7 @@ void QCALLTYPE AssemblyNative::GetType(QCall::AssemblyHandle pAssembly, LPCWSTR
     BOOL prohibitAsmQualifiedName = TRUE;
 
     // Load the class from this assembly (fail if it is in a different one).
-    retTypeHandle = TypeName::GetTypeManaged(wszName, pAssembly, bThrowOnError, bIgnoreCase, pAssembly->IsIntrospectionOnly(), prohibitAsmQualifiedName, NULL, FALSE, (OBJECTREF*)keepAlive.m_ppObject);
+    retTypeHandle = TypeName::GetTypeManaged(wszName, pAssembly, bThrowOnError, bIgnoreCase, prohibitAsmQualifiedName, NULL, FALSE, (OBJECTREF*)keepAlive.m_ppObject);
 
     if (!retTypeHandle.IsNull())
     {
diff --git a/src/vm/assemblyspec.cpp b/src/vm/assemblyspec.cpp
index 8d3f76f2b9..f274c13c61 100644
--- a/src/vm/assemblyspec.cpp
+++ b/src/vm/assemblyspec.cpp
@@ -186,7 +186,6 @@ BOOL AssemblySpec::IsValidAssemblyName()
 HRESULT AssemblySpec::InitializeSpecInternal(mdToken kAssemblyToken,
                                   IMDInternalImport *pImport,
                                   DomainAssembly *pStaticParent,
-                                  BOOL fIntrospectionOnly, 
                                   BOOL fAllowAllocation)
 {
     CONTRACTL
@@ -199,7 +198,6 @@ HRESULT AssemblySpec::InitializeSpecInternal(mdToken kAssemblyToken,
         PRECONDITION(pImport->IsValidToken(kAssemblyToken));
         PRECONDITION(TypeFromToken(kAssemblyToken) == mdtAssembly
                      || TypeFromToken(kAssemblyToken) == mdtAssemblyRef);
-        PRECONDITION(pStaticParent == NULL || !(pStaticParent->IsIntrospectionOnly() && !fIntrospectionOnly));   //Something's wrong if an introspection assembly loads an assembly for execution.
     }
     CONTRACTL_END;
     
@@ -207,16 +205,6 @@ HRESULT AssemblySpec::InitializeSpecInternal(mdToken kAssemblyToken,
     
     EX_TRY
     {
-        // We also did this check as a precondition as we should have prevented this structurally - but just 
-        // in case, make sure retail stops us from proceeding further.
-        if (pStaticParent != NULL && pStaticParent->IsIntrospectionOnly() && !fIntrospectionOnly)
-        {
-            EEPOLICY_HANDLE_FATAL_ERROR(COR_E_EXECUTIONENGINE);
-        }
-        
-        // Normalize this boolean as it tends to be used for comparisons
-        m_fIntrospectionOnly = !!fIntrospectionOnly;
-
         IfFailThrow(BaseAssemblySpec::Init(kAssemblyToken,pImport));
 
         if (IsContentType_WindowsRuntime())
@@ -268,7 +256,7 @@ void AssemblySpec::InitializeSpec(PEAssembly * pFile)
     mdAssembly a;
     IfFailThrow(pImport->GetAssemblyFromScope(&a));
 
-    InitializeSpec(a, pImport, NULL, pFile->IsIntrospectionOnly());
+    InitializeSpec(a, pImport, NULL);
     
 #ifdef FEATURE_COMINTEROP
     if (IsContentType_WindowsRuntime())
@@ -303,7 +291,7 @@ void AssemblySpec::InitializeSpec(PEAssembly * pFile)
 
 // This uses thread storage to allocate space. Please use Checkpoint and release it.
 HRESULT AssemblySpec::InitializeSpec(StackingAllocator* alloc, ASSEMBLYNAMEREF* pName, 
-                                  BOOL fParse /*=TRUE*/, BOOL fIntrospectionOnly /*=FALSE*/)
+                                  BOOL fParse /*=TRUE*/)
 {
     CONTRACTL
     {
@@ -453,9 +441,6 @@ HRESULT AssemblySpec::InitializeSpec(StackingAllocator* alloc, ASSEMBLYNAMEREF*
                           (*pName)->GetHashForControl()->GetNumComponents(), 
                           (*pName)->GetHashAlgorithmForControl());
 
-    // Normalize this boolean as it tends to be used for comparisons
-    m_fIntrospectionOnly = !!fIntrospectionOnly;
-
     // Extract embedded WinRT name, if present.
     ParseEncodedName();
 
@@ -755,7 +740,7 @@ PEAssembly *AssemblySpec::ResolveAssemblyFile(AppDomain *pDomain, BOOL fPreBind)
     if (GetName() == NULL)
         RETURN NULL;
 
-    Assembly *pAssembly = pDomain->RaiseAssemblyResolveEvent(this, IsIntrospectionOnly(), fPreBind);
+    Assembly *pAssembly = pDomain->RaiseAssemblyResolveEvent(this, fPreBind);
 
     if (pAssembly != NULL) {
         PEAssembly *pFile = pAssembly->GetManifestFile();
@@ -768,7 +753,7 @@ PEAssembly *AssemblySpec::ResolveAssemblyFile(AppDomain *pDomain, BOOL fPreBind)
 }
 
 
-Assembly *AssemblySpec::LoadAssembly(FileLoadLevel targetLevel, BOOL fThrowOnFileNotFound, BOOL fRaisePrebindEvents, StackCrawlMark *pCallerStackMark)
+Assembly *AssemblySpec::LoadAssembly(FileLoadLevel targetLevel, BOOL fThrowOnFileNotFound, StackCrawlMark *pCallerStackMark)
 {
     CONTRACTL
     {
@@ -778,7 +763,7 @@ Assembly *AssemblySpec::LoadAssembly(FileLoadLevel targetLevel, BOOL fThrowOnFil
     }
     CONTRACTL_END;
  
-    DomainAssembly * pDomainAssembly = LoadDomainAssembly(targetLevel, fThrowOnFileNotFound, fRaisePrebindEvents, pCallerStackMark);
+    DomainAssembly * pDomainAssembly = LoadDomainAssembly(targetLevel, fThrowOnFileNotFound, pCallerStackMark);
     if (pDomainAssembly == NULL) {
         _ASSERTE(!fThrowOnFileNotFound);
         return NULL;
@@ -907,7 +892,6 @@ ICLRPrivBinder* AssemblySpec::GetBindingContextFromParentAssembly(AppDomain *pDo
 
 DomainAssembly *AssemblySpec::LoadDomainAssembly(FileLoadLevel targetLevel,
                                                  BOOL fThrowOnFileNotFound,
-                                                 BOOL fRaisePrebindEvents,
                                                  StackCrawlMark *pCallerStackMark)
 {
     CONTRACT(DomainAssembly *)
@@ -960,7 +944,7 @@ DomainAssembly *AssemblySpec::LoadDomainAssembly(FileLoadLevel targetLevel,
     }
 
 
-    PEAssemblyHolder pFile(pDomain->BindAssemblySpec(this, fThrowOnFileNotFound, fRaisePrebindEvents, pCallerStackMark));
+    PEAssemblyHolder pFile(pDomain->BindAssemblySpec(this, fThrowOnFileNotFound, pCallerStackMark));
     if (pFile == NULL)
         RETURN NULL;
 
@@ -1785,11 +1769,7 @@ BOOL AssemblySpecBindingCache::CompareSpecs(UPTR u1, UPTR u2)
     AssemblySpec *a1 = (AssemblySpec *) (u1 << 1);
     AssemblySpec *a2 = (AssemblySpec *) u2;
 
-
-    if ((!a1->CompareEx(a2)) ||
-        (a1->IsIntrospectionOnly() != a2->IsIntrospectionOnly()))
-        return FALSE;
-    return TRUE;  
+    return a1->CompareEx(a2);
 }
 
 
@@ -1802,13 +1782,7 @@ BOOL DomainAssemblyCache::CompareBindingSpec(UPTR spec1, UPTR spec2)
     AssemblySpec* pSpec1 = (AssemblySpec*) (spec1 << 1);
     AssemblyEntry* pEntry2 = (AssemblyEntry*) spec2;
 
-
-
-    if ((!pSpec1->CompareEx(&pEntry2->spec)) ||
-        (pSpec1->IsIntrospectionOnly() != pEntry2->spec.IsIntrospectionOnly()))
-        return FALSE;
-
-    return TRUE;
+    return pSpec1->CompareEx(&pEntry2->spec);
 }
 
 
diff --git a/src/vm/assemblyspec.hpp b/src/vm/assemblyspec.hpp
index 2415aea738..6db0d1ac8f 100644
--- a/src/vm/assemblyspec.hpp
+++ b/src/vm/assemblyspec.hpp
@@ -50,7 +50,6 @@ class AssemblySpec  : public BaseAssemblySpec
     HRESULT InitializeSpecInternal(mdToken kAssemblyRefOrDef, 
                                    IMDInternalImport *pImport, 
                                    DomainAssembly *pStaticParent,
-                                   BOOL fIntrospectionOnly,
                                    BOOL fAllowAllocation);
 
     // InitializeSpecInternal should be used very carefully so it's made private.
@@ -97,8 +96,7 @@ class AssemblySpec  : public BaseAssemblySpec
 
     void InitializeSpec(mdToken kAssemblyRefOrDef, 
                         IMDInternalImport *pImport, 
-                        DomainAssembly *pStaticParent = NULL,
-                        BOOL fIntrospectionOnly = FALSE)
+                        DomainAssembly *pStaticParent = NULL)
     {
         CONTRACTL
         {
@@ -108,7 +106,7 @@ class AssemblySpec  : public BaseAssemblySpec
             MODE_ANY;
         }
         CONTRACTL_END;
-        HRESULT hr=InitializeSpecInternal(kAssemblyRefOrDef, pImport,pStaticParent,fIntrospectionOnly,TRUE);
+        HRESULT hr=InitializeSpecInternal(kAssemblyRefOrDef, pImport,pStaticParent,TRUE);
         if(FAILED(hr))
             EEFileLoadException::Throw(this,hr);
     };
@@ -117,8 +115,7 @@ class AssemblySpec  : public BaseAssemblySpec
     void InitializeSpec(PEAssembly *pFile);
     HRESULT InitializeSpec(StackingAllocator* alloc,
                         ASSEMBLYNAMEREF* pName,
-                        BOOL fParse = TRUE,
-                        BOOL fIntrospectionOnly = FALSE);
+                        BOOL fParse = TRUE);
 
     void AssemblyNameInit(ASSEMBLYNAMEREF* pName, PEImage* pImageInfo); //[in,out], [in]
 
@@ -185,7 +182,6 @@ class AssemblySpec  : public BaseAssemblySpec
 
         BaseAssemblySpec::CopyFrom(pSource);
 
-        SetIntrospectionOnly(pSource->IsIntrospectionOnly());
         SetParentAssembly(pSource->GetParentAssembly());
 
         // Copy the details of the fallback load context binder
@@ -225,11 +221,9 @@ class AssemblySpec  : public BaseAssemblySpec
 
     Assembly *LoadAssembly(FileLoadLevel targetLevel, 
                            BOOL fThrowOnFileNotFound = TRUE,
-                           BOOL fRaisePrebindEvents = TRUE,
                            StackCrawlMark *pCallerStackMark = NULL);
     DomainAssembly *LoadDomainAssembly(FileLoadLevel targetLevel,
                                        BOOL fThrowOnFileNotFound = TRUE,
-                                       BOOL fRaisePrebindEvents = TRUE,
                                        StackCrawlMark *pCallerStackMark = NULL);
 
     //****************************************************************************************
diff --git a/src/vm/baseassemblyspec.h b/src/vm/baseassemblyspec.h
index 9381157f7a..4fe752a2ff 100644
--- a/src/vm/baseassemblyspec.h
+++ b/src/vm/baseassemblyspec.h
@@ -31,7 +31,6 @@ protected:
     LPCSTR                      m_szWinRtTypeClassName;
     ICLRPrivBinder             *m_pHostBinder;
     int                         m_ownedFlags;
-    BOOL                        m_fIntrospectionOnly;
     ICLRPrivBinder             *m_pBindingContext;
 
 public:
@@ -142,22 +141,6 @@ public:
         BOOL fIncludeCodeBase = TRUE, /* Used by fusion only */
         BOOL fMustBeBindable = FALSE) const;
 
-
-    BOOL IsIntrospectionOnly()
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        // Important to ensure we return a normalized boolean (the introspection fields
-        // of different AssemblySpecs can be compared.)
-        return !!m_fIntrospectionOnly;
-    }
-
-    VOID SetIntrospectionOnly(BOOL fIntrospectionOnly)
-    {
-        LIMITED_METHOD_CONTRACT;
-        m_fIntrospectionOnly = !!fIntrospectionOnly;
-    }
-
     inline BOOL IsContentType_WindowsRuntime() const
     {
         LIMITED_METHOD_CONTRACT;
diff --git a/src/vm/ceeload.cpp b/src/vm/ceeload.cpp
index 5c4df90a80..23fa8f6e8e 100644
--- a/src/vm/ceeload.cpp
+++ b/src/vm/ceeload.cpp
@@ -4232,12 +4232,6 @@ BOOL Module::IsVisibleToDebugger()
         return FALSE;
     }
 
-    if (IsIntrospectionOnly())
-    {
-        return FALSE;
-    }
-
-
     // If for whatever other reason, we can't run it, then don't notify the debugger about it.
     Assembly * pAssembly = GetAssembly();
     if (!pAssembly->HasRunAccess())
@@ -5262,12 +5256,6 @@ Module::GetAssemblyIfLoaded(
 #ifdef FEATURE_COMINTEROP
             if (szWinRtNamespace != NULL)
             {
-                if (IsIntrospectionOnly())
-                {   // We do not have to implement this method for ReflectionOnly WinRT type requests
-                    // ReflectionOnly WinRT types will never have instances on GC heap to be inspected by stackwalking or by debugger
-                    break;
-                }
-                
                 _ASSERTE(szWinRtClassName != NULL);
                 
                 CLRPrivBinderWinRT * pWinRtBinder = pAppDomainExamine->GetWinRtBinder();
@@ -5331,7 +5319,6 @@ Module::GetAssemblyIfLoaded(
                 if (FAILED(spec.InitializeSpecInternal(kAssemblyRef, 
                                                        pMDImport, 
                                                        pCurAssemblyInExamineDomain,
-                                                       IsIntrospectionOnly(), 
                                                        FALSE /*fAllowAllocation*/)))
                 {
                     continue;
@@ -5392,8 +5379,6 @@ Module::GetAssemblyIfLoaded(
             // as the shared assembly context may have different binding rules as compared to the root context. At this time, we prefer to not fix this scenario until
             // there is customer need for a fix.
         }
-        else if (IsIntrospectionOnly())
-            eligibleForAdditionalChecks = FALSE;
 
         AssemblySpec specSearchAssemblyRef;
 
@@ -5405,7 +5390,6 @@ Module::GetAssemblyIfLoaded(
             if (FAILED(specSearchAssemblyRef.InitializeSpecInternal(kAssemblyRef, 
                                                     pMDImport, 
                                                     NULL,
-                                                    FALSE, 
                                                     FALSE /*fAllowAllocation*/)))
             {
                 eligibleForAdditionalChecks = FALSE; // If an assemblySpec can't be constructed then we're not going to succeed
@@ -5482,7 +5466,6 @@ Module::GetAssemblyIfLoaded(
                                 if (FAILED(specFoundAssemblyRef.InitializeSpecInternal(assemblyRef, 
                                                                         pImportFoundNativeImage, 
                                                                         NULL,
-                                                                        FALSE, 
                                                                         FALSE /*fAllowAllocation*/)))
                                 {
                                     continue; // If the spec cannot be loaded, it isn't the one we're looking for
@@ -5614,7 +5597,7 @@ DomainAssembly * Module::LoadAssembly(
                 szWinRtTypeNamespace, 
                 szWinRtTypeClassName);
         AssemblySpec spec;
-        spec.InitializeSpec(kAssemblyRef, GetMDImport(), GetDomainFile(GetAppDomain())->GetDomainAssembly(), IsIntrospectionOnly());
+        spec.InitializeSpec(kAssemblyRef, GetMDImport(), GetDomainFile(GetAppDomain())->GetDomainAssembly());
         // Set the binding context in the AssemblySpec if one is available. This can happen if the LoadAssembly ended up
         // invoking the custom AssemblyLoadContext implementation that returned a reference to an assembly bound to a different
         // AssemblyLoadContext implementation.
@@ -5633,7 +5616,6 @@ DomainAssembly * Module::LoadAssembly(
     if (pDomainAssembly != NULL)
     {
         _ASSERTE(
-            IsIntrospectionOnly() ||                        // GetAssemblyIfLoaded will not find introspection-only assemblies
             !fHasBindableIdentity ||                        // GetAssemblyIfLoaded will not find non-bindable assemblies
             pDomainAssembly->IsSystem() ||                  // GetAssemblyIfLoaded will not find mscorlib (see AppDomain::FindCachedFile)
             !pDomainAssembly->IsLoaded() ||                 // GetAssemblyIfLoaded will not find not-yet-loaded assemblies
@@ -13815,15 +13797,9 @@ LookupMapBase::ListEnumMemoryRegions(CLRDataEnumMemoryFlags flags)
 #endif // DACCESS_COMPILE
 
 
-// Optimization intended for Module::IsIntrospectionOnly and Module::EnsureActive only
+// Optimization intended for Module::EnsureActive only
 #include <optsmallperfcritical.h>
 
-BOOL Module::IsIntrospectionOnly()
-{
-    WRAPPER_NO_CONTRACT;
-    return GetAssembly()->IsIntrospectionOnly();
-}
-
 #ifndef DACCESS_COMPILE
 VOID Module::EnsureActive()
 {
diff --git a/src/vm/ceeload.h b/src/vm/ceeload.h
index 939d7294b5..4b1f234920 100644
--- a/src/vm/ceeload.h
+++ b/src/vm/ceeload.h
@@ -1901,8 +1901,6 @@ protected:
         return m_dwPersistedFlags.LoadWithoutBarrier() & LOW_LEVEL_SYSTEM_ASSEMBLY_BY_NAME;
     }
 
-    BOOL IsIntrospectionOnly();
-
 #ifndef DACCESS_COMPILE
     VOID EnsureActive();
     VOID EnsureAllocated();    
diff --git a/src/vm/clsload.cpp b/src/vm/clsload.cpp
index abf96d0425..24887a4d83 100644
--- a/src/vm/clsload.cpp
+++ b/src/vm/clsload.cpp
@@ -1034,8 +1034,7 @@ VOID ClassLoader::PopulateAvailableClassHashTable(Module* pModule,
     SString            ssFileName;
     StackScratchBuffer ssFileNameBuffer;
     
-    if (pModule->GetAssembly()->IsWinMD() && 
-        !pModule->IsIntrospectionOnly())
+    if (pModule->GetAssembly()->IsWinMD())
     {   // WinMD file in execution context (not ReflectionOnly context) - use its file name as WinRT namespace prefix 
         //  (Windows requirement)
         // Note: Reflection can work on 'unfinished' WinMD files where the types are in 'wrong' WinMD file (i.e. 
@@ -1562,11 +1561,6 @@ TypeHandle ClassLoader::TryFindDynLinkZapType(TypeKey *pKey)
     }
     CONTRACTL_END;
 
-    // For the introspection-only case, we can skip this step as introspection assemblies
-    // do not use NGEN images. 
-    if (pKey->IsIntrospectionOnly())
-        return TypeHandle();
-
     // Never use dyn link zap items during ngen time. We will independently decide later 
     // whether we want to store the item into ngen image or not.
     // Note that it is not good idea to make decisions based on the list of depencies here 
@@ -1636,7 +1630,6 @@ TypeHandle ClassLoader::TryFindDynLinkZapType(TypeKey *pKey)
 
         AppDomain * pDomain = pRequiredDomain->AsAppDomain();
         
-        _ASSERTE(!(pKey->IsIntrospectionOnly()));
         AppDomain::AssemblyIterator assemblyIterator = pDomain->IterateAssembliesEx(
             (AssemblyIterationFlags)(kIncludeLoaded | kIncludeExecution));
         CollectibleAssemblyHolder<DomainAssembly *> pDomainAssembly;
@@ -2820,63 +2813,60 @@ TypeHandle ClassLoader::LoadTypeDefThrowing(Module *pModule,
 
             if (pModule->IsReflection())
             {
-                //if (!(pModule->IsIntrospectionOnly()))
+                // Don't try to load types that are not in available table, when this
+                // is an in-memory module.  Raise the type-resolve event instead.
+                typeHnd = TypeHandle();
+
+                // Avoid infinite recursion
+                if (tokenNotToLoad != tdAllAssemblies)
                 {
-                    // Don't try to load types that are not in available table, when this
-                    // is an in-memory module.  Raise the type-resolve event instead.
-                    typeHnd = TypeHandle();
+                    AppDomain* pDomain = SystemDomain::GetCurrentDomain();
 
-                    // Avoid infinite recursion
-                    if (tokenNotToLoad != tdAllAssemblies)
+                    LPUTF8 pszFullName;
+                    LPCUTF8 className;
+                    LPCUTF8 nameSpace;
+                    if (FAILED(pInternalImport->GetNameOfTypeDef(typeDef, &className, &nameSpace)))
                     {
-                        AppDomain* pDomain = SystemDomain::GetCurrentDomain();
-
-                        LPUTF8 pszFullName;
-                        LPCUTF8 className;
-                        LPCUTF8 nameSpace;
-                        if (FAILED(pInternalImport->GetNameOfTypeDef(typeDef, &className, &nameSpace)))
-                        {
-                            LOG((LF_CLASSLOADER, LL_INFO10, "Bogus TypeDef record while loading: 0x%08x\n", typeDef));
-                            typeHnd = TypeHandle();
-                        }
-                        else
+                        LOG((LF_CLASSLOADER, LL_INFO10, "Bogus TypeDef record while loading: 0x%08x\n", typeDef));
+                        typeHnd = TypeHandle();
+                    }
+                    else
+                    {
+                        MAKE_FULL_PATH_ON_STACK_UTF8(pszFullName,
+                                                        nameSpace,
+                                                        className);
+                        GCX_COOP();
+                        ASSEMBLYREF asmRef = NULL;
+                        DomainAssembly *pDomainAssembly = NULL;
+                        GCPROTECT_BEGIN(asmRef);
+
+                        pDomainAssembly = pDomain->RaiseTypeResolveEventThrowing(
+                            pModule->GetAssembly()->GetDomainAssembly(), 
+                            pszFullName, &asmRef);
+
+                        if (asmRef != NULL)
                         {
-                            MAKE_FULL_PATH_ON_STACK_UTF8(pszFullName,
-                                                         nameSpace,
-                                                         className);
-                            GCX_COOP();
-                            ASSEMBLYREF asmRef = NULL;
-                            DomainAssembly *pDomainAssembly = NULL;
-                            GCPROTECT_BEGIN(asmRef);
-
-                            pDomainAssembly = pDomain->RaiseTypeResolveEventThrowing(
-                                pModule->GetAssembly()->GetDomainAssembly(), 
-                                pszFullName, &asmRef);
-
-                            if (asmRef != NULL)
+                            _ASSERTE(pDomainAssembly != NULL);
+                            if (pDomainAssembly->GetAssembly()->GetLoaderAllocator()->IsCollectible())
                             {
-                                _ASSERTE(pDomainAssembly != NULL);
-                                if (pDomainAssembly->GetAssembly()->GetLoaderAllocator()->IsCollectible())
+                                if (!pModule->GetLoaderAllocator()->IsCollectible())
                                 {
-                                    if (!pModule->GetLoaderAllocator()->IsCollectible())
-                                    {
-                                        LOG((LF_CLASSLOADER, LL_INFO10, "Bad result from TypeResolveEvent while loader TypeDef record: 0x%08x\n", typeDef));
-                                        COMPlusThrow(kNotSupportedException, W("NotSupported_CollectibleBoundNonCollectible"));
-                                    }
-
-                                    pModule->GetLoaderAllocator()->EnsureReference(pDomainAssembly->GetAssembly()->GetLoaderAllocator());
+                                    LOG((LF_CLASSLOADER, LL_INFO10, "Bad result from TypeResolveEvent while loader TypeDef record: 0x%08x\n", typeDef));
+                                    COMPlusThrow(kNotSupportedException, W("NotSupported_CollectibleBoundNonCollectible"));
                                 }
+
+                                pModule->GetLoaderAllocator()->EnsureReference(pDomainAssembly->GetAssembly()->GetLoaderAllocator());
                             }
-                            GCPROTECT_END();
-                            if (pDomainAssembly != NULL)
-                            {
-                                Assembly *pAssembly = pDomainAssembly->GetAssembly();
+                        }
+                        GCPROTECT_END();
+                        if (pDomainAssembly != NULL)
+                        {
+                            Assembly *pAssembly = pDomainAssembly->GetAssembly();
                                 
-                                NameHandle name(nameSpace, className);
-                                name.SetTypeToken(pModule, typeDef);
-                                name.SetTokenNotToLoad(tdAllAssemblies);
-                                typeHnd = pAssembly->GetLoader()->LoadTypeHandleThrowing(&name, level);
-                            }
+                            NameHandle name(nameSpace, className);
+                            name.SetTypeToken(pModule, typeDef);
+                            name.SetTokenNotToLoad(tdAllAssemblies);
+                            typeHnd = pAssembly->GetLoader()->LoadTypeHandleThrowing(&name, level);
                         }
                     }
                 }
diff --git a/src/vm/comcallablewrapper.cpp b/src/vm/comcallablewrapper.cpp
index 7b91668ace..4d116c157f 100644
--- a/src/vm/comcallablewrapper.cpp
+++ b/src/vm/comcallablewrapper.cpp
@@ -1602,9 +1602,6 @@ BOOL SimpleComCallWrapper::SupportsIReflect(MethodTable *pClass)
     if (pClass == g_pRuntimeTypeClass)
         return FALSE;
 
-    if (MscorlibBinder::IsClass(pClass, CLASS__CLASS_INTROSPECTION_ONLY))
-        return FALSE;
-
     if (MscorlibBinder::IsClass(pClass, CLASS__TYPE_BUILDER))
         return FALSE;
 
diff --git a/src/vm/commodule.cpp b/src/vm/commodule.cpp
index 9512468a6d..235b02a8ed 100644
--- a/src/vm/commodule.cpp
+++ b/src/vm/commodule.cpp
@@ -815,7 +815,7 @@ void QCALLTYPE COMModule::GetType(QCall::ModuleHandle pModule, LPCWSTR wszName,
     BOOL prohibitAsmQualifiedName = TRUE;
 
     // Load the class from this assembly (fail if it is in a different one).
-    retTypeHandle = TypeName::GetTypeManaged(wszName, pAssembly, bThrowOnError, bIgnoreCase, pAssembly->IsIntrospectionOnly(), prohibitAsmQualifiedName, NULL, FALSE, (OBJECTREF*)keepAlive.m_ppObject);
+    retTypeHandle = TypeName::GetTypeManaged(wszName, pAssembly, bThrowOnError, bIgnoreCase, prohibitAsmQualifiedName, NULL, FALSE, (OBJECTREF*)keepAlive.m_ppObject);
 
     // Verify that it's in 'this' module
     // But, if it's in a different assembly than expected, that's okay, because
diff --git a/src/vm/compile.cpp b/src/vm/compile.cpp
index 996f61fba2..d78ce62bd0 100644
--- a/src/vm/compile.cpp
+++ b/src/vm/compile.cpp
@@ -346,7 +346,7 @@ HRESULT CEECompileInfo::LoadAssemblyByPath(
 #endif // !_TARGET_64BIT_
         
         AssemblySpec spec;
-        spec.InitializeSpec(TokenFromRid(1, mdtAssembly), pImage->GetMDImport(), NULL, FALSE);
+        spec.InitializeSpec(TokenFromRid(1, mdtAssembly), pImage->GetMDImport(), NULL);
 
         if (spec.IsMscorlib())
         {
@@ -403,7 +403,7 @@ HRESULT CEECompileInfo::LoadAssemblyByPath(
                     // that IL assemblies will be available.
                     fExplicitBindToNativeImage
                     );
-                pAssemblyHolder = PEAssembly::Open(&bindResult,FALSE,FALSE);
+                pAssemblyHolder = PEAssembly::Open(&bindResult,FALSE);
             }
 
             // Now load assembly into domain.
@@ -477,7 +477,7 @@ HRESULT CEECompileInfo::LoadTypeRefWinRT(
                 LPCSTR pszname;
                 pAssemblyImport->GetNameOfTypeRef(ref, &psznamespace, &pszname);
                 AssemblySpec spec;
-                spec.InitializeSpec(tkResolutionScope, pAssemblyImport, NULL, FALSE);
+                spec.InitializeSpec(tkResolutionScope, pAssemblyImport, NULL);
                 spec.SetWindowsRuntimeType(psznamespace, pszname);
                 
                 _ASSERTE(spec.HasBindableIdentity());
@@ -7292,7 +7292,6 @@ void ReportMissingDependency(Exception * e)
 PEAssembly *CompilationDomain::BindAssemblySpec(
     AssemblySpec *pSpec,
     BOOL fThrowOnFileNotFound,
-    BOOL fRaisePrebindEvents,
     StackCrawlMark *pCallerStackMark,
     BOOL fUseHostBinderIfAvailable)
 {
@@ -7310,7 +7309,6 @@ PEAssembly *CompilationDomain::BindAssemblySpec(
         pFile = AppDomain::BindAssemblySpec(
             pSpec,
             fThrowOnFileNotFound,
-            fRaisePrebindEvents,
             pCallerStackMark,
             fUseHostBinderIfAvailable);
     }
diff --git a/src/vm/compile.h b/src/vm/compile.h
index fb664249c5..6ab3d6c715 100644
--- a/src/vm/compile.h
+++ b/src/vm/compile.h
@@ -791,7 +791,6 @@ class CompilationDomain : public AppDomain,
     PEAssembly *BindAssemblySpec(
         AssemblySpec *pSpec,
         BOOL fThrowOnFileNotFound,
-        BOOL fRaisePrebindEvents,
         StackCrawlMark *pCallerStackMark = NULL,
         BOOL fUseHostBinderIfAvailable = TRUE) DAC_EMPTY_RET(NULL);
 
diff --git a/src/vm/crossgencompile.cpp b/src/vm/crossgencompile.cpp
index 47894bfbdd..ce36eec1ab 100644
--- a/src/vm/crossgencompile.cpp
+++ b/src/vm/crossgencompile.cpp
@@ -385,7 +385,7 @@ void EEPolicy::HandleFatalError(UINT exitCode, UINT_PTR address, LPCWSTR pszMess
 
 //---------------------------------------------------------------------------------------
 
-Assembly * AppDomain::RaiseAssemblyResolveEvent(AssemblySpec * pSpec, BOOL fIntrospection, BOOL fPreBind)
+Assembly * AppDomain::RaiseAssemblyResolveEvent(AssemblySpec * pSpec, BOOL fPreBind)
 {
     return NULL;
 }
diff --git a/src/vm/dispatchinfo.cpp b/src/vm/dispatchinfo.cpp
index 4a21dfa04c..f7b3068428 100644
--- a/src/vm/dispatchinfo.cpp
+++ b/src/vm/dispatchinfo.cpp
@@ -3709,8 +3709,7 @@ OBJECTREF DispatchExInfo::GetReflectionObject()
     // we get the exposed class object and not the actual objectred contained in the
     // wrapper.
 
-    if (m_pMT == g_pRuntimeTypeClass ||
-        MscorlibBinder::IsClass(m_pMT, CLASS__CLASS_INTROSPECTION_ONLY))
+    if (m_pMT == g_pRuntimeTypeClass)
         return m_pMT->GetManagedClassObject();
     else
         return m_pSimpleWrapperOwner->GetObjectRef();
diff --git a/src/vm/domainfile.cpp b/src/vm/domainfile.cpp
index c8bbcf7241..314f165eea 100644
--- a/src/vm/domainfile.cpp
+++ b/src/vm/domainfile.cpp
@@ -409,12 +409,6 @@ DomainAssembly *DomainFile::GetDomainAssembly()
     return (DomainAssembly *) this;
 }
 
-BOOL DomainFile::IsIntrospectionOnly()
-{
-    WRAPPER_NO_CONTRACT;
-    return GetFile()->IsIntrospectionOnly();
-}
-
 // Return true iff the debugger should get notifications about this assembly.
 //
 // Notes:
@@ -431,7 +425,6 @@ BOOL DomainAssembly::IsVisibleToDebugger()
     SUPPORTS_DAC;
 
     // If you can't run an assembly, then don't send notifications to the debugger.
-    // This check includeds IsIntrospectionOnly().
     return ((GetAssembly() != NULL) ? GetAssembly()->HasRunAccess() : FALSE);
 }
 
@@ -1052,9 +1045,6 @@ void DomainFile::EagerFixups()
     WRAPPER_NO_CONTRACT;
 
 #ifdef FEATURE_PREJIT
-    if (IsIntrospectionOnly())
-        return; 
-    
     if (GetCurrentModule()->HasNativeImage())
     {
         GetCurrentModule()->RunEagerFixups();
@@ -1191,12 +1181,6 @@ void DomainFile::VerifyExecution()
     }
     CONTRACT_END;
 
-    if (GetModule()->IsIntrospectionOnly())
-    {
-        // Throw an exception
-        COMPlusThrow(kInvalidOperationException, IDS_EE_CODEEXECUTION_IN_INTROSPECTIVE_ASSEMBLY);
-    }
-
     if(GetFile()->PassiveDomainOnly())
     {
     // Remove path - location must be hidden for security purposes
diff --git a/src/vm/domainfile.h b/src/vm/domainfile.h
index 15811e2b3f..b163da87c6 100644
--- a/src/vm/domainfile.h
+++ b/src/vm/domainfile.h
@@ -260,8 +260,6 @@ class DomainFile
     // Other public APIs
     // ------------------------------------------------------------
 
-    BOOL IsIntrospectionOnly();
-
 #ifndef DACCESS_COMPILE
     BOOL Equals(DomainFile *pFile) { WRAPPER_NO_CONTRACT; return GetFile()->Equals(pFile->GetFile()); }
     BOOL Equals(PEFile *pFile) { WRAPPER_NO_CONTRACT; return GetFile()->Equals(pFile); }
diff --git a/src/vm/excep.cpp b/src/vm/excep.cpp
index 0c9e101542..5cd5e6c2e2 100644
--- a/src/vm/excep.cpp
+++ b/src/vm/excep.cpp
@@ -12920,7 +12920,6 @@ UINT GetResourceIDForFileLoadExceptionHR(HRESULT hr)
     case (HRESULT)IDS_INET_E_SECURITY_PROBLEM:
     case (HRESULT)IDS_EE_BAD_USER_PROFILE:
     case (HRESULT)IDS_EE_ALREADY_EXISTS:
-    case IDS_EE_REFLECTIONONLY_LOADFAILURE:
     case IDS_CLASSLOAD_32BITCLRLOADING64BITASSEMBLY:
        break;
 
diff --git a/src/vm/frameworkexceptionloader.cpp b/src/vm/frameworkexceptionloader.cpp
index 5885060676..442973686f 100644
--- a/src/vm/frameworkexceptionloader.cpp
+++ b/src/vm/frameworkexceptionloader.cpp
@@ -66,7 +66,7 @@ MethodTable* FrameworkExceptionLoader::GetException(RuntimeExceptionKind kind)
     // Loading will either succeed or throw a FileLoadException.  Catch & swallow that exception.
     EX_TRY
     {
-        pMT = TypeName::GetTypeFromAsmQualifiedName(assemblyQualifiedName.GetUnicode(), FALSE).GetMethodTable();
+        pMT = TypeName::GetTypeFromAsmQualifiedName(assemblyQualifiedName.GetUnicode()).GetMethodTable();
 
         // Since this type is from another assembly, we must ensure that assembly has been sufficiently loaded.
         pMT->EnsureActive();
diff --git a/src/vm/genmeth.cpp b/src/vm/genmeth.cpp
index 4c1ba8b93b..f142fb4ae6 100644
--- a/src/vm/genmeth.cpp
+++ b/src/vm/genmeth.cpp
@@ -375,8 +375,7 @@ InstantiatedMethodDesc::NewInstantiatedMethodDesc(MethodTable *pExactMT,
 
         // Next look in each ngen'ed image in turn
         AppDomain::AssemblyIterator assemblyIterator = GetAppDomain()->IterateAssembliesEx((AssemblyIterationFlags)(
-            kIncludeLoaded | 
-            (pExactMT->IsIntrospectionOnly() ? kIncludeIntrospection : kIncludeExecution)));
+            kIncludeLoaded | kIncludeExecution));
         CollectibleAssemblyHolder<DomainAssembly *> pDomainAssembly;
         while ((pNewMD == NULL) && assemblyIterator.Next(pDomainAssembly.This()))
         {
diff --git a/src/vm/interoputil.cpp b/src/vm/interoputil.cpp
index 09f7d88904..24afdf73fa 100644
--- a/src/vm/interoputil.cpp
+++ b/src/vm/interoputil.cpp
@@ -5255,7 +5255,7 @@ TypeHandle GetWinRTType(SString* ssTypeName, BOOL bThrowIfNotFound)
     SString ssAssemblyName(SString::Utf8Literal, "WindowsRuntimeAssemblyName, ContentType=WindowsRuntime");
     DomainAssembly *pAssembly = LoadDomainAssembly(&ssAssemblyName, NULL, 
                                                    NULL, 
-                                                   bThrowIfNotFound, FALSE, ssTypeName);
+                                                   bThrowIfNotFound, ssTypeName);
     if (pAssembly != NULL)
     {
         typeHandle = TypeName::GetTypeFromAssembly(*ssTypeName, pAssembly->GetAssembly(), bThrowIfNotFound);
@@ -5953,7 +5953,7 @@ MethodTable *WinRTInterfaceRedirector::GetWinRTTypeForRedirectedInterfaceIndex(W
         const NonMscorlibRedirectedInterfaceInfo *pInfo = &s_rNonMscorlibInterfaceInfos[id & ~NON_MSCORLIB_MARKER];
         SString assemblyQualifiedTypeName(SString::Utf8, pInfo->m_szWinRTInterfaceAssemblyQualifiedTypeName);
 
-        RETURN TypeName::GetTypeFromAsmQualifiedName(assemblyQualifiedTypeName.GetUnicode(), FALSE).GetMethodTable();
+        RETURN TypeName::GetTypeFromAsmQualifiedName(assemblyQualifiedTypeName.GetUnicode()).GetMethodTable();
     }
 }
 
@@ -5970,7 +5970,7 @@ MethodDesc *WinRTInterfaceRedirector::LoadMethodFromRedirectedAssembly(LPCUTF8 s
 
     SString assemblyQualifiedTypeName(SString::Utf8, szAssemblyQualifiedTypeName);
 
-    MethodTable *pMT = TypeName::GetTypeFromAsmQualifiedName(assemblyQualifiedTypeName.GetUnicode(), FALSE).GetMethodTable();
+    MethodTable *pMT = TypeName::GetTypeFromAsmQualifiedName(assemblyQualifiedTypeName.GetUnicode()).GetMethodTable();
     return MemberLoader::FindMethodByName(pMT, szMethodName);
 }
 
@@ -6239,13 +6239,13 @@ MethodTable *WinRTDelegateRedirector::GetWinRTTypeForRedirectedDelegateIndex(Win
     case WinMDAdapter::RedirectedTypeIndex_System_Collections_Specialized_NotifyCollectionChangedEventHandler:
     {
         SString assemblyQualifiedTypeName(SString::Utf8, NCCEHWINRT_ASM_QUAL_TYPE_NAME);
-        return TypeName::GetTypeFromAsmQualifiedName(assemblyQualifiedTypeName.GetUnicode(), FALSE).GetMethodTable();
+        return TypeName::GetTypeFromAsmQualifiedName(assemblyQualifiedTypeName.GetUnicode()).GetMethodTable();
     }
 
     case WinMDAdapter::RedirectedTypeIndex_System_ComponentModel_PropertyChangedEventHandler:
     {
         SString assemblyQualifiedTypeName(SString::Utf8, PCEHWINRT_ASM_QUAL_TYPE_NAME);
-        return TypeName::GetTypeFromAsmQualifiedName(assemblyQualifiedTypeName.GetUnicode(), FALSE).GetMethodTable();
+        return TypeName::GetTypeFromAsmQualifiedName(assemblyQualifiedTypeName.GetUnicode()).GetMethodTable();
     }
 
     default:
diff --git a/src/vm/marshalnative.cpp b/src/vm/marshalnative.cpp
index a552ef33f5..133cbf9069 100644
--- a/src/vm/marshalnative.cpp
+++ b/src/vm/marshalnative.cpp
@@ -974,8 +974,7 @@ FCIMPL1(ITypeInfo*, MarshalNative::GetITypeInfoForType, ReflectClassBaseObject*
         COMPlusThrowArgumentNull(W("t"));
         
     MethodTable *pRefMT = refClass->GetMethodTable();
-    if (pRefMT != g_pRuntimeTypeClass &&
-        pRefMT != MscorlibBinder::GetClass(CLASS__CLASS_INTROSPECTION_ONLY))
+    if (pRefMT != g_pRuntimeTypeClass)
         COMPlusThrowArgumentException(W("t"), W("Argument_MustBeRuntimeType"));
 
     TypeHandle th = refClass->GetType();
@@ -1533,8 +1532,7 @@ FCIMPL1(FC_BOOL_RET, MarshalNative::IsTypeVisibleFromCom, ReflectClassBaseObject
         COMPlusThrowArgumentNull(W("t"));
         
     MethodTable *pRefMT = refClass->GetMethodTable();
-    if (pRefMT != g_pRuntimeTypeClass && 
-        pRefMT != MscorlibBinder::GetClass(CLASS__CLASS_INTROSPECTION_ONLY))
+    if (pRefMT != g_pRuntimeTypeClass)
         COMPlusThrowArgumentException(W("t"), W("Argument_MustBeRuntimeType"));
 
     // Call the internal version of IsTypeVisibleFromCom.
@@ -1728,8 +1726,7 @@ FCIMPL2(void, MarshalNative::DoGenerateGuidForType, GUID * result, ReflectClassB
         COMPlusThrowArgumentNull(W("type"));
         
     MethodTable *pRefMT = refType->GetMethodTable();
-    if (pRefMT != g_pRuntimeTypeClass &&
-        pRefMT != MscorlibBinder::GetClass(CLASS__CLASS_INTROSPECTION_ONLY))
+    if (pRefMT != g_pRuntimeTypeClass)
         COMPlusThrowArgumentException(W("type"), W("Argument_MustBeRuntimeType"));
     if (result == NULL)
         COMPlusThrow(kArgumentNullException, W("ArgumentNull_GUID"));
@@ -1964,8 +1961,7 @@ FCIMPL1(int, MarshalNative::GetStartComSlot, ReflectClassBaseObject* tUNSAFE)
         COMPlusThrow(kArgumentNullException, W("ArgumentNull_Generic"));
     
     MethodTable *pTMT = t->GetMethodTable();
-    if (pTMT != g_pRuntimeTypeClass &&
-        pTMT != MscorlibBinder::GetClass(CLASS__CLASS_INTROSPECTION_ONLY))
+    if (pTMT != g_pRuntimeTypeClass)
         COMPlusThrowArgumentException(W("t"), W("Argument_MustBeRuntimeType"));
 
     MethodTable *pMT = t->GetType().GetMethodTable();
@@ -1998,8 +1994,7 @@ FCIMPL1(int, MarshalNative::GetEndComSlot, ReflectClassBaseObject* tUNSAFE)
         COMPlusThrow(kArgumentNullException, W("ArgumentNull_Generic"));
     
     MethodTable *pTMT = t->GetMethodTable();
-    if (pTMT != g_pRuntimeTypeClass &&
-        pTMT != MscorlibBinder::GetClass(CLASS__CLASS_INTROSPECTION_ONLY))
+    if (pTMT != g_pRuntimeTypeClass)
         COMPlusThrowArgumentException(W("t"), W("Argument_MustBeRuntimeType"));
 
     TypeHandle classTH = t->GetType();
@@ -2077,8 +2072,7 @@ FCIMPL3(Object*, MarshalNative::GetMethodInfoForComSlot, ReflectClassBaseObject*
         COMPlusThrow(kArgumentNullException, W("ArgumentNull_Generic"));
     
     MethodTable *pTMT = t->GetMethodTable();
-    if (pTMT != g_pRuntimeTypeClass &&
-        pTMT != MscorlibBinder::GetClass(CLASS__CLASS_INTROSPECTION_ONLY))
+    if (pTMT != g_pRuntimeTypeClass)
         COMPlusThrowArgumentException(W("t"), W("Argument_MustBeRuntimeType"));
 
     TypeHandle type = t->GetType();
diff --git a/src/vm/method.cpp b/src/vm/method.cpp
index 68f54233ed..bcc11e85ff 100644
--- a/src/vm/method.cpp
+++ b/src/vm/method.cpp
@@ -120,13 +120,6 @@ SIZE_T MethodDesc::SizeOf()
     return size;
 }
 
-//*******************************************************************************
-BOOL MethodDesc::IsIntrospectionOnly()
-{
-    WRAPPER_NO_CONTRACT;
-    return GetModule()->GetAssembly()->IsIntrospectionOnly();
-}
-
 /*********************************************************************/
 #ifndef DACCESS_COMPILE
 BOOL NDirectMethodDesc::HasDefaultDllImportSearchPathsAttribute()
diff --git a/src/vm/method.hpp b/src/vm/method.hpp
index 943bcdb6d6..56acf46635 100644
--- a/src/vm/method.hpp
+++ b/src/vm/method.hpp
@@ -704,7 +704,6 @@ public:
         InterlockedUpdateFlags(mdcNotInline, set);
     }
 
-    BOOL IsIntrospectionOnly();
 #ifndef DACCESS_COMPILE
     VOID EnsureActive();
 #endif
diff --git a/src/vm/methodtable.cpp b/src/vm/methodtable.cpp
index aeb0c766f1..a768ded29b 100644
--- a/src/vm/methodtable.cpp
+++ b/src/vm/methodtable.cpp
@@ -4029,10 +4029,7 @@ OBJECTREF MethodTable::GetManagedClassObject()
 
         REFLECTCLASSBASEREF  refClass = NULL;
         GCPROTECT_BEGIN(refClass);
-        if (GetAssembly()->IsIntrospectionOnly())
-            refClass = (REFLECTCLASSBASEREF) AllocateObject(MscorlibBinder::GetClass(CLASS__CLASS_INTROSPECTION_ONLY));
-        else
-            refClass = (REFLECTCLASSBASEREF) AllocateObject(g_pRuntimeTypeClass);
+        refClass = (REFLECTCLASSBASEREF) AllocateObject(g_pRuntimeTypeClass);
 
         LoaderAllocator *pLoaderAllocator = GetLoaderAllocator();
 
@@ -5966,7 +5963,7 @@ void MethodTable::DoFullyLoad(Generics::RecursionGraph * const pVisited,  const
             SetIsDependenciesLoaded();
 
 #if defined(FEATURE_COMINTEROP) && !defined(DACCESS_COMPILE)
-            if (WinRTSupported() && g_fEEStarted && !ContainsIntrospectionOnlyTypes())
+            if (WinRTSupported() && g_fEEStarted)
             {
                 _ASSERTE(GetAppDomain() != NULL);
 
@@ -9367,7 +9364,7 @@ CHECK MethodTable::CheckActivated()
 }
 
 #ifdef _MSC_VER
-// Optimization intended for EnsureInstanceActive, IsIntrospectionOnly, EnsureActive only
+// Optimization intended for EnsureInstanceActive, EnsureActive only
 #pragma optimize("t", on)
 #endif // _MSC_VER
 //==========================================================================================
@@ -9423,40 +9420,6 @@ VOID MethodTable::EnsureInstanceActive()
 #endif //!DACCESS_COMPILE
 
 //==========================================================================================
-BOOL MethodTable::IsIntrospectionOnly()
-{
-    WRAPPER_NO_CONTRACT;
-    return GetAssembly()->IsIntrospectionOnly();
-}
-
-//==========================================================================================
-BOOL MethodTable::ContainsIntrospectionOnlyTypes()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END
-
-    // check this type
-    if (IsIntrospectionOnly())
-        return TRUE;
-
-    // check the instantiation
-    Instantiation inst = GetInstantiation();
-    for (DWORD i = 0; i < inst.GetNumArgs(); i++)
-    {
-        CONSISTENCY_CHECK(!inst[i].IsEncodedFixup());
-        if (inst[i].ContainsIntrospectionOnlyTypes())
-            return TRUE;
-    }
-
-    return FALSE;
-}
-
-//==========================================================================================
 #ifndef DACCESS_COMPILE
 VOID MethodTable::EnsureActive()
 {
diff --git a/src/vm/methodtable.h b/src/vm/methodtable.h
index 98702961f3..38ce20ee0a 100644
--- a/src/vm/methodtable.h
+++ b/src/vm/methodtable.h
@@ -993,11 +993,6 @@ public:
     }
 #endif // FEATURE_COMINTEROP
 
-    BOOL IsIntrospectionOnly();
-
-    // Checks this type and its instantiation for "IsIntrospectionOnly"
-    BOOL ContainsIntrospectionOnlyTypes();
-
 #ifndef DACCESS_COMPILE
     VOID EnsureActive();
     VOID EnsureInstanceActive();
diff --git a/src/vm/mlinfo.cpp b/src/vm/mlinfo.cpp
index 12be6d3b95..ad7093f500 100644
--- a/src/vm/mlinfo.cpp
+++ b/src/vm/mlinfo.cpp
@@ -913,17 +913,17 @@ EventArgsMarshalingInfo::EventArgsMarshalingInfo()
 
     // Load the System.Collections.Specialized.NotifyCollectionChangedEventArgs class.
     SString qualifiedNCCEventArgsTypeName(SString::Utf8, NCCEVENTARGS_ASM_QUAL_TYPE_NAME);
-    m_hndSystemNCCEventArgsType = TypeName::GetTypeFromAsmQualifiedName(qualifiedNCCEventArgsTypeName.GetUnicode(), FALSE);
+    m_hndSystemNCCEventArgsType = TypeName::GetTypeFromAsmQualifiedName(qualifiedNCCEventArgsTypeName.GetUnicode());
     _ASSERTE(!m_hndSystemNCCEventArgsType.IsNull() && "Cannot load System.Collections.Specialized.NotifyCollectionChangedEventArgs!");
 
     // Load the System.ComponentModel.PropertyChangedEventArgs class.
     SString qualifiedPCEventArgsTypeName(SString::Utf8, PCEVENTARGS_ASM_QUAL_TYPE_NAME);
-    m_hndSystemPCEventArgsType = TypeName::GetTypeFromAsmQualifiedName(qualifiedPCEventArgsTypeName.GetUnicode(), FALSE);
+    m_hndSystemPCEventArgsType = TypeName::GetTypeFromAsmQualifiedName(qualifiedPCEventArgsTypeName.GetUnicode());
     _ASSERTE(!m_hndSystemPCEventArgsType.IsNull() && "Cannot load System.ComponentModel.PropertyChangedEventArgs!");
 
     // Load the NCCEventArgs marshaler class.
     SString qualifiedNCCEventArgsMarshalerTypeName(SString::Utf8, NCCEVENTARGS_MARSHALER_ASM_QUAL_TYPE_NAME);
-    TypeHandle hndNCCEventArgsMarshalerType = TypeName::GetTypeFromAsmQualifiedName(qualifiedNCCEventArgsMarshalerTypeName.GetUnicode(), FALSE);
+    TypeHandle hndNCCEventArgsMarshalerType = TypeName::GetTypeFromAsmQualifiedName(qualifiedNCCEventArgsMarshalerTypeName.GetUnicode());
 
     // Retrieve the method to convert a .NET NCCEventArgs to a WinRT NCCEventArgs.
     m_pSystemNCCEventArgsToWinRTNCCEventArgsMD = MemberLoader::FindMethodByName(hndNCCEventArgsMarshalerType.GetMethodTable(), EVENTARGS_TO_WINRT_EVENTARGS_METH_NAME);
@@ -935,7 +935,7 @@ EventArgsMarshalingInfo::EventArgsMarshalingInfo()
 
     // Load the PCEventArgs marshaler class.
     SString qualifiedPCEventArgsMarshalerTypeName(SString::Utf8, PCEVENTARGS_MARSHALER_ASM_QUAL_TYPE_NAME);
-    TypeHandle hndPCEventArgsMarshalerType = TypeName::GetTypeFromAsmQualifiedName(qualifiedPCEventArgsMarshalerTypeName.GetUnicode(), FALSE);
+    TypeHandle hndPCEventArgsMarshalerType = TypeName::GetTypeFromAsmQualifiedName(qualifiedPCEventArgsMarshalerTypeName.GetUnicode());
 
     // Retrieve the method to convert a .NET PCEventArgs to a WinRT PCEventArgs.
     m_pSystemPCEventArgsToWinRTPCEventArgsMD = MemberLoader::FindMethodByName(hndPCEventArgsMarshalerType.GetMethodTable(), EVENTARGS_TO_WINRT_EVENTARGS_METH_NAME);
@@ -992,7 +992,7 @@ UriMarshalingInfo::UriMarshalingInfo()
 
     // Load the System.Uri class.
     SString qualifiedUriTypeName(SString::Utf8, URI_ASM_QUAL_TYPE_NAME);
-    m_hndSystemUriType = TypeName::GetTypeFromAsmQualifiedName(qualifiedUriTypeName.GetUnicode(), FALSE);
+    m_hndSystemUriType = TypeName::GetTypeFromAsmQualifiedName(qualifiedUriTypeName.GetUnicode());
     _ASSERTE(!m_hndSystemUriType.IsNull() && "Cannot load System.Uri!");
     
     m_SystemUriOriginalStringGetterMD = MemberLoader::FindPropertyMethod(m_hndSystemUriType.GetMethodTable(), ORIGINALSTRING_PROPERTY_NAME, PropertyGet);
@@ -1039,12 +1039,12 @@ OleColorMarshalingInfo::OleColorMarshalingInfo() :
     SString qualifiedColorTranslatorTypeName(SString::Utf8, COLOR_TRANSLATOR_ASM_QUAL_TYPE_NAME);
 
     // Load the color translator class.
-    TypeHandle hndColorTranslatorType = TypeName::GetTypeFromAsmQualifiedName(qualifiedColorTranslatorTypeName.GetUnicode(), FALSE);
+    TypeHandle hndColorTranslatorType = TypeName::GetTypeFromAsmQualifiedName(qualifiedColorTranslatorTypeName.GetUnicode());
 
     
     SString qualifiedColorTypeName(SString::Utf8, COLOR_ASM_QUAL_TYPE_NAME);
     // Load the color class.
-    m_hndColorType = TypeName::GetTypeFromAsmQualifiedName(qualifiedColorTypeName.GetUnicode(), FALSE);
+    m_hndColorType = TypeName::GetTypeFromAsmQualifiedName(qualifiedColorTypeName.GetUnicode());
     
     // Retrieve the method to convert an OLE_COLOR to a System.Drawing.Color.
     m_OleColorToSystemColorMD = MemberLoader::FindMethodByName(hndColorTranslatorType.GetMethodTable(), OLECOLOR_TO_SYSTEMCOLOR_METH_NAME);
diff --git a/src/vm/mngstdinterfaces.cpp b/src/vm/mngstdinterfaces.cpp
index d6de4f32a0..7e93877c91 100644
--- a/src/vm/mngstdinterfaces.cpp
+++ b/src/vm/mngstdinterfaces.cpp
@@ -131,7 +131,7 @@ void MngStdItfBase::InitHelper(
 
     // Retrieve the custom marshaler type handle.
     SString sstrCMTypeName(SString::Utf8, strCMTypeName);
-    *pCustomMarshalerType = TypeName::GetTypeFromAsmQualifiedName(sstrCMTypeName.GetUnicode(), FALSE);
+    *pCustomMarshalerType = TypeName::GetTypeFromAsmQualifiedName(sstrCMTypeName.GetUnicode());
     
     // Run the <clinit> for the marshaller.
     pCustomMarshalerType->GetMethodTable()->EnsureInstanceActive();    
@@ -139,7 +139,7 @@ void MngStdItfBase::InitHelper(
 
     // Load the managed view.
     SString sstrManagedViewName(SString::Utf8, strManagedViewName);
-    *pManagedViewType = TypeName::GetTypeFromAsmQualifiedName(sstrManagedViewName.GetUnicode(), FALSE);
+    *pManagedViewType = TypeName::GetTypeFromAsmQualifiedName(sstrManagedViewName.GetUnicode());
 
     // Run the <clinit> for the managed view.
     pManagedViewType->GetMethodTable()->EnsureInstanceActive();
diff --git a/src/vm/mscorlib.h b/src/vm/mscorlib.h
index c33e9e1f74..c1b904ccb5 100644
--- a/src/vm/mscorlib.h
+++ b/src/vm/mscorlib.h
@@ -209,8 +209,6 @@ DEFINE_METHOD(CLASS,                GET_METHOD_BASE,        GetMethodBase,
 DEFINE_METHOD(CLASS,                GET_FIELD_INFO,         GetFieldInfo,               SM_RuntimeType_IRuntimeFieldInfo_RetFieldInfo)
 DEFINE_METHOD(CLASS,                GET_PROPERTY_INFO,      GetPropertyInfo,            SM_RuntimeType_Int_RetPropertyInfo)
 
-DEFINE_CLASS(CLASS_INTROSPECTION_ONLY, System,              ReflectionOnlyType)
-
 #ifdef FEATURE_COMINTEROP
 DEFINE_CLASS_U(System,                 __ComObject,            ComObject)
 DEFINE_FIELD_U(m_ObjectToDataMap,      ComObject,              m_ObjectToDataMap)
diff --git a/src/vm/pefile.cpp b/src/vm/pefile.cpp
index 77c99f6191..7cfa05779a 100644
--- a/src/vm/pefile.cpp
+++ b/src/vm/pefile.cpp
@@ -212,9 +212,6 @@ static void ValidatePEFileMachineType(PEFile *peFile)
 {
     STANDARD_VM_CONTRACT;
 
-    if (peFile->IsIntrospectionOnly())
-        return;    // ReflectionOnly assemblies permitted to violate CPU restrictions
-
     if (peFile->IsDynamic())
         return;    // PEFiles for ReflectionEmit assemblies don't cache the machine type.
 
@@ -280,12 +277,12 @@ void PEFile::LoadLibrary(BOOL allowNativeSkip/*=TRUE*/) // if allowNativeSkip==F
     // Resource images are always flat.
     if (IsResource())
     {
-        GetILimage()->LoadNoMetaData(IsIntrospectionOnly());
+        GetILimage()->LoadNoMetaData();
         RETURN;
     }
 
 #if !defined(_TARGET_64BIT_)
-    if (!HasNativeImage() && (!GetILimage()->Has32BitNTHeaders()) && !IsIntrospectionOnly())
+    if (!HasNativeImage() && !GetILimage()->Has32BitNTHeaders())
     {
         // Tried to load 64-bit assembly on 32-bit platform.
         EEFileLoadException::Throw(this, COR_E_BADIMAGEFORMAT, NULL);
@@ -298,16 +295,6 @@ void PEFile::LoadLibrary(BOOL allowNativeSkip/*=TRUE*/) // if allowNativeSkip==F
         EnsureImageOpened();
     }
 
-    if (IsIntrospectionOnly())
-    {
-        GetILimage()->LoadForIntrospection();
-        RETURN;
-    }
-
-
-    //---- Below this point, only do the things necessary for execution ----
-    _ASSERTE(!IsIntrospectionOnly());
-
 #ifdef FEATURE_PREJIT
     // For on-disk Dlls, we can call LoadLibrary
     if (IsDll() && !((HasNativeImage()?m_nativeImage:GetILimage())->GetPath().IsEmpty()))
@@ -463,13 +450,6 @@ BOOL PEFile::Equals(PEFile *pFile)
     if (pFile == this)
         return TRUE;
 
-
-    // Execution and introspection files are NOT equal
-    if ( (!IsIntrospectionOnly()) != !(pFile->IsIntrospectionOnly()) )
-    {
-        return FALSE;
-    }
-
     // Different host assemblies cannot be equal unless they are associated with the same host binder
     // It's ok if only one has a host binder because multiple threads can race to load the same assembly
     // and that may cause temporary candidate PEAssembly objects that never get bound to a host assembly
@@ -1633,11 +1613,11 @@ PEFile::LoadAssembly(
     
     AssemblySpec spec;
     
-    spec.InitializeSpec(kAssemblyRef, pImport, GetAppDomain()->FindAssembly(GetAssembly()), IsIntrospectionOnly());
+    spec.InitializeSpec(kAssemblyRef, pImport, GetAppDomain()->FindAssembly(GetAssembly()));
     if (szWinRtTypeClassName != NULL)
         spec.SetWindowsRuntimeType(szWinRtTypeNamespace, szWinRtTypeClassName);
     
-    RETURN GetAppDomain()->BindAssemblySpec(&spec, TRUE, IsIntrospectionOnly());
+    RETURN GetAppDomain()->BindAssemblySpec(&spec, TRUE);
 }
 
 // ------------------------------------------------------------
@@ -1805,7 +1785,7 @@ BOOL PEFile::GetResource(LPCSTR szName, DWORD *cbResource,
                 return FALSE;
 
             AssemblySpec spec;
-            spec.InitializeSpec(mdLinkRef, GetPersistentMDImport(), pDomainAssembly, pDomainAssembly->GetFile()->IsIntrospectionOnly());
+            spec.InitializeSpec(mdLinkRef, GetPersistentMDImport(), pDomainAssembly);
             pDomainAssembly = spec.LoadDomainAssembly(FILE_LOADED);
 
             if (dwLocation) {
@@ -1962,7 +1942,6 @@ PEAssembly::PEAssembly(
                 IMetaDataEmit* pEmit, 
                 PEFile *creator, 
                 BOOL system,
-                BOOL introspectionOnly/*=FALSE*/,
                 PEImage * pPEImageIL /*= NULL*/,
                 PEImage * pPEImageNI /*= NULL*/,
                 ICLRPrivAssembly * pHostAssembly /*= NULL*/)
@@ -1985,14 +1964,6 @@ PEAssembly::PEAssembly(
     }
     CONTRACTL_END;
 
-    if (introspectionOnly)
-    {
-        if (!system)  // Implementation restriction: mscorlib.dll cannot be loaded as introspection. The architecture depends on there being exactly one mscorlib.
-        {
-            m_flags |= PEFILE_INTROSPECTIONONLY;
-        }
-    }
-
     m_flags |= PEFILE_ASSEMBLY;
     if (system)
         m_flags |= PEFILE_SYSTEM;
@@ -2085,8 +2056,7 @@ PEAssembly *PEAssembly::Open(
     PEAssembly *       pParent,
     PEImage *          pPEImageIL, 
     PEImage *          pPEImageNI, 
-    ICLRPrivAssembly * pHostAssembly, 
-    BOOL               fIsIntrospectionOnly)
+    ICLRPrivAssembly * pHostAssembly)
 {
     STANDARD_VM_CONTRACT;
 
@@ -2095,7 +2065,6 @@ PEAssembly *PEAssembly::Open(
         nullptr,        // IMetaDataEmit
         pParent,        // PEFile creator
         FALSE,          // isSystem
-        fIsIntrospectionOnly,
         pPEImageIL,
         pPEImageNI,
         pHostAssembly);
@@ -2197,7 +2166,6 @@ PEAssembly *PEAssembly::DoOpenSystem(IUnknown * pAppCtx)
 /* static */
 PEAssembly *PEAssembly::OpenMemory(PEAssembly *pParentAssembly,
                                    const void *flat, COUNT_T size,
-                                   BOOL isIntrospectionOnly/*=FALSE*/,
                                    CLRPrivBinderLoadFile* pBinderToUse)
 {
     STANDARD_VM_CONTRACT;
@@ -2206,7 +2174,7 @@ PEAssembly *PEAssembly::OpenMemory(PEAssembly *pParentAssembly,
 
     EX_TRY
     {
-        result = DoOpenMemory(pParentAssembly, flat, size, isIntrospectionOnly, pBinderToUse);
+        result = DoOpenMemory(pParentAssembly, flat, size, pBinderToUse);
     }
     EX_HOOK
     {
@@ -2246,7 +2214,6 @@ PEAssembly *PEAssembly::DoOpenMemory(
     PEAssembly *pParentAssembly,
     const void *flat,
     COUNT_T size,
-    BOOL isIntrospectionOnly,
     CLRPrivBinderLoadFile* pBinderToUse)
 {
     CONTRACT(PEAssembly *)
@@ -2279,24 +2246,23 @@ PEAssembly *PEAssembly::DoOpenMemory(
     IfFailThrow(CCoreCLRBinderHelper::GetAssemblyFromImage(image, NULL, &assembly));
     bindResult.Init(assembly,FALSE,FALSE);
 
-    RETURN new PEAssembly(&bindResult, NULL, pParentAssembly, FALSE, isIntrospectionOnly);
+    RETURN new PEAssembly(&bindResult, NULL, pParentAssembly, FALSE);
 }
 #endif // !CROSSGEN_COMPILE
 
 
 
 PEAssembly* PEAssembly::Open(CoreBindResult* pBindResult,
-                                   BOOL isSystem, BOOL isIntrospectionOnly)
+                                   BOOL isSystem)
 {
 
-    return new PEAssembly(pBindResult,NULL,NULL,isSystem,isIntrospectionOnly);
+    return new PEAssembly(pBindResult,NULL,NULL,isSystem);
 
 };
 
 /* static */
 PEAssembly *PEAssembly::Create(PEAssembly *pParentAssembly,
-                               IMetaDataAssemblyEmit *pAssemblyEmit,
-                               BOOL bIsIntrospectionOnly)
+                               IMetaDataAssemblyEmit *pAssemblyEmit)
 {
     CONTRACT(PEAssembly *)
     {
@@ -2311,7 +2277,7 @@ PEAssembly *PEAssembly::Create(PEAssembly *pParentAssembly,
     // we have.)
     SafeComHolder<IMetaDataEmit> pEmit;
     pAssemblyEmit->QueryInterface(IID_IMetaDataEmit, (void **)&pEmit);
-    PEAssemblyHolder pFile(new PEAssembly(NULL, pEmit, pParentAssembly, FALSE, bIsIntrospectionOnly));
+    PEAssemblyHolder pFile(new PEAssembly(NULL, pEmit, pParentAssembly, FALSE));
     RETURN pFile.Extract();
 }
 
@@ -2423,20 +2389,8 @@ void PEAssembly::VerifyStrongName()
             ThrowHR(COR_E_BADIMAGEFORMAT);
     }
 
-    // Check the strong name if present.
-    if (IsIntrospectionOnly())
-    {
-        // For introspection assemblies, we don't need to check strong names and we don't
-        // need to do module hash checks.
-        m_flags |= PEFILE_SKIP_MODULE_HASH_CHECKS;
-    }
-    else
-    {
-        // Runtime policy on CoreCLR is to skip verification of ALL assemblies
-        m_flags |= PEFILE_SKIP_MODULE_HASH_CHECKS;
-        m_fStrongNameVerified = TRUE;
-    }
-
+    // Runtime policy on CoreCLR is to skip verification of ALL assemblies
+    m_flags |= PEFILE_SKIP_MODULE_HASH_CHECKS;
     m_fStrongNameVerified = TRUE;
 }
 
diff --git a/src/vm/pefile.h b/src/vm/pefile.h
index 787474745d..66915bf81a 100644
--- a/src/vm/pefile.h
+++ b/src/vm/pefile.h
@@ -218,7 +218,6 @@ public:
     BOOL IsDynamic() const;
     BOOL IsResource() const;
     BOOL IsIStream() const;
-    BOOL IsIntrospectionOnly() const;
     // Returns self (if assembly) or containing assembly (if module)
     PEAssembly *GetAssembly() const;
 
@@ -454,7 +453,6 @@ protected:
         PEFILE_NATIVE_IMAGE_USED_EXCLUSIVELY =0x1000,
         PEFILE_SAFE_TO_HARDBINDTO     = 0x4000, // NGEN-only flag
 #endif        
-        PEFILE_INTROSPECTIONONLY      = 0x400,
     };
 
     // ------------------------------------------------------------
@@ -674,8 +672,7 @@ class PEAssembly : public PEFile
         PEAssembly *       pParent,
         PEImage *          pPEImageIL, 
         PEImage *          pPEImageNI, 
-        ICLRPrivAssembly * pHostAssembly, 
-        BOOL               fIsIntrospectionOnly = FALSE);
+        ICLRPrivAssembly * pHostAssembly);
 
     // This opens the canonical mscorlib.dll
     static PEAssembly *OpenSystem(IUnknown *pAppCtx);
@@ -685,26 +682,22 @@ class PEAssembly : public PEFile
 
     static PEAssembly *Open(
         CoreBindResult* pBindResult,
-        BOOL isSystem,
-        BOOL isIntrospectionOnly);
+        BOOL isSystem);
 
     static PEAssembly *Create(
         PEAssembly *pParentAssembly,
-        IMetaDataAssemblyEmit *pEmit,
-        BOOL isIntrospectionOnly);
+        IMetaDataAssemblyEmit *pEmit);
 
     static PEAssembly *OpenMemory(
         PEAssembly *pParentAssembly,
         const void *flat,
         COUNT_T size, 
-        BOOL isIntrospectionOnly = FALSE,
         CLRPrivBinderLoadFile* pBinderToUse = NULL);
 
     static PEAssembly *DoOpenMemory(
         PEAssembly *pParentAssembly,
         const void *flat,
         COUNT_T size,
-        BOOL isIntrospectionOnly,
         CLRPrivBinderLoadFile* pBinderToUse);
 
   private:
@@ -789,7 +782,6 @@ class PEAssembly : public PEFile
         IMetaDataEmit *pEmit,
         PEFile *creator, 
         BOOL system, 
-        BOOL introspectionOnly = FALSE,
         PEImage * pPEImageIL = NULL,
         PEImage * pPEImageNI = NULL,
         ICLRPrivAssembly * pHostAssembly = NULL
diff --git a/src/vm/pefile.inl b/src/vm/pefile.inl
index 47c921634d..c5c92a96c9 100644
--- a/src/vm/pefile.inl
+++ b/src/vm/pefile.inl
@@ -118,7 +118,7 @@ inline void PEFile::ValidateForExecution()
 
     // We do not need to check NGen images; if it had the attribute, it would have failed to load
     // at NGen time and so there would be no NGen image.
-    if (HasNativeImage() || IsIntrospectionOnly())
+    if (HasNativeImage())
         return;
 
     //
@@ -328,16 +328,6 @@ inline BOOL PEFile::IsIStream() const
     return (m_flags & PEFILE_ISTREAM) != 0;
 }
 
-inline BOOL PEFile::IsIntrospectionOnly() const
-{
-    WRAPPER_NO_CONTRACT;
-    STATIC_CONTRACT_SO_TOLERANT;
-    {
-        return (m_flags & PEFILE_INTROSPECTIONONLY) != 0;
-    }
-}
-
-
 inline PEAssembly *PEFile::GetAssembly() const
 {
     WRAPPER_NO_CONTRACT;
@@ -1343,9 +1333,7 @@ inline PTR_PEImageLayout PEFile::GetLoadedIL()
     SUPPORTS_DAC;
 
     _ASSERTE(HasOpenedILimage());
-    if(IsIntrospectionOnly())
-        return GetOpenedILimage()->GetLoadedIntrospectionLayout();
-    
+
     return GetOpenedILimage()->GetLoadedLayout();
 };
 
@@ -1368,10 +1356,6 @@ inline BOOL PEFile::IsLoaded(BOOL bAllowNative/*=TRUE*/)
     CONTRACTL_END;
     if(IsDynamic())
         return TRUE;
-    if(IsIntrospectionOnly())
-    {
-        return HasOpenedILimage() && GetOpenedILimage()->HasLoadedIntrospectionLayout();
-    }
 #ifdef FEATURE_PREJIT
     if (bAllowNative && HasNativeImage())
     {
diff --git a/src/vm/peimage.cpp b/src/vm/peimage.cpp
index 83989f0e4d..766d40bdc4 100644
--- a/src/vm/peimage.cpp
+++ b/src/vm/peimage.cpp
@@ -808,8 +808,6 @@ void PEImage::EnumMemoryRegions(CLRDataEnumMemoryFlags flags)
         m_pLayouts[IMAGE_MAPPED]->EnumMemoryRegions(flags);
     if (m_pLayouts[IMAGE_LOADED].IsValid() &&  m_pLayouts[IMAGE_LOADED]!=NULL)
         m_pLayouts[IMAGE_LOADED]->EnumMemoryRegions(flags);
-    if (m_pLayouts[IMAGE_LOADED_FOR_INTROSPECTION].IsValid() &&  m_pLayouts[IMAGE_LOADED_FOR_INTROSPECTION]!=NULL)
-        m_pLayouts[IMAGE_LOADED_FOR_INTROSPECTION]->EnumMemoryRegions(flags);
 }
 
 #endif // #ifdef DACCESS_COMPILE
@@ -1179,19 +1177,6 @@ void PEImage::LoadFromMapped()
         SetLayout(IMAGE_LOADED,pLayout.Extract());
 }
 
-void PEImage::LoadForIntrospection()
-{
-    STANDARD_VM_CONTRACT;
-
-    if (HasLoadedIntrospectionLayout())
-        return;
-
-    PEImageLayoutHolder pLayout(GetLayout(PEImageLayout::LAYOUT_ANY,LAYOUT_CREATEIFNEEDED));
-    SimpleWriteLockHolder lock(m_pLayoutLock);
-    if(m_pLayouts[IMAGE_LOADED_FOR_INTROSPECTION]==NULL)
-        SetLayout(IMAGE_LOADED_FOR_INTROSPECTION,pLayout.Extract());
-}
-
 void PEImage::LoadNoFile()
 {
     CONTRACTL
@@ -1212,32 +1197,25 @@ void PEImage::LoadNoFile()
 }
 
 
-void PEImage::LoadNoMetaData(BOOL bIntrospection)
+void PEImage::LoadNoMetaData()
 {
     STANDARD_VM_CONTRACT;
 
-     if (bIntrospection)
-     {
-        if (HasLoadedIntrospectionLayout())
-            return;
-     }
-     else
-         if (HasLoadedLayout())
-            return;
+    if (HasLoadedLayout())
+        return;
 
     SimpleWriteLockHolder lock(m_pLayoutLock);
-    int layoutKind=bIntrospection?IMAGE_LOADED_FOR_INTROSPECTION:IMAGE_LOADED;
-    if (m_pLayouts[layoutKind]!=NULL)
+    if (m_pLayouts[IMAGE_LOADED]!=NULL)
         return;
     if (m_pLayouts[IMAGE_FLAT]!=NULL)
     {
         m_pLayouts[IMAGE_FLAT]->AddRef();
-        SetLayout(layoutKind,m_pLayouts[IMAGE_FLAT]);
+        SetLayout(IMAGE_LOADED,m_pLayouts[IMAGE_FLAT]);
     }
     else
     {
         _ASSERTE(!m_path.IsEmpty());
-        SetLayout(layoutKind,PEImageLayout::LoadFlat(GetFileHandle(),this));
+        SetLayout(IMAGE_LOADED,PEImageLayout::LoadFlat(GetFileHandle(),this));
     }
 }
 
diff --git a/src/vm/peimage.h b/src/vm/peimage.h
index a767c70342..e05f95dac8 100644
--- a/src/vm/peimage.h
+++ b/src/vm/peimage.h
@@ -70,11 +70,8 @@ public:
     };
     PTR_PEImageLayout GetLayout(DWORD imageLayoutMask,DWORD flags); //with ref
     PTR_PEImageLayout GetLoadedLayout(); //no ref
-    PTR_PEImageLayout GetLoadedIntrospectionLayout(); //no ref, introspection only
     BOOL IsOpened();
     BOOL HasLoadedLayout();
-    BOOL HasLoadedIntrospectionLayout();
-    
 
 public:
     // ------------------------------------------------------------
@@ -135,10 +132,9 @@ public:
 
     void   Load();
     void   SetLoadedHMODULE(HMODULE hMod);
-    void   LoadNoMetaData(BOOL bIntrospection);
+    void   LoadNoMetaData();
     void   LoadNoFile();
-    void   LoadFromMapped();  
-    void   LoadForIntrospection();
+    void   LoadFromMapped();
 
     void AllocateLazyCOWPages();
 #endif
@@ -329,8 +325,7 @@ protected:
         IMAGE_FLAT=0,
         IMAGE_MAPPED=1,
         IMAGE_LOADED=2,
-        IMAGE_LOADED_FOR_INTROSPECTION=3,
-        IMAGE_COUNT=4
+        IMAGE_COUNT=3
     };
     
     SimpleRWLock *m_pLayoutLock;
diff --git a/src/vm/peimage.inl b/src/vm/peimage.inl
index 954d8872f6..0e7410734e 100644
--- a/src/vm/peimage.inl
+++ b/src/vm/peimage.inl
@@ -94,16 +94,6 @@ inline PTR_PEImageLayout PEImage::GetLoadedLayout()
     return m_pLayouts[IMAGE_LOADED]; //no addref
 }
 
-inline PTR_PEImageLayout PEImage::GetLoadedIntrospectionLayout()
-{
-    LIMITED_METHOD_CONTRACT;
-    SUPPORTS_DAC;
-
-    _ASSERTE(m_pLayouts[IMAGE_LOADED_FOR_INTROSPECTION]!=NULL);
-    return m_pLayouts[IMAGE_LOADED_FOR_INTROSPECTION]; //no addref
-}
-
-
 //
 // GetExistingLayout - get an layout corresponding to the specified mask, or null if none.
 // Does not take any locks or call AddRef.
@@ -125,8 +115,6 @@ inline PTR_PEImageLayout PEImage::GetExistingLayoutInternal(DWORD imageLayoutMas
 
     if (imageLayoutMask&PEImageLayout::LAYOUT_LOADED)
         pRetVal=m_pLayouts[IMAGE_LOADED];
-    if (pRetVal==NULL && (imageLayoutMask & PEImageLayout::LAYOUT_LOADED_FOR_INTROSPECTION)) 
-        pRetVal=m_pLayouts[IMAGE_LOADED_FOR_INTROSPECTION];
     if (pRetVal==NULL && (imageLayoutMask & PEImageLayout::LAYOUT_MAPPED))
         pRetVal=m_pLayouts[IMAGE_MAPPED];
     if (pRetVal==NULL && (imageLayoutMask & PEImageLayout::LAYOUT_FLAT))
@@ -146,14 +134,7 @@ inline BOOL PEImage::HasLoadedLayout()
 inline BOOL PEImage::IsOpened()
 {
     LIMITED_METHOD_CONTRACT;
-    return m_pLayouts[IMAGE_LOADED]!=NULL ||m_pLayouts[IMAGE_MAPPED]!=NULL || m_pLayouts[IMAGE_FLAT] !=NULL || m_pLayouts[IMAGE_LOADED_FOR_INTROSPECTION]!=NULL;
-}
-
-
-inline BOOL PEImage::HasLoadedIntrospectionLayout() //introspection only!!!
-{
-    LIMITED_METHOD_DAC_CONTRACT;
-    return m_pLayouts[IMAGE_LOADED_FOR_INTROSPECTION]!=NULL;
+    return m_pLayouts[IMAGE_LOADED]!=NULL ||m_pLayouts[IMAGE_MAPPED]!=NULL || m_pLayouts[IMAGE_FLAT] !=NULL;
 }
 
 
diff --git a/src/vm/prestub.cpp b/src/vm/prestub.cpp
index c567ba0573..378dc2e120 100644
--- a/src/vm/prestub.cpp
+++ b/src/vm/prestub.cpp
@@ -1650,16 +1650,6 @@ PCODE MethodDesc::DoPrestub(MethodTable *pDispatchingMT)
     // Running a prestub on a method causes us to access its MethodTable
     g_IBCLogger.LogMethodDescAccess(this);
 
-    // A secondary layer of defense against executing code in inspection-only assembly.
-    // This should already have been taken care of by not allowing inspection assemblies
-    // to be activated. However, this is a very inexpensive piece of insurance in the name
-    // of security.
-    if (IsIntrospectionOnly())
-    {
-        _ASSERTE(!"A ReflectionOnly assembly reached the prestub. This should not have happened.");
-        COMPlusThrow(kInvalidOperationException, IDS_EE_CODEEXECUTION_IN_INTROSPECTIVE_ASSEMBLY);
-    }
-
     if (ContainsGenericVariables())
     {
         COMPlusThrow(kInvalidOperationException, IDS_EE_CODEEXECUTION_CONTAINSGENERICVAR);
diff --git a/src/vm/profilingenumerators.cpp b/src/vm/profilingenumerators.cpp
index 2406f5aa42..a6b0a640f1 100644
--- a/src/vm/profilingenumerators.cpp
+++ b/src/vm/profilingenumerators.cpp
@@ -294,7 +294,7 @@ HRESULT IterateUnsharedModules(AppDomain * pAppDomain,
     // DomainAssembly instances.
     AppDomain::AssemblyIterator domainAssemblyIterator = 
         pAppDomain->IterateAssembliesEx(
-            (AssemblyIterationFlags) (kIncludeAvailableToProfilers | kIncludeExecution | kIncludeIntrospection));
+            (AssemblyIterationFlags) (kIncludeAvailableToProfilers | kIncludeExecution));
     CollectibleAssemblyHolder<DomainAssembly *> pDomainAssembly;
     
     while (domainAssemblyIterator.Next(pDomainAssembly.This()))
diff --git a/src/vm/readytoruninfo.cpp b/src/vm/readytoruninfo.cpp
index c654e68b18..4a57ed52b5 100644
--- a/src/vm/readytoruninfo.cpp
+++ b/src/vm/readytoruninfo.cpp
@@ -463,13 +463,6 @@ PTR_ReadyToRunInfo ReadyToRunInfo::Initialize(Module * pModule, AllocMemTracker
         return NULL;
     }
 
-    // Ignore ReadyToRun for introspection-only loads
-    if (pFile->IsIntrospectionOnly())
-    {
-        DoLog("Ready to Run disabled - module loaded for reflection");
-        return NULL;
-    }
-
     if (!pFile->HasLoadedIL())
     {
         DoLog("Ready to Run disabled - no loaded IL image");
diff --git a/src/vm/reflectioninvocation.cpp b/src/vm/reflectioninvocation.cpp
index 4d7ae83a54..d9ed5fb98b 100644
--- a/src/vm/reflectioninvocation.cpp
+++ b/src/vm/reflectioninvocation.cpp
@@ -168,9 +168,6 @@ FCIMPL5(Object*, RuntimeFieldHandle::GetValue, ReflectFieldObject *pFieldUNSAFE,
         pAssem = declaringType.GetAssembly();
     }
 
-    if (pAssem->IsIntrospectionOnly())
-        FCThrowEx(kInvalidOperationException, IDS_EE_CODEEXECUTION_IN_INTROSPECTIVE_ASSEMBLY, NULL, NULL, NULL);
-
     // We should throw NotSupportedException here. 
     // But for backward compatibility we are throwing FieldAccessException instead.
     if (pAssem->IsDynamic() && !pAssem->HasRunAccess())
@@ -331,9 +328,6 @@ FCIMPL7(void, RuntimeFieldHandle::SetValue, ReflectFieldObject *pFieldUNSAFE, Ob
         pAssem = declaringType.GetAssembly();
     }
 
-    if (pAssem->IsIntrospectionOnly())
-        FCThrowExVoid(kInvalidOperationException, IDS_EE_CODEEXECUTION_IN_INTROSPECTIVE_ASSEMBLY, NULL, NULL, NULL);
-
     // We should throw NotSupportedException here. 
     // But for backward compatibility we are throwing FieldAccessException instead.
     if (pAssem->IsDynamic() && !pAssem->HasRunAccess())
@@ -404,9 +398,6 @@ FCIMPL5(Object*, RuntimeTypeHandle::CreateInstance, ReflectClassBaseObject* refT
 
     Assembly *pAssem = thisTH.GetAssembly();
 
-    if (pAssem->IsIntrospectionOnly())
-        FCThrowEx(kInvalidOperationException, IDS_EE_CODEEXECUTION_IN_INTROSPECTIVE_ASSEMBLY, NULL, NULL, NULL);
-
     if (pAssem->IsDynamic() && !pAssem->HasRunAccess())
         FCThrowRes(kNotSupportedException, W("NotSupported_DynamicAssemblyNoRunAccess"));
 
@@ -986,9 +977,6 @@ FCIMPL5(Object*, RuntimeMethodHandle::InvokeMethod,
 
     Assembly *pAssem = pMeth->GetAssembly();
 
-    if (pAssem->IsIntrospectionOnly())
-        COMPlusThrow(kInvalidOperationException, IDS_EE_CODEEXECUTION_IN_INTROSPECTIVE_ASSEMBLY);
-
     // We should throw NotSupportedException here. 
     // But for backward compatibility we are throwing TargetException instead.
     if (pAssem->IsDynamic() && !pAssem->HasRunAccess())
@@ -1527,9 +1515,6 @@ FCIMPL4(Object*, RuntimeFieldHandle::GetValueDirect, ReflectFieldObject *pFieldU
 
     Assembly *pAssem = pField->GetModule()->GetAssembly();
 
-    if (pAssem->IsIntrospectionOnly())
-        FCThrowEx(kInvalidOperationException, IDS_EE_CODEEXECUTION_IN_INTROSPECTIVE_ASSEMBLY, NULL, NULL, NULL);
-
     // We should throw NotSupportedException here. 
     // But for backward compatibility we are throwing FieldAccessException instead.
     if (pAssem->IsDynamic() && !pAssem->HasRunAccess())
@@ -1692,9 +1677,6 @@ FCIMPL5(void, RuntimeFieldHandle::SetValueDirect, ReflectFieldObject *pFieldUNSA
 
     Assembly *pAssem = pField->GetModule()->GetAssembly();
 
-    if (pAssem->IsIntrospectionOnly())
-        FCThrowExVoid(kInvalidOperationException, IDS_EE_CODEEXECUTION_IN_INTROSPECTIVE_ASSEMBLY, NULL, NULL, NULL);
-
     // We should throw NotSupportedException here. 
     // But for backward compatibility we are throwing FieldAccessException instead.
     if (pAssem->IsDynamic() && !pAssem->HasRunAccess())
@@ -1909,9 +1891,6 @@ FCIMPL1(void, ReflectionInvocation::RunClassConstructor, ReflectClassBaseObject
 
     Assembly *pAssem = pMT->GetAssembly();
 
-    if (pAssem->IsIntrospectionOnly())
-        FCThrowExVoid(kInvalidOperationException, IDS_EE_CODEEXECUTION_IN_INTROSPECTIVE_ASSEMBLY, NULL, NULL, NULL);
-
     if (pAssem->IsDynamic() && !pAssem->HasRunAccess())
     {
         FCThrowResVoid(kNotSupportedException, W("NotSupported_DynamicAssemblyNoRunAccess"));
@@ -1947,9 +1926,6 @@ FCIMPL1(void, ReflectionInvocation::RunModuleConstructor, ReflectModuleBaseObjec
 
     Assembly *pAssem = pModule->GetAssembly();
 
-    if (pAssem->IsIntrospectionOnly())
-        FCThrowExVoid(kInvalidOperationException, IDS_EE_CODEEXECUTION_IN_INTROSPECTIVE_ASSEMBLY, NULL, NULL, NULL);
-
     if (pAssem->IsDynamic() && !pAssem->HasRunAccess())
         FCThrowResVoid(kNotSupportedException, W("NotSupported_DynamicAssemblyNoRunAccess"));
 
diff --git a/src/vm/runtimehandles.cpp b/src/vm/runtimehandles.cpp
index 25a96a316c..a8a2d31950 100644
--- a/src/vm/runtimehandles.cpp
+++ b/src/vm/runtimehandles.cpp
@@ -1430,7 +1430,7 @@ void QCALLTYPE RuntimeTypeHandle::GetTypeByNameUsingCARules(LPCWSTR pwzClassName
     return;
 }
 
-void QCALLTYPE RuntimeTypeHandle::GetTypeByName(LPCWSTR pwzClassName, BOOL bThrowOnError, BOOL bIgnoreCase, BOOL bReflectionOnly,
+void QCALLTYPE RuntimeTypeHandle::GetTypeByName(LPCWSTR pwzClassName, BOOL bThrowOnError, BOOL bIgnoreCase,
                                                 QCall::StackCrawlMarkHandle pStackMark, 
                                                 ICLRPrivBinder * pPrivHostBinder,
                                                 BOOL bLoadTypeFromPartialNameHack, QCall::ObjectHandleOnStack retType,
@@ -1446,7 +1446,7 @@ void QCALLTYPE RuntimeTypeHandle::GetTypeByName(LPCWSTR pwzClassName, BOOL bThro
             COMPlusThrowArgumentNull(W("className"),W("ArgumentNull_String"));
 
     {
-        typeHandle = TypeName::GetTypeManaged(pwzClassName, NULL, bThrowOnError, bIgnoreCase, bReflectionOnly, /*bProhibitAsmQualifiedName =*/ FALSE, pStackMark,
+        typeHandle = TypeName::GetTypeManaged(pwzClassName, NULL, bThrowOnError, bIgnoreCase, /*bProhibitAsmQualifiedName =*/ FALSE, pStackMark,
                                               bLoadTypeFromPartialNameHack, (OBJECTREF*)keepAlive.m_ppObject,
                                               pPrivHostBinder);
     }
diff --git a/src/vm/runtimehandles.h b/src/vm/runtimehandles.h
index 213e90da86..dc379d827e 100644
--- a/src/vm/runtimehandles.h
+++ b/src/vm/runtimehandles.h
@@ -172,7 +172,7 @@ public:
     void QCALLTYPE GetTypeByNameUsingCARules(LPCWSTR pwzClassName, QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retType);
 
     static
-    void QCALLTYPE GetTypeByName(LPCWSTR pwzClassName, BOOL bThrowOnError, BOOL bIgnoreCase, BOOL bReflectionOnly,
+    void QCALLTYPE GetTypeByName(LPCWSTR pwzClassName, BOOL bThrowOnError, BOOL bIgnoreCase,
                                  QCall::StackCrawlMarkHandle pStackMark, 
                                  ICLRPrivBinder * pPrivHostBinder,
                                  BOOL bLoadTypeFromPartialNameHack, QCall::ObjectHandleOnStack retType,
diff --git a/src/vm/siginfo.cpp b/src/vm/siginfo.cpp
index 3a707d228c..1995d51515 100644
--- a/src/vm/siginfo.cpp
+++ b/src/vm/siginfo.cpp
@@ -3364,14 +3364,6 @@ BOOL CompareTypeDefsForEquivalence(mdToken tk1, mdToken tk2, Module *pModule1, M
     }
 
     // *************************************************************************
-    // 2c. the two types cannot be equivalent across IntrospectionOnly/Non-introspection boundaries
-    // *************************************************************************
-    if (!!pModule1->GetAssembly()->IsIntrospectionOnly() != !!pModule2->GetAssembly()->IsIntrospectionOnly())
-    {
-        return FALSE;
-    }
-
-    // *************************************************************************
     // 3. type is an interface, struct, enum, or delegate
     // *************************************************************************
     if (IsTdInterface(dwAttrType1))
diff --git a/src/vm/typedesc.cpp b/src/vm/typedesc.cpp
index 7da1c84604..b244f4503c 100644
--- a/src/vm/typedesc.cpp
+++ b/src/vm/typedesc.cpp
@@ -821,10 +821,7 @@ OBJECTREF ParamTypeDesc::GetManagedClassObject()
     if (m_hExposedClassObject == NULL) {
         REFLECTCLASSBASEREF  refClass = NULL;
         GCPROTECT_BEGIN(refClass);
-        if (GetAssembly()->IsIntrospectionOnly())
-            refClass = (REFLECTCLASSBASEREF) AllocateObject(MscorlibBinder::GetClass(CLASS__CLASS_INTROSPECTION_ONLY));
-        else
-            refClass = (REFLECTCLASSBASEREF) AllocateObject(g_pRuntimeTypeClass);
+        refClass = (REFLECTCLASSBASEREF) AllocateObject(g_pRuntimeTypeClass);
 
         LoaderAllocator *pLoaderAllocator = GetLoaderAllocator();
         TypeHandle th = TypeHandle(this);
@@ -2261,10 +2258,7 @@ OBJECTREF TypeVarTypeDesc::GetManagedClassObject()
     if (m_hExposedClassObject == NULL) {
         REFLECTCLASSBASEREF  refClass = NULL;
         GCPROTECT_BEGIN(refClass);
-        if (GetAssembly()->IsIntrospectionOnly())
-            refClass = (REFLECTCLASSBASEREF) AllocateObject(MscorlibBinder::GetClass(CLASS__CLASS_INTROSPECTION_ONLY));
-        else
-            refClass = (REFLECTCLASSBASEREF) AllocateObject(g_pRuntimeTypeClass);
+        refClass = (REFLECTCLASSBASEREF) AllocateObject(g_pRuntimeTypeClass);
 
         LoaderAllocator *pLoaderAllocator = GetLoaderAllocator();
         TypeHandle th = TypeHandle(this);
@@ -2336,53 +2330,6 @@ FnPtrTypeDesc::IsExternallyVisible() const
     return TRUE;
 } // FnPtrTypeDesc::IsExternallyVisible
 
-// Returns TRUE if any of return or argument types is part of an assembly loaded for introspection.
-BOOL 
-FnPtrTypeDesc::IsIntrospectionOnly() const
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-    }
-    CONTRACTL_END;
-    
-    const TypeHandle * rgRetAndArgTypes = GetRetAndArgTypes();
-    for (DWORD i = 0; i <= m_NumArgs; i++)
-    {
-        if (rgRetAndArgTypes[i].IsIntrospectionOnly())
-        {
-            return TRUE;
-        }
-    }
-    // None of the return/arguments type was loaded for introspection
-    return FALSE;
-} // FnPtrTypeDesc::IsIntrospectionOnly
-
-// Returns TRUE if any of return or argument types is part of an assembly loaded for introspection.
-// Instantiations of generic types are also recursively checked.
-BOOL 
-FnPtrTypeDesc::ContainsIntrospectionOnlyTypes() const
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-    }
-    CONTRACTL_END;
-    
-    const TypeHandle * rgRetAndArgTypes = GetRetAndArgTypes();
-    for (DWORD i = 0; i <= m_NumArgs; i++)
-    {
-        if (rgRetAndArgTypes[i].ContainsIntrospectionOnlyTypes())
-        {
-            return TRUE;
-        }
-    }
-    // None of the return/arguments type contains types loaded for introspection
-    return FALSE;
-} // FnPtrTypeDesc::ContainsIntrospectionOnlyTypes
-
 #endif //DACCESS_COMPILE
 
 #if defined(FEATURE_NATIVE_IMAGE_GENERATION) && !defined(DACCESS_COMPILE)
diff --git a/src/vm/typedesc.h b/src/vm/typedesc.h
index 3e8b0e618b..81cc34048b 100644
--- a/src/vm/typedesc.h
+++ b/src/vm/typedesc.h
@@ -651,15 +651,8 @@ public:
     }
 
 #ifndef DACCESS_COMPILE
-    
     // Returns TRUE if all return and argument types are externally visible.
     BOOL IsExternallyVisible() const;
-    // Returns TRUE if any of return or argument types is part of an assembly loaded for introspection.
-    BOOL IsIntrospectionOnly() const;
-    // Returns TRUE if any of return or argument types is part of an assembly loaded for introspection.
-    // Instantiations of generic types are also recursively checked.
-    BOOL ContainsIntrospectionOnlyTypes() const;
-    
 #endif //DACCESS_COMPILE
 
 #ifdef FEATURE_PREJIT
diff --git a/src/vm/typehandle.cpp b/src/vm/typehandle.cpp
index 405be60543..0b3f81f1ce 100644
--- a/src/vm/typehandle.cpp
+++ b/src/vm/typehandle.cpp
@@ -1077,114 +1077,6 @@ BOOL TypeHandle::IsFnPtrType() const
             (GetSignatureCorElementType() == ELEMENT_TYPE_FNPTR));
 }
 
-// Is this type part of an assembly loaded for introspection?
-BOOL 
-TypeHandle::IsIntrospectionOnly() const
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END
-    
-#ifndef DACCESS_COMPILE
-    if (IsFnPtrType())
-    {
-        return AsFnPtrType()->IsIntrospectionOnly();
-    }
-    else if (HasTypeParam())
-    {
-        return GetTypeParam().IsIntrospectionOnly();
-    }
-    else
-    {
-        return GetModule()->IsIntrospectionOnly();
-    }
-#else //DACCESS_COMPILE
-    return FALSE;
-#endif //DACCESS_COMPILE
-} // TypeHandle::IsIntrospectionOnly
-
-// Checks this type and its components for "IsIntrospectionOnly"
-BOOL
-TypeHandle::ContainsIntrospectionOnlyTypes() const
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END
-
-#ifndef DACCESS_COMPILE
-    if (IsFnPtrType())
-    {
-        return AsFnPtrType()->ContainsIntrospectionOnlyTypes();
-    }
-    else if (HasTypeParam())
-    {
-        return GetTypeParam().ContainsIntrospectionOnlyTypes();
-    }
-    else if (IsTypeDesc())
-    {
-        return GetModule()->IsIntrospectionOnly();
-    }
-    else
-    {
-        return AsMethodTable()->ContainsIntrospectionOnlyTypes();
-    }
-#else //DACCESS_COMPILE
-    return FALSE;
-#endif //DACCESS_COMPILE
-} // TypeHandle::ContainsIntrospectionOnlyTypes
-
-// Is this type part of an assembly loaded for introspection?
-BOOL 
-TypeKey::IsIntrospectionOnly()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-    }
-    CONTRACTL_END
-    
-#ifndef DACCESS_COMPILE
-    switch (m_kind)
-    {
-        case ELEMENT_TYPE_CLASS:
-            return u.asClass.m_pModule->IsIntrospectionOnly();
-
-        case ELEMENT_TYPE_ARRAY:
-        case ELEMENT_TYPE_SZARRAY:
-        case ELEMENT_TYPE_PTR:
-        case ELEMENT_TYPE_BYREF:
-            return TypeHandle::FromTAddr(u.asParamType.m_paramType).IsIntrospectionOnly();
-
-        case ELEMENT_TYPE_FNPTR:
-            // Return TRUE if any return/arguments type was loaded for introspection only
-            for (DWORD i = 0; i <= u.asFnPtr.m_numArgs; i++)
-            {
-                if (u.asFnPtr.m_pRetAndArgTypes[i].IsIntrospectionOnly())
-                {
-                    return TRUE;
-                }
-            }
-            // None of return/arguments types was loaded for introspection only
-            return FALSE;
-            
-        default:
-            UNREACHABLE_MSG("Corrupted typekey");
-    }
-#else //DACCESS_COMPILE
-    return FALSE;
-#endif //DACCESS_COMPILE
-} // TypeKey::IsIntrospectionOnly
-
 BOOL TypeHandle::IsRestored_NoLogging() const
 { 
     LIMITED_METHOD_CONTRACT;
diff --git a/src/vm/typehandle.h b/src/vm/typehandle.h
index c8f0747d6a..3364d76e48 100644
--- a/src/vm/typehandle.h
+++ b/src/vm/typehandle.h
@@ -542,12 +542,6 @@ public:
     void CheckRestore() const;
     BOOL IsExternallyVisible() const;
 
-    // Is this type part of an assembly loaded for introspection?
-    BOOL IsIntrospectionOnly() const;
-
-    // Checks this type and its components for "IsIntrospectionOnly"
-    BOOL ContainsIntrospectionOnlyTypes() const;
-
     // Does this type participate in type equivalence?
     inline BOOL HasTypeEquivalence() const;
 
diff --git a/src/vm/typekey.h b/src/vm/typekey.h
index 0d58254d83..22f8abf3c2 100644
--- a/src/vm/typekey.h
+++ b/src/vm/typekey.h
@@ -296,11 +296,6 @@ public:
         return hash;
 #endif
     }
-
-    // Is this type part of an assembly loaded for introspection?
-    BOOL IsIntrospectionOnly();
-
-
 };
 
 
diff --git a/src/vm/typeparse.cpp b/src/vm/typeparse.cpp
index af3fd65876..a6190dd668 100644
--- a/src/vm/typeparse.cpp
+++ b/src/vm/typeparse.cpp
@@ -1098,8 +1098,6 @@ TypeHandle TypeName::GetTypeUsingCASearchRules(LPCWSTR szTypeName, Assembly *pRe
     STATIC_CONTRACT_GC_TRIGGERS;
     STATIC_CONTRACT_FAULT;
 
-    BOOL bIntrospectionOnly = pRequestingAssembly ? pRequestingAssembly->IsIntrospectionOnly() : FALSE; // classfactory loads are always for execution
-
     DWORD error = (DWORD)-1;
 
     GCX_COOP();
@@ -1140,7 +1138,6 @@ TypeHandle TypeName::GetTypeUsingCASearchRules(LPCWSTR szTypeName, Assembly *pRe
     th = pTypeName->GetTypeWorker(
         /*bThrowIfNotFound = */ TRUE, 
         /*bIgnoreCase = */ FALSE, 
-        bIntrospectionOnly, 
         /*pAssemblyGetType =*/ NULL, 
         /*fEnableCASearchRules = */ TRUE, 
         /*fProhibitAsmQualifiedName = */ FALSE, 
@@ -1183,7 +1180,6 @@ TypeHandle TypeName::GetTypeUsingCASearchRules(LPCWSTR szTypeName, Assembly *pRe
     DomainAssembly* pAssemblyGetType, 
     BOOL bThrowIfNotFound, 
     BOOL bIgnoreCase, 
-    BOOL bIntrospectionOnly, 
     BOOL bProhibitAsmQualifiedName,
     StackCrawlMark* pStackMark, 
     BOOL bLoadTypeFromPartialNameHack,
@@ -1231,7 +1227,6 @@ TypeHandle TypeName::GetTypeUsingCASearchRules(LPCWSTR szTypeName, Assembly *pRe
     TypeHandle result = pTypeName->GetTypeWorker(
         bPeriodPrefix ? FALSE : bThrowIfNotFound, 
         bIgnoreCase, 
-        bIntrospectionOnly, 
         pAssemblyGetType ? pAssemblyGetType->GetAssembly() : NULL, 
         /*fEnableCASearchRules = */TRUE, 
         bProhibitAsmQualifiedName, 
@@ -1262,7 +1257,6 @@ TypeHandle TypeName::GetTypeUsingCASearchRules(LPCWSTR szTypeName, Assembly *pRe
         result = pTypeName->GetTypeWorker(
             bThrowIfNotFound, 
             bIgnoreCase, 
-            bIntrospectionOnly, 
             pAssemblyGetType ? pAssemblyGetType->GetAssembly() : NULL, 
             /*fEnableCASearchRules = */TRUE, 
             bProhibitAsmQualifiedName, 
@@ -1326,19 +1320,15 @@ TypeHandle TypeName::GetTypeUsingCASearchRules(LPCWSTR szTypeName, Assembly *pRe
         COMPlusThrow(kArgumentException, IDS_EE_CANNOT_HAVE_ASSEMBLY_SPEC);
     }
 
-    return pTypeName->GetTypeWorker(bThrowIfNotFound, /*bIgnoreCase = */FALSE, pAssembly->IsIntrospectionOnly(), pAssembly, /*fEnableCASearchRules = */FALSE, FALSE, NULL, NULL, 
+    return pTypeName->GetTypeWorker(bThrowIfNotFound, /*bIgnoreCase = */FALSE, pAssembly, /*fEnableCASearchRules = */FALSE, FALSE, NULL, NULL, 
         nullptr, // pPrivHostBinder
         FALSE, NULL /* cannot find a collectible type unless it is in assembly */);
-
-
-    
-
 }
 
 //-------------------------------------------------------------------------------------------
 // Retrieves a type. Will assert if the name is not fully qualified.
 //-------------------------------------------------------------------------------------------
-/* public static */ TypeHandle TypeName::GetTypeFromAsmQualifiedName(LPCWSTR szFullyQualifiedName, BOOL bForIntrospection)
+/* public static */ TypeHandle TypeName::GetTypeFromAsmQualifiedName(LPCWSTR szFullyQualifiedName)
 {
     STATIC_CONTRACT_THROWS;
     STATIC_CONTRACT_GC_TRIGGERS;
@@ -1373,11 +1363,11 @@ TypeHandle TypeName::GetTypeUsingCASearchRules(LPCWSTR szTypeName, Assembly *pRe
         COMPlusThrowArgumentException(msg.GetUnicode(), NULL);
     }
 
-    return pTypeName->GetTypeFromAsm(bForIntrospection);
+    return pTypeName->GetTypeFromAsm();
 }
 
 
-TypeHandle TypeName::GetTypeFromAsm(BOOL bForIntrospection)
+TypeHandle TypeName::GetTypeFromAsm()
 {
     STATIC_CONTRACT_THROWS;
     STATIC_CONTRACT_GC_TRIGGERS;
@@ -1393,7 +1383,6 @@ TypeHandle TypeName::GetTypeFromAsm(BOOL bForIntrospection)
     return this->GetTypeWorker(
         /*bThrowIfNotFound =*/TRUE, 
         /*bIgnoreCase = */FALSE, 
-        bForIntrospection, 
         NULL, 
         /*fEnableCASearchRules = */FALSE, 
         FALSE, 
@@ -1416,7 +1405,6 @@ TypeHandle TypeName::GetTypeFromAsm(BOOL bForIntrospection)
 /* private instance */ TypeHandle TypeName::GetTypeWorker(
     BOOL bThrowIfNotFound, 
     BOOL bIgnoreCase, 
-    BOOL bIntrospectionOnly, 
     Assembly* pAssemblyGetType,
 
     BOOL fEnableCASearchRules,
@@ -1492,7 +1480,7 @@ TypeHandle TypeName::GetTypeFromAsm(BOOL bForIntrospection)
             {
                 DomainAssembly *pDomainAssembly = LoadDomainAssembly(GetAssembly(), pRequestingAssembly, 
                                                                      pPrivHostBinder,
-                                                                     bThrowIfNotFound, bIntrospectionOnly, pssOuterTypeName);
+                                                                     bThrowIfNotFound, pssOuterTypeName);
                 if (pDomainAssembly)
                 {
                     th = GetTypeHaveAssembly(pDomainAssembly->GetAssembly(), bThrowIfNotFound, bIgnoreCase, pKeepAlive);
@@ -1508,7 +1496,7 @@ TypeHandle TypeName::GetTypeFromAsm(BOOL bForIntrospection)
         {
             DomainAssembly *pDomainAssembly = LoadDomainAssembly(GetAssembly(), pRequestingAssembly, 
                                                                  pPrivHostBinder,
-                                                                 bThrowIfNotFound, bIntrospectionOnly, pssOuterTypeName);
+                                                                 bThrowIfNotFound, pssOuterTypeName);
             if (pDomainAssembly)
             {
                 th = GetTypeHaveAssembly(pDomainAssembly->GetAssembly(), bThrowIfNotFound, bIgnoreCase, pKeepAlive);
@@ -1525,14 +1513,6 @@ TypeHandle TypeName::GetTypeFromAsm(BOOL bForIntrospection)
     // Otherwise look in the caller's assembly then the system assembly
     else if (fEnableCASearchRules)
     {
-        if (bIntrospectionOnly)
-        {
-            if (pStackMark != NULL) // This is our test to see if we're being because of a managed api or because we are parsing a CA. 
-            {
-                COMPlusThrow(kArgumentException, IDS_EE_REFLECTIONONLYGETTYPE_NOASSEMBLY);
-            }
-        }
-
         if (!pRequestingAssembly && pStackMark)
             pRequestingAssembly = SystemDomain::GetCallersAssembly(pStackMark); 
         
@@ -1548,7 +1528,7 @@ TypeHandle TypeName::GetTypeFromAsm(BOOL bForIntrospection)
         }
         
         // Raise AssemblyResolveEvent to try to resolve assembly
-        if (th.IsNull() && !bIntrospectionOnly) 
+        if (th.IsNull()) 
         {
             AppDomain *pDomain = (AppDomain *)SystemDomain::GetCurrentDomain();
 
@@ -1603,7 +1583,7 @@ TypeHandle TypeName::GetTypeFromAsm(BOOL bForIntrospection)
         for (INT32 i = 0; i < cGenericArgs; i++)
         {
             TypeHandle thGenericArg = m_genericArguments[i]->GetTypeWorker(
-                bThrowIfNotFound, bIgnoreCase, bIntrospectionOnly, 
+                bThrowIfNotFound, bIgnoreCase,
                 pAssemblyGetType, fEnableCASearchRules, bProhibitAsmQualifiedName, pStackMark, pRequestingAssembly, 
                 pPrivHostBinder,
                 bLoadTypeFromPartialNameHack, 
@@ -1816,7 +1796,6 @@ DomainAssembly * LoadDomainAssembly(
     Assembly * pRequestingAssembly, 
     ICLRPrivBinder * pPrivHostBinder,
     BOOL       bThrowIfNotFound, 
-    BOOL       bIntrospectionOnly, 
     SString *  pssOuterTypeName)
 {
     CONTRACTL
@@ -1830,9 +1809,6 @@ DomainAssembly * LoadDomainAssembly(
     AssemblySpec spec;
     DomainAssembly *pDomainAssembly = NULL;
 
-    if (bIntrospectionOnly)
-        spec.SetIntrospectionOnly(TRUE);
-
     StackScratchBuffer buffer;
     LPCUTF8 szAssemblySpec = psszAssemblySpec->GetUTF8(buffer);
     IfFailThrow(spec.Init(szAssemblySpec));
@@ -1869,7 +1845,7 @@ DomainAssembly * LoadDomainAssembly(
     {
         EX_TRY
         {
-            pDomainAssembly = spec.LoadDomainAssembly(FILE_LOADED, NULL, bThrowIfNotFound);
+            pDomainAssembly = spec.LoadDomainAssembly(FILE_LOADED, bThrowIfNotFound);
         }
         EX_CATCH
         {
diff --git a/src/vm/typeparse.h b/src/vm/typeparse.h
index 0665f906a4..a2ec689814 100644
--- a/src/vm/typeparse.h
+++ b/src/vm/typeparse.h
@@ -50,7 +50,6 @@ DomainAssembly * LoadDomainAssembly(
     Assembly * pRequestingAssembly, 
     ICLRPrivBinder * pPrivHostBinder,
     BOOL       bThrowIfNotFound, 
-    BOOL       bIntrospectionOnly, 
     SString *  pssOuterTypeName);
 
 class TypeNameFactory : public ITypeNameFactory
@@ -323,12 +322,12 @@ public:
     //-------------------------------------------------------------------------------------------
     static TypeHandle GetTypeFromAssembly(LPCWSTR szTypeName, Assembly *pAssembly, BOOL bThrowIfNotFound = TRUE);
 
-    TypeHandle GetTypeFromAsm(BOOL bForIntrospection);
+    TypeHandle GetTypeFromAsm();
 
     //-------------------------------------------------------------------------------------------
     // Retrieves a type. Will assert if the name is not fully qualified.
     //-------------------------------------------------------------------------------------------
-    static TypeHandle GetTypeFromAsmQualifiedName(LPCWSTR szFullyQualifiedName, BOOL bForIntrospection);
+    static TypeHandle GetTypeFromAsmQualifiedName(LPCWSTR szFullyQualifiedName);
 
 
     //-------------------------------------------------------------------------------------------
@@ -366,7 +365,6 @@ public:
         DomainAssembly* pAssemblyGetType,
         BOOL bThrowIfNotFound,
         BOOL bIgnoreCase,
-        BOOL bIntrospectionOnly,
         BOOL bProhibitAssemblyQualifiedName,
         StackCrawlMark* pStackMark,
         BOOL bLoadTypeFromPartialNameHack,
@@ -427,7 +425,6 @@ private:
     TypeHandle GetTypeWorker(
         BOOL bThrowIfNotFound, 
         BOOL bIgnoreCase, 
-        BOOL bIntrospectionOnly, 
         Assembly* pAssemblyGetType,
 
         BOOL fEnableCASearchRules,  
diff --git a/src/vm/typestring.h b/src/vm/typestring.h
index e9b032f8f2..88a218156e 100644
--- a/src/vm/typestring.h
+++ b/src/vm/typestring.h
@@ -54,7 +54,7 @@ public:
 private:
     friend class TypeString;
     friend SString* TypeName::ToString(SString*, BOOL, BOOL, BOOL);
-    friend TypeHandle TypeName::GetTypeWorker(BOOL, BOOL, BOOL, Assembly*, BOOL, BOOL, StackCrawlMark*, Assembly*, 
+    friend TypeHandle TypeName::GetTypeWorker(BOOL, BOOL, Assembly*, BOOL, BOOL, StackCrawlMark*, Assembly*, 
         ICLRPrivBinder * pPrivHostBinder,
         BOOL, OBJECTREF *);
     HRESULT OpenGenericArguments(); 
diff --git a/src/vm/zapsig.cpp b/src/vm/zapsig.cpp
index fedc9483c5..32ddd7ae59 100644
--- a/src/vm/zapsig.cpp
+++ b/src/vm/zapsig.cpp
@@ -663,8 +663,7 @@ Module *ZapSig::DecodeModuleFromIndexes(Module *fromModule,
                 AssemblySpec spec;
                 spec.InitializeSpec(TokenFromRid(assemblyIndex, mdtAssemblyRef),
                                     fromModule->GetNativeAssemblyImport(),
-                                    NULL,
-                                    FALSE);
+                                    NULL);
 
                 pAssembly = spec.LoadAssembly(FILE_LOADED);