diff --git a/Src/Compilers/CSharp/Portable/Symbols/ReferenceManager.cs b/Src/Compilers/CSharp/Portable/Symbols/ReferenceManager.cs
index 2ca34607b153e5e51454f1efeaad8c4376bdaf00..f67d2290305329563c6b82f6bb498ef79516ea2a 100644
--- a/Src/Compilers/CSharp/Portable/Symbols/ReferenceManager.cs
+++ b/Src/Compilers/CSharp/Portable/Symbols/ReferenceManager.cs
@@ -237,7 +237,7 @@ public PEAssemblySymbol CreatePEAssemblyForAssemblyMetadata(AssemblyMetadata met
                     referencedAssembliesByIdentity.Add(symbol.Identity, symbol);
                 }
 
-                var assembly = metadata.Assembly;
+                var assembly = metadata.GetAssembly();
                 var peReferences = assembly.AssemblyReferences.SelectAsArray(MapAssemblyIdentityToResolvedSymbol, referencedAssembliesByIdentity);
                 var assemblySymbol = new PEAssemblySymbol(assembly, DocumentationProvider.Default, isLinked: false, importOptions: importOptions);
 
diff --git a/Src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Assembly.cs b/Src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Assembly.cs
index 9a509e5559d829d6cea51102941950a1cdec39f1..76e2431c244dad7f0f4665d49045b362392e38e7 100644
--- a/Src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Assembly.cs
+++ b/Src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_Assembly.cs
@@ -947,7 +947,7 @@ class Program
 
             var exeMetadata = AssemblyMetadata.CreateFromImage(consoleappCompilation.EmitToArray());
 
-            peModule = exeMetadata.Assembly.ManifestModule; 
+            peModule = exeMetadata.GetAssembly().ManifestModule; 
             metadataReader = peModule.GetMetadataReader();
 
             Assert.Equal(1, metadataReader.GetTableRowCount(TableIndex.ModuleRef));
diff --git a/Src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/AssemblyReferencesTests.cs b/Src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/AssemblyReferencesTests.cs
index 15c719accfb5dc56a71aecaa844c5a44d86a07e4..a2825181233b8b967979c20403dee6591a00fe26 100644
--- a/Src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/AssemblyReferencesTests.cs
+++ b/Src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/AssemblyReferencesTests.cs
@@ -53,7 +53,7 @@ class C
             var c1 = CreateCompilation(src1, references);
             var c2 = CreateCompilation(src2, references);
             var md1 = AssemblyMetadata.CreateFromImageStream(c1.EmitToStream());
-            var baseline = EmitBaseline.CreateInitialBaseline(md1.ManifestModule, handle => ImmutableArray.Create<string>());
+            var baseline = EmitBaseline.CreateInitialBaseline(md1.GetModules()[0], handle => ImmutableArray.Create<string>());
 
             var mdStream = new MemoryStream();
             var ilStream = new MemoryStream();
@@ -122,7 +122,7 @@ class C
 
             var c1 = CreateCompilation(src1, new[] { MscorlibRef });
             var c2 = CreateCompilation(src2, new[] { MscorlibRef });
-            var baseline = EmitBaseline.CreateInitialBaseline(md1.ManifestModule, handle => ImmutableArray.Create<string>());
+            var baseline = EmitBaseline.CreateInitialBaseline(md1.GetModules()[0], handle => ImmutableArray.Create<string>());
 
             var mdStream = new MemoryStream();
             var ilStream = new MemoryStream();
diff --git a/Src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTests.cs b/Src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTests.cs
index abad8a11f79e4005a33b41914ff3599cf257eda3..61cf1516187fb367b318ff643e7578902693014a 100644
--- a/Src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTests.cs
+++ b/Src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTests.cs
@@ -3934,7 +3934,7 @@ static object F()
             var compilation0 = CreateCompilationWithMscorlib(source0, options: TestOptions.DebugDll);
             var compilation1 = CreateCompilationWithMscorlib(source1, options: TestOptions.DebugDll);
 
-            var moduleMetadata0 = ((AssemblyMetadata)metadata0.GetMetadata()).Modules[0];
+            var moduleMetadata0 = ((AssemblyMetadata)metadata0.GetMetadata()).GetModules()[0];
             var method0 = compilation0.GetMember<MethodSymbol>("C.F");
             var generation0 = EmitBaseline.CreateInitialBaseline(
             moduleMetadata0,
@@ -4623,7 +4623,7 @@ static object F(System.IDisposable d)
             var compilation0 = CreateCompilationWithMscorlib(source, options: TestOptions.DebugDll);
             var compilation1 = CreateCompilationWithMscorlib(source, options: TestOptions.DebugDll);
 
-            var moduleMetadata0 = ((AssemblyMetadata)metadata0.GetMetadata()).Modules[0];
+            var moduleMetadata0 = ((AssemblyMetadata)metadata0.GetMetadata()).GetModules()[0];
             var method0 = compilation0.GetMember<MethodSymbol>("C.F");
             var generation0 = EmitBaseline.CreateInitialBaseline(
                 moduleMetadata0,
diff --git a/Src/Compilers/CSharp/Test/Emit/Emit/EmitMetadata.cs b/Src/Compilers/CSharp/Test/Emit/Emit/EmitMetadata.cs
index e0c02619eef6a081fa3d869dcb4c84a65f8c0c82..bf8b185fd855b8a5a8dc37f9b782552dbce4946d 100644
--- a/Src/Compilers/CSharp/Test/Emit/Emit/EmitMetadata.cs
+++ b/Src/Compilers/CSharp/Test/Emit/Emit/EmitMetadata.cs
@@ -245,7 +245,7 @@ public void AssemblyRefs_DuplicateRows()
             context.Diagnostics.Verify();
 
             // check that there are no duplicate rows in AssemblyRef table:
-            PEAssembly emittedAssembly = AssemblyMetadata.CreateFromImage(image).Assembly;
+            PEAssembly emittedAssembly = AssemblyMetadata.CreateFromImage(image).GetAssembly();
             var emittedReferences = emittedAssembly.Modules[0].ReferencedAssemblies;
             Assert.Equal(1, emittedReferences.Length);
             Assert.Equal("foo", emittedReferences[0].Name);
diff --git a/Src/Compilers/CSharp/Test/Symbol/Compilation/ReferenceManagerTests.cs b/Src/Compilers/CSharp/Test/Symbol/Compilation/ReferenceManagerTests.cs
index aa9358a0d04bf4aa9c641300b40827e002355a34..7490b5ec9c871e617ac57a0714a8fb1a438c5a98 100644
--- a/Src/Compilers/CSharp/Test/Symbol/Compilation/ReferenceManagerTests.cs
+++ b/Src/Compilers/CSharp/Test/Symbol/Compilation/ReferenceManagerTests.cs
@@ -1683,7 +1683,7 @@ public class PrintTicket
             AssemblyIdentity actualIdentity = method.ReturnType.ContainingAssembly.Identity;
 
             // Even though the compilation has the correct version number, the referenced binary is preferred.
-            Assert.Equal(oldMetadata.Assembly.Identity, actualIdentity);
+            Assert.Equal(oldMetadata.GetAssembly().Identity, actualIdentity);
             Assert.NotEqual(comp.Assembly.Identity, actualIdentity);
         }
 
@@ -1802,7 +1802,7 @@ class D
             Assert.Equal(comp1.Assembly, moduleSymbol1.ContainingAssembly);
 
             var moduleReferences1 = moduleSymbol1.GetReferencedAssemblies();
-            Assert.Contains(assemblyMetadata.Assembly.Identity, moduleReferences1);
+            Assert.Contains(assemblyMetadata.GetAssembly().Identity, moduleReferences1);
 
             var moduleTypeSymbol1 = comp1.GlobalNamespace.GetMember<NamedTypeSymbol>("TypeFromModule");
             Assert.Equal(moduleSymbol1, moduleTypeSymbol1.ContainingModule);
diff --git a/Src/Compilers/CSharp/Test/Symbol/Symbols/MetadataCacheTests.cs b/Src/Compilers/CSharp/Test/Symbol/Symbols/MetadataCacheTests.cs
index 160c43ee8cae5d24827638d6465e49ae7e9f18e8..ea1d8a9f3b81a6e99b9e43285a65747e3bf05bf9 100644
--- a/Src/Compilers/CSharp/Test/Symbol/Symbols/MetadataCacheTests.cs
+++ b/Src/Compilers/CSharp/Test/Symbol/Symbols/MetadataCacheTests.cs
@@ -111,7 +111,7 @@ private ObjectReference GetWeakAssemblyFromCache(FileKey fileKey)
 
             Assert.Equal(2, mdTestLib1.CachedSymbols.Count());
 
-            object assembly = mdTestLib1.Metadata.GetTarget().Assembly;
+            object assembly = mdTestLib1.Metadata.GetTarget().GetAssembly();
             Assert.NotNull(assembly);
             return new ObjectReference(assembly);
         }
@@ -176,7 +176,7 @@ public void CompilationWithMscorlibReference()
 
                 Assert.Equal(mscorlibPath, MetadataCache.AssembliesFromFiles.Keys.Single().FullPath, StringComparer.OrdinalIgnoreCase);
 
-                var assembly = cachedAssembly.Metadata.GetTarget().Assembly;
+                var assembly = cachedAssembly.Metadata.GetTarget().GetAssembly();
                 Assert.NotNull(assembly);
 
                 Assert.Equal("mscorlib", assembly.Identity.Name);
@@ -188,7 +188,7 @@ public void CompilationWithMscorlibReference()
                 var mscorlibAsm = (PEAssemblySymbol)cachedAssembly.CachedSymbols.First();
 
                 Assert.NotNull(mscorlibAsm);
-                Assert.Same(mscorlibAsm.Assembly, cachedAssembly.Metadata.GetTarget().Assembly);
+                Assert.Same(mscorlibAsm.Assembly, cachedAssembly.Metadata.GetTarget().GetAssembly());
                 Assert.Equal("mscorlib", mscorlibAsm.Identity.Name);
                 Assert.Equal("mscorlib", mscorlibAsm.Name);
                 Assert.Equal(1, mscorlibAsm.Modules.Length);
@@ -583,7 +583,7 @@ public void ReferenceModule()
                 Assert.Same(mscorlibInfo.CachedSymbols.First(), mscorlibAsm);
 
                 var varMTTestLib1Info = MetadataCache.AssembliesFromFiles[FileKey.Create(varMTTestLib1Path)];
-                var assembly = varMTTestLib1Info.Metadata.GetTarget().Assembly;
+                var assembly = varMTTestLib1Info.Metadata.GetTarget().GetAssembly();
                 Assert.NotNull(assembly);
                 Assert.Equal(1, varMTTestLib1Info.CachedSymbols.Count());
 
@@ -850,7 +850,7 @@ public void ReferenceMultiModuleAssembly()
 
                 var fileInfo = MetadataCache.AssembliesFromFiles[FileKey.Create(multimoduleRef.FilePath)];
 
-                var assembly = fileInfo.Metadata.GetTarget().Assembly;
+                var assembly = fileInfo.Metadata.GetTarget().GetAssembly();
 
                 // tc1 compilation is holding on the Assembly:
                 Assert.NotNull(assembly);
@@ -1336,7 +1336,7 @@ public void CompactFileCache2()
             lock (MetadataCache.Guard)
             {
                 Assert.Equal(1, mdTestLib1.CachedSymbols.Count());
-                Assert.NotNull(mdTestLib1.Metadata.GetTarget().Assembly);
+                Assert.NotNull(mdTestLib1.Metadata.GetTarget().GetAssembly());
                 Assert.False(mdTestLib1.CachedSymbols.GetWeakReference(0).IsNull());
                 Assert.Same(mdTestLib1.Metadata, MetadataCache.AssembliesFromFiles[fileKey].Metadata);
 
diff --git a/Src/Compilers/Core/CodeAnalysisTest/MetadataReferences/AssemblyMetadataTests.cs b/Src/Compilers/Core/CodeAnalysisTest/MetadataReferences/AssemblyMetadataTests.cs
index 8be9045769c5ece921d16eceb937e6c4ce650a1f..87b7964f6695669d9990a998f4dcf79c17b7e17e 100644
--- a/Src/Compilers/Core/CodeAnalysisTest/MetadataReferences/AssemblyMetadataTests.cs
+++ b/Src/Compilers/Core/CodeAnalysisTest/MetadataReferences/AssemblyMetadataTests.cs
@@ -42,8 +42,8 @@ public void CreateFromBytes()
             using (var a = AssemblyMetadata.CreateFromImage(TestResources.SymbolsTests.MultiModule.MultiModule))
             {
                 // even though the image refers to other modules only the manifest module is loaded:
-                Assert.Equal(1, a.Modules.Length);
-                Assert.Equal("MultiModule.dll", a.Modules[0].Name);
+                Assert.Equal(1, a.GetModules().Length);
+                Assert.Equal("MultiModule.dll", a.GetModules()[0].Name);
             }
         }
 
@@ -57,10 +57,10 @@ public void CreateFromFile()
 
             using (var a = MetadataFileFactory.CreateAssembly(mm))
             {
-                Assert.Equal(3, a.Modules.Length);
-                Assert.Equal("MultiModule.dll", a.Modules[0].Name);
-                Assert.Equal("mod2.netmodule", a.Modules[1].Name);
-                Assert.Equal("mod3.netmodule", a.Modules[2].Name);
+                Assert.Equal(3, a.GetModules().Length);
+                Assert.Equal("MultiModule.dll", a.GetModules()[0].Name);
+                Assert.Equal("mod2.netmodule", a.GetModules()[1].Name);
+                Assert.Equal("mod3.netmodule", a.GetModules()[2].Name);
             }
         }
         
@@ -96,54 +96,53 @@ public void ImageOwnership()
 
             var copy1 = a.Copy();
             Assert.False(copy1.IsImageOwner, "Assembly should not own the image");
-            Assert.False(copy1.Modules[0].IsImageOwner, "Module should not own the image");
-            Assert.False(copy1.Modules[1].IsImageOwner, "Module should not own the image");
-            Assert.False(copy1.Modules[2].IsImageOwner, "Module should not own the image");
+            Assert.False(copy1.GetModules()[0].IsImageOwner, "Module should not own the image");
+            Assert.False(copy1.GetModules()[1].IsImageOwner, "Module should not own the image");
+            Assert.False(copy1.GetModules()[2].IsImageOwner, "Module should not own the image");
 
-            Assert.Equal(m1.Module, copy1.Modules[0].Module);
-            Assert.Equal(m2.Module, copy1.Modules[1].Module);
-            Assert.Equal(m3.Module, copy1.Modules[2].Module);
+            Assert.Equal(m1.Module, copy1.GetModules()[0].Module);
+            Assert.Equal(m2.Module, copy1.GetModules()[1].Module);
+            Assert.Equal(m3.Module, copy1.GetModules()[2].Module);
 
             var copy2 = copy1.Copy();
             Assert.False(copy2.IsImageOwner, "Assembly should not own the image");
-            Assert.False(copy2.Modules[0].IsImageOwner, "Module should not own the image");
-            Assert.False(copy2.Modules[1].IsImageOwner, "Module should not own the image");
-            Assert.False(copy2.Modules[2].IsImageOwner, "Module should not own the image");
+            Assert.False(copy2.GetModules()[0].IsImageOwner, "Module should not own the image");
+            Assert.False(copy2.GetModules()[1].IsImageOwner, "Module should not own the image");
+            Assert.False(copy2.GetModules()[2].IsImageOwner, "Module should not own the image");
 
-            Assert.Equal(m1.Module, copy2.Modules[0].Module);
-            Assert.Equal(m2.Module, copy2.Modules[1].Module);
-            Assert.Equal(m3.Module, copy2.Modules[2].Module);
+            Assert.Equal(m1.Module, copy2.GetModules()[0].Module);
+            Assert.Equal(m2.Module, copy2.GetModules()[1].Module);
+            Assert.Equal(m3.Module, copy2.GetModules()[2].Module);
 
             copy1.Dispose();
-            Assert.Throws<ObjectDisposedException>(() => copy1.Modules[0].Module);
-            Assert.Throws<ObjectDisposedException>(() => copy1.Modules[1].Module);
-            Assert.Throws<ObjectDisposedException>(() => copy1.Modules[2].Module);
+            Assert.Throws<ObjectDisposedException>(() => copy1.GetModules()[0].Module);
+            Assert.Throws<ObjectDisposedException>(() => copy1.GetModules()[1].Module);
+            Assert.Throws<ObjectDisposedException>(() => copy1.GetModules()[2].Module);
 
-            Assert.NotNull(a.Modules[0].Module);
-            Assert.NotNull(a.Modules[1].Module);
-            Assert.NotNull(a.Modules[2].Module);
+            Assert.NotNull(a.GetModules()[0].Module);
+            Assert.NotNull(a.GetModules()[1].Module);
+            Assert.NotNull(a.GetModules()[2].Module);
 
             a.Dispose();
 
-            Assert.Throws<ObjectDisposedException>(() => a.Modules[0].Module);
-            Assert.Throws<ObjectDisposedException>(() => a.Modules[1].Module);
-            Assert.Throws<ObjectDisposedException>(() => a.Modules[2].Module);
+            Assert.Throws<ObjectDisposedException>(() => a.GetModules()[0].Module);
+            Assert.Throws<ObjectDisposedException>(() => a.GetModules()[1].Module);
+            Assert.Throws<ObjectDisposedException>(() => a.GetModules()[2].Module);
         }
 
         [Fact]
         public void BadImageFormat()
         {
             var invalidModuleName = Temp.CreateFile().WriteAllBytes(TestResources.MetadataTests.Invalid.InvalidModuleName);
-            Assert.Throws<BadImageFormatException>(() => MetadataFileFactory.CreateAssembly(invalidModuleName.Path));
+            var metadata = MetadataFileFactory.CreateAssembly(invalidModuleName.Path);
+            Assert.Throws<BadImageFormatException>(() => metadata.GetModules());
         }
 
         [Fact, WorkItem(547015, "DevDiv")]
         public void IncorrectCustomAssemblyTableSize_TooManyMethodSpecs()
         {
-            Assert.Throws<BadImageFormatException>(() =>
-            {
-                AssemblyMetadata.CreateFromImage(TestResources.MetadataTests.Invalid.IncorrectCustomAssemblyTableSize_TooManyMethodSpecs);
-            });
+            var metadata = AssemblyMetadata.CreateFromImage(TestResources.MetadataTests.Invalid.IncorrectCustomAssemblyTableSize_TooManyMethodSpecs);
+            Assert.Throws<BadImageFormatException>(() => metadata.GetModules());
         }
     }
 }
diff --git a/Src/Compilers/Core/CodeAnalysisTest/MetadataReferences/MetadataReferenceTests.cs b/Src/Compilers/Core/CodeAnalysisTest/MetadataReferences/MetadataReferenceTests.cs
index 3ede5297dde5240291ced8b4b41e2dcd7529f62e..3086393a17b388c83e48b32a98ffc160e8a25abd 100644
--- a/Src/Compilers/Core/CodeAnalysisTest/MetadataReferences/MetadataReferenceTests.cs
+++ b/Src/Compilers/Core/CodeAnalysisTest/MetadataReferences/MetadataReferenceTests.cs
@@ -338,7 +338,7 @@ public void MetadataImageReferenceFromStream()
             r = new MetadataImageReference(new MemoryStream(TestResources.SymbolsTests.General.C1, writable: false));
             Assert.Equal("<in-memory assembly>".NeedsLocalization(), r.Display);
 
-            Assert.Equal("C, Version=1.0.0.0, Culture=neutral, PublicKeyToken=374d0c2befcd8cc9", ((AssemblyMetadata)r.GetMetadata()).Assembly.Identity.GetDisplayName());
+            Assert.Equal("C, Version=1.0.0.0, Culture=neutral, PublicKeyToken=374d0c2befcd8cc9", ((AssemblyMetadata)r.GetMetadata()).GetAssembly().Identity.GetDisplayName());
         }
 
     }
diff --git a/Src/Compilers/Core/CodeAnalysisTest/MetadataReferences/ModuleMetadataTests.cs b/Src/Compilers/Core/CodeAnalysisTest/MetadataReferences/ModuleMetadataTests.cs
index c095dfc91b259c0998e9c124bcb5adebb676547a..456a0bd881dd667c89c0490e04b1583831329873 100644
--- a/Src/Compilers/Core/CodeAnalysisTest/MetadataReferences/ModuleMetadataTests.cs
+++ b/Src/Compilers/Core/CodeAnalysisTest/MetadataReferences/ModuleMetadataTests.cs
@@ -22,13 +22,11 @@ public unsafe void CreateFromMetadata_Errors()
             Assert.Throws<ArgumentOutOfRangeException>(() => { fixed (byte* ptr = new byte[] { 1, 2, 3 }) ModuleMetadata.CreateFromMetadata((IntPtr)ptr, 0); });
             Assert.Throws<ArgumentOutOfRangeException>(() => { fixed (byte* ptr = new byte[] { 1, 2, 3 }) ModuleMetadata.CreateFromMetadata((IntPtr)ptr, -1); });
 
-            Assert.Throws<BadImageFormatException>(() =>
+            fixed (byte* ptr = new byte[] { 1, 2, 3 })
             {
-                fixed (byte* ptr = new byte[] { 1, 2, 3 })
-                {
-                    ModuleMetadata.CreateFromMetadata((IntPtr)ptr, 3);
-                }
-            });
+                var metadata = ModuleMetadata.CreateFromMetadata((IntPtr)ptr, 3);
+                Assert.Throws<BadImageFormatException>(() => metadata.GetModuleNames());
+            }
         }
 
         [Fact]
diff --git a/Src/Compilers/Core/CodeAnalysisTest/MetadataReferences/ModuleNoPiaTests.cs b/Src/Compilers/Core/CodeAnalysisTest/MetadataReferences/ModuleNoPiaTests.cs
index 800c510d75165fd587ee32a81c53a28fa4e8c0cf..27aabc54d42241b8759c88bf9beea99c9b09193b 100644
--- a/Src/Compilers/Core/CodeAnalysisTest/MetadataReferences/ModuleNoPiaTests.cs
+++ b/Src/Compilers/Core/CodeAnalysisTest/MetadataReferences/ModuleNoPiaTests.cs
@@ -14,9 +14,9 @@ public void ContainsNoPiaLocalTypes()
                                     metadata1 = AssemblyMetadata.CreateFromImage(TestResources.SymbolsTests.NoPia.LocalTypes1),
                                     metadata2 = AssemblyMetadata.CreateFromImage(TestResources.SymbolsTests.NoPia.LocalTypes2))
             {
-                var pia1 = piaMetadata.Assembly.Modules[0];
-                var localTypes1 = metadata1.Assembly.Modules[0];
-                var localTypes2 = metadata2.Assembly.Modules[0];
+                var pia1 = piaMetadata.GetAssembly().Modules[0];
+                var localTypes1 = metadata1.GetAssembly().Modules[0];
+                var localTypes2 = metadata2.GetAssembly().Modules[0];
 
                 Assert.False(pia1.ContainsNoPiaLocalTypes());
                 Assert.False(pia1.ContainsNoPiaLocalTypes());
diff --git a/Src/Compilers/Core/Desktop/AnalyzerFileReference.cs b/Src/Compilers/Core/Desktop/AnalyzerFileReference.cs
index 8896fee0652859c99a78b0679036d6ba8397a0d6..7175ae627814359900ef67eccaacbfa078df0143 100644
--- a/Src/Compilers/Core/Desktop/AnalyzerFileReference.cs
+++ b/Src/Compilers/Core/Desktop/AnalyzerFileReference.cs
@@ -198,8 +198,7 @@ internal void AddAnalyzers(ImmutableArray<DiagnosticAnalyzer>.Builder builder, s
 
                 analyzerAssembly = GetAssembly();
             }
-            catch (Exception e) if (e is FileLoadException || e is FileNotFoundException || e is BadImageFormatException ||
-                                    e is SecurityException || e is ArgumentException || e is PathTooLongException)
+            catch (Exception e) if (e is IOException || e is BadImageFormatException || e is SecurityException || e is ArgumentException)
             {
                 this.AnalyzerLoadFailed?.Invoke(this, new AnalyzerLoadFailureEventArgs(AnalyzerLoadFailureEventArgs.FailureErrorCode.UnableToLoadAnalyzer, e, null));
                 return;
@@ -285,11 +284,13 @@ private IEnumerable<DiagnosticAnalyzer> GetAnalyzersForTypeNames(Assembly analyz
         /// <summary>
         /// Opens the analyzer dll with the metadata reader and builds a map of language -> analyzer type names.
         /// </summary>
+        /// <exception cref="BadImageFormatException">The PE image format is invalid.</exception>
+        /// <exception cref="IOException">IO error reading the metadata.</exception>
         private static ImmutableDictionary<string, ImmutableHashSet<string>> GetAnalyzerTypeNameMap(string fullPath)
         {
             using (var assembly = MetadataFileFactory.CreateAssembly(fullPath))
             {
-                var typeNameMap = from module in assembly.Modules
+                var typeNameMap = from module in assembly.GetModules()
                                   from typeDefHandle in module.MetadataReader.TypeDefinitions
                                   let typeDef = module.MetadataReader.GetTypeDefinition(typeDefHandle)
                                   let typeName = GetFullyQualifiedTypeName(typeDef, module.Module)
@@ -330,7 +331,7 @@ private static string GetSupportedLanguage(PEModule peModule, CustomAttributeHan
             // Single string parameter
             if (argsReader.Length > 4)
             {
-                // check prolog
+                // check prologue
                 if (argsReader.ReadByte() == 1 && argsReader.ReadByte() == 0)
                 {
                     string languageName;
diff --git a/Src/Compilers/Core/Desktop/AssemblyMetadata.FromFile.cs b/Src/Compilers/Core/Desktop/AssemblyMetadata.FromFile.cs
index dd9aeadba0952cc01bdf8250e36e6ca406c0a3c0..bd53751f57f084b789daf32c5a4e0e8feaeb26e4 100644
--- a/Src/Compilers/Core/Desktop/AssemblyMetadata.FromFile.cs
+++ b/Src/Compilers/Core/Desktop/AssemblyMetadata.FromFile.cs
@@ -7,7 +7,7 @@
 
 namespace Microsoft.CodeAnalysis
 {
-    public static partial class MetadataFileFactory
+    public static partial class MetadataFileFactory // TODO: split to AssemblyMetadataFactory and ModuleMetadataFactory
     {
         /// <summary>
         /// Finds all modules of an assembly on a specified path and builds an instance of <see cref="AssemblyMetadata"/> that represents them.
@@ -18,33 +18,15 @@ public static partial class MetadataFileFactory
         /// <exception cref="IOException">Error reading file <paramref name="fullPath"/>. See <see cref="Exception.InnerException"/> for details.</exception>
         public static AssemblyMetadata CreateAssembly(string fullPath)
         {
-            CompilerPathUtilities.RequireAbsolutePath(fullPath, "fullPath");
+            CompilerPathUtilities.RequireAbsolutePath(fullPath, nameof(fullPath));
 
-            return new AssemblyMetadata(CreateModulesFromFile(fullPath));
+            return new AssemblyMetadata(CreateModule(fullPath), moduleName => CreateModuleFromFile(fullPath, moduleName));
         }
 
-        private static ImmutableArray<ModuleMetadata> CreateModulesFromFile(string fullPath)
+        /// <exception cref="IOException">Error reading file <paramref name="fullPath"/>. See <see cref="Exception.InnerException"/> for details.</exception>
+        private static ModuleMetadata CreateModuleFromFile(string fullPath, string moduleName)
         {
-            ArrayBuilder<ModuleMetadata> moduleBuilder = null;
-
-            // if the file isn't an assembly manifest module an error will be reported later
-            ModuleMetadata manifestModule = CreateModule(fullPath);
-
-            string assemblyDir = null;
-            foreach (string moduleName in manifestModule.GetModuleNames())
-            {
-                if (moduleBuilder == null)
-                {
-                    moduleBuilder = ArrayBuilder<ModuleMetadata>.GetInstance();
-                    moduleBuilder.Add(manifestModule);
-                    assemblyDir = Path.GetDirectoryName(fullPath);
-                }
-
-                var module = CreateModule(PathUtilities.CombineAbsoluteAndRelativePaths(assemblyDir, moduleName));
-                moduleBuilder.Add(module);
-            }
-
-            return (moduleBuilder != null) ? moduleBuilder.ToImmutableAndFree() : ImmutableArray.Create(manifestModule);
+            return CreateModule(PathUtilities.CombineAbsoluteAndRelativePaths(Path.GetDirectoryName(fullPath), moduleName));
         }
     }
 }
diff --git a/Src/Compilers/Core/Desktop/CommandLine/CommonCompiler.ExistingReferencesResolver.cs b/Src/Compilers/Core/Desktop/CommandLine/CommonCompiler.ExistingReferencesResolver.cs
index 9064d49b02d898cbbde676e8cbd6c61083e285fe..5d7997371d7944fc378342b5f6453633e99691aa 100644
--- a/Src/Compilers/Core/Desktop/CommandLine/CommonCompiler.ExistingReferencesResolver.cs
+++ b/Src/Compilers/Core/Desktop/CommandLine/CommonCompiler.ExistingReferencesResolver.cs
@@ -57,7 +57,7 @@ private string ResolveAssemblyName(string displayName)
             {
                 foreach (var fileReference in availableReferences)
                 {
-                    var identity = ((AssemblyMetadata)fileReference.GetMetadata()).Assembly.Identity;
+                    var identity = ((AssemblyMetadata)fileReference.GetMetadata()).GetAssembly().Identity;
                     if (assemblyIdentityComparer.ReferenceMatchesDefinition(displayName, identity))
                     {
                         return fileReference.FilePath;
diff --git a/Src/Compilers/Core/Desktop/ModuleMetadata.FromFile.cs b/Src/Compilers/Core/Desktop/ModuleMetadata.FromFile.cs
index e263283a1d1e1755ceb3a1f477248741473bea61..1d3e25016b349f348eea7d1fc6113d5d4f85622a 100644
--- a/Src/Compilers/Core/Desktop/ModuleMetadata.FromFile.cs
+++ b/Src/Compilers/Core/Desktop/ModuleMetadata.FromFile.cs
@@ -18,8 +18,7 @@ public static partial class MetadataFileFactory
         /// </remarks>
         /// <exception cref="ArgumentNullException"><paramref name="fullPath"/> is null.</exception>
         /// <exception cref="ArgumentException"><paramref name="fullPath"/> is not a valid absolute path.</exception>
-        /// <exception cref="BadImageFormatException">The PE image format is invalid.</exception>
-        /// <exception cref="IOException">Error reading file <paramref name="fullPath"/>. See <see cref="Exception.InnerException"/> for details.</exception>
+        /// <exception cref="IOException">Error opening file <paramref name="fullPath"/>. See <see cref="Exception.InnerException"/> for details.</exception>
         /// <exception cref="FileNotFoundException">File <paramref name="fullPath"/> not found.</exception>
         public static ModuleMetadata CreateModule(string fullPath)
         {
diff --git a/Src/Compilers/Core/Portable/MetadataReader/PEModule.cs b/Src/Compilers/Core/Portable/MetadataReader/PEModule.cs
index 28606a5f263f3cae3908b441c37109772c308943..81db705ef12b04f145b51347b84b9bf51e79eec6 100644
--- a/Src/Compilers/Core/Portable/MetadataReader/PEModule.cs
+++ b/Src/Compilers/Core/Portable/MetadataReader/PEModule.cs
@@ -23,7 +23,11 @@ namespace Microsoft.CodeAnalysis
     /// </summary>
     internal sealed class PEModule : IDisposable
     {
+        // Either we have PEReader or we have pointer and size of the metadata blob:
         private readonly PEReader peReaderOpt;
+        private readonly IntPtr metadataPointerOpt;
+        private readonly int metadataSizeOpt;
+
         private MetadataReader lazyMetadataReader;
 
         private ImmutableArray<AssemblyIdentity> lazyAssemblyReferences;
@@ -71,14 +75,16 @@ internal sealed class PEModule : IDisposable
         private static readonly AttributeValueExtractor<ObsoleteAttributeData> AttributeObsoleteDataExtractor = CrackObsoleteAttributeData;
         private static readonly AttributeValueExtractor<ObsoleteAttributeData> AttributeDeprecatedDataExtractor = CrackDeprecatedAttributeData;
 
-        internal PEModule(PEReader peReader, MetadataReader metadataReader)
+        internal PEModule(PEReader peReader, IntPtr metadataOpt, int metadataSizeOpt)
         {
             // shall not throw
 
-            Debug.Assert((peReader == null) ^ (metadataReader == null));
+            Debug.Assert((peReader == null) ^ (metadataOpt == IntPtr.Zero && metadataSizeOpt == 0));
+            Debug.Assert(metadataOpt == IntPtr.Zero || metadataSizeOpt > 0);
 
             this.peReaderOpt = peReader;
-            this.lazyMetadataReader = metadataReader;
+            this.metadataPointerOpt = metadataOpt;
+            this.metadataSizeOpt = metadataSizeOpt;
             this.lazyTypeNameCollection = new Lazy<IdentifierCollection>(ComputeTypeNameCollection);
             this.lazyNamespaceNameCollection = new Lazy<IdentifierCollection>(ComputeNamespaceNameCollection);
             this.hashesOpt = (peReader != null) ? new PEHashProvider(peReader) : null;
@@ -141,14 +147,24 @@ internal MetadataReader MetadataReader
             {
                 if (lazyMetadataReader == null)
                 {
-                    // PEModule is either created with metadata reader or PE reader.
-                    Debug.Assert(peReaderOpt != null);
-                    if (!peReaderOpt.HasMetadata)
+                    MetadataReader newReader;
+
+                    // PEModule is either created with metadata memory block or a PE reader.
+                    if (metadataPointerOpt != IntPtr.Zero)
+                    {
+                        newReader = new MetadataReader(metadataPointerOpt, metadataSizeOpt, MetadataReaderOptions.ApplyWindowsRuntimeProjections, stringInterner: StringTable.AddShared);
+                    }
+                    else
                     {
-                        throw new BadImageFormatException(CodeAnalysisResources.PEImageDoesntContainManagedMetadata);
+                        Debug.Assert(peReaderOpt != null);
+                        if (!peReaderOpt.HasMetadata)
+                        {
+                            throw new BadImageFormatException(CodeAnalysisResources.PEImageDoesntContainManagedMetadata);
+                        }
+
+                        newReader = peReaderOpt.GetMetadataReader(MetadataReaderOptions.ApplyWindowsRuntimeProjections, stringInterner: StringTable.AddShared);
                     }
 
-                    var newReader = peReaderOpt.GetMetadataReader(MetadataReaderOptions.ApplyWindowsRuntimeProjections, stringInterner: StringTable.AddShared);
                     Interlocked.CompareExchange(ref lazyMetadataReader, newReader, null);
                 }
 
diff --git a/Src/Compilers/Core/Portable/MetadataReference/AssemblyMetadata.cs b/Src/Compilers/Core/Portable/MetadataReference/AssemblyMetadata.cs
index eb14812c358f640f4e09572bd9c058b698f8f6de..5d44a82eec9550908e21456044cf3a81d26ad203 100644
--- a/Src/Compilers/Core/Portable/MetadataReference/AssemblyMetadata.cs
+++ b/Src/Compilers/Core/Portable/MetadataReference/AssemblyMetadata.cs
@@ -6,6 +6,8 @@
 using System.IO;
 using System.Reflection.Metadata;
 using System.Reflection.PortableExecutable;
+using System.Threading;
+using System.Diagnostics;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis
@@ -15,12 +17,49 @@ namespace Microsoft.CodeAnalysis
     /// </summary>
     public sealed class AssemblyMetadata : Metadata
     {
+        private sealed class Data
+        {
+            public static readonly Data Disposed = new Data();
+
+            public readonly ImmutableArray<ModuleMetadata> Modules;
+            public readonly PEAssembly Assembly;
+
+            private Data()
+            {
+            }
+
+            public Data(ImmutableArray<ModuleMetadata> modules, PEAssembly assembly)
+            {
+                Debug.Assert(!modules.IsDefaultOrEmpty && assembly != null);
+
+                this.Modules = modules;
+                this.Assembly = assembly;
+            }
+
+            public bool IsDisposed
+            {
+                get { return Assembly == null; }
+            }
+        }
+
         /// <summary>
-        /// Modules comprising this assembly. The first module is the manifest module.
+        /// Factory that provides the <see cref="ModuleMetadata"/> for additional modules (other than <see cref="initialModules"/>) of the assembly.
+        /// Shall only throw <see cref="BadImageFormatException"/> or <see cref="IOException"/>.
+        /// Null of all modules were specified at construction time.
         /// </summary>
-        public ImmutableArray<ModuleMetadata> Modules { get; private set; }
+        private readonly Func<string, ModuleMetadata> moduleFactoryOpt;
 
-        internal PEAssembly Assembly { get; private set; }
+        /// <summary>
+        /// Modules the <see cref="AssemblyMetadata"/> was created with, in case they are eagerly allocated.
+        /// </summary>
+        private readonly ImmutableArray<ModuleMetadata> initialModules;
+
+        // Encapsulates the modules and the corresponding PEAssembly produced by the modules factory.
+        private Data lazyData;
+
+        // The actual array of modules exposed via Modules property.
+        // The same modules as the ones produced by the factory or their copies.
+        private ImmutableArray<ModuleMetadata> lazyPublishedModules;
 
         /// <summary>
         /// Cached assembly symbols.
@@ -30,23 +69,33 @@ public sealed class AssemblyMetadata : Metadata
         /// </remarks>
         internal readonly WeakList<IAssemblySymbol> CachedSymbols = new WeakList<IAssemblySymbol>();
 
-        private AssemblyMetadata(AssemblyMetadata metadata)
+        // creates a copy
+        private AssemblyMetadata(AssemblyMetadata other)
+            : base(isImageOwner: false)
         {
-            this.Assembly = metadata.Assembly;
-            this.CachedSymbols = metadata.CachedSymbols;
-            this.Modules = metadata.Modules.SelectAsArray(module => module.Copy());
+            this.CachedSymbols = other.CachedSymbols;
+            this.lazyData = other.lazyData;
+            this.moduleFactoryOpt = other.moduleFactoryOpt;
+            this.initialModules = other.initialModules;
+
+            // Leave lazyPublishedModules unset. Published modules will be set and copied as needed.
         }
 
-        private AssemblyMetadata(ModuleMetadata module)
+        internal AssemblyMetadata(ImmutableArray<ModuleMetadata> modules)
+            : base(isImageOwner: true)
         {
-            this.Modules = ImmutableArray.Create(module);
-            this.Assembly = new PEAssembly(this, ImmutableArray.Create(module.Module));
+            Debug.Assert(!modules.IsDefaultOrEmpty);
+            this.initialModules = modules;
         }
 
-        internal AssemblyMetadata(ImmutableArray<ModuleMetadata> modules)
+        internal AssemblyMetadata(ModuleMetadata manifestModule, Func<string, ModuleMetadata> moduleFactory)
+            : base(isImageOwner: true)
         {
-            this.Modules = modules;
-            this.Assembly = new PEAssembly(this, modules.SelectAsArray(m => m.Module));
+            Debug.Assert(manifestModule != null);
+            Debug.Assert(moduleFactory != null);
+
+            this.initialModules = ImmutableArray.Create(manifestModule);
+            this.moduleFactoryOpt = moduleFactory;
         }
 
         /// <summary>
@@ -56,7 +105,6 @@ internal AssemblyMetadata(ImmutableArray<ModuleMetadata> modules)
         /// Manifest module image.
         /// </param>
         /// <exception cref="ArgumentException"><paramref name="peImage"/> has the default value.</exception>
-        /// <exception cref="BadImageFormatException">The PE image format is invalid.</exception>
         public static AssemblyMetadata CreateFromImage(ImmutableArray<byte> peImage)
         {
             return Create(ModuleMetadata.CreateFromImage(peImage));
@@ -107,10 +155,10 @@ public static AssemblyMetadata Create(ModuleMetadata module)
         {
             if (module == null)
             {
-                throw new ArgumentNullException("module");
+                throw new ArgumentNullException(nameof(module));
             }
 
-            return new AssemblyMetadata(module);
+            return new AssemblyMetadata(ImmutableArray.Create(module));
         }
 
         /// <summary>
@@ -126,24 +174,24 @@ public static AssemblyMetadata Create(ImmutableArray<ModuleMetadata> modules)
         {
             if (modules.IsDefault)
             {
-                throw new ArgumentException("modules");
+                throw new ArgumentException(nameof(modules));
             }
 
             if (modules.Length == 0)
             {
-                throw new ArgumentException(CodeAnalysisResources.AssemblyMustHaveAtLeastOneModule, "modules");
+                throw new ArgumentException(CodeAnalysisResources.AssemblyMustHaveAtLeastOneModule, nameof(modules));
             }
 
             for (int i = 0; i < modules.Length; i++)
             {
                 if (modules[i] == null)
                 {
-                    throw new ArgumentNullException("modules[" + i + "]");
+                    throw new ArgumentNullException(nameof(modules) + "[" + i + "]");
                 }
 
                 if (!modules[i].IsImageOwner)
                 {
-                    throw new ArgumentException(CodeAnalysisResources.ModuleCopyCannotBeUsedToCreateAssemblyMetadata, "modules[" + i + "]");
+                    throw new ArgumentException(CodeAnalysisResources.ModuleCopyCannotBeUsedToCreateAssemblyMetadata, nameof(modules) + "[" + i + "]");
                 }
             }
 
@@ -197,34 +245,155 @@ protected override Metadata CommonCopy()
             return Copy();
         }
 
+        /// <summary>
+        /// Modules comprising this assembly. The first module is the manifest module.
+        /// </summary>
+        /// <exception cref="BadImageFormatException">The PE image format is invalid.</exception>
+        /// <exception cref="IOException">IO error reading the metadata. See <see cref="Exception.InnerException"/> for details.</exception>
+        /// <exception cref="ObjectDisposedException">The object has been disposed.</exception>
+        public ImmutableArray<ModuleMetadata> GetModules()
+        {
+            if (lazyPublishedModules.IsDefault)
+            {
+                var data = GetOrCreateData();
+                var newModules = data.Modules;
+
+                if (!IsImageOwner)
+                {
+                    newModules = newModules.SelectAsArray(module => module.Copy());
+                }
+
+                ImmutableInterlocked.InterlockedInitialize(ref lazyPublishedModules, newModules);
+            }
+
+            if (lazyData == Data.Disposed)
+            {
+                throw new ObjectDisposedException(nameof(AssemblyMetadata));
+            }
+
+            return lazyPublishedModules;
+        }
+
+        /// <exception cref="BadImageFormatException">The PE image format is invalid.</exception>
+        /// <exception cref="IOException">IO error while reading the metadata. See <see cref="Exception.InnerException"/> for details.</exception>
+        /// <exception cref="ObjectDisposedException">The object has been disposed.</exception>
+        internal PEAssembly GetAssembly()
+        {
+            return GetOrCreateData().Assembly;
+        }
+
+        /// <exception cref="BadImageFormatException">The PE image format is invalid.</exception>
+        /// <exception cref="IOException">IO error while reading the metadata. See <see cref="Exception.InnerException"/> for details.</exception>
+        /// <exception cref="ObjectDisposedException">The object has been disposed.</exception>
+        private Data GetOrCreateData()
+        {
+            if (lazyData == null)
+            {
+                ImmutableArray<ModuleMetadata> modules = initialModules;
+                ImmutableArray<ModuleMetadata>.Builder moduleBuilder = null;
+
+                bool createdModulesUsed = false;
+                try
+                {
+                    if (this.moduleFactoryOpt != null)
+                    {
+                        Debug.Assert(initialModules.Length == 1);
+
+                        var additionalModuleNames = initialModules[0].GetModuleNames();
+                        if (additionalModuleNames.Length > 0)
+                        {
+                            moduleBuilder = ImmutableArray.CreateBuilder<ModuleMetadata>(1 + additionalModuleNames.Length);
+                            moduleBuilder.Add(initialModules[0]);
+
+                            foreach (string moduleName in additionalModuleNames)
+                            {
+                                moduleBuilder.Add(moduleFactoryOpt(moduleName));
+                            }
+
+                            modules = moduleBuilder.ToImmutable();
+                        }
+                    }
+
+                    var assembly = new PEAssembly(this, modules.SelectAsArray(m => m.Module));
+                    var newData = new Data(modules, assembly);
+
+                    createdModulesUsed = Interlocked.CompareExchange(ref lazyData, newData, null) == null;
+                }
+                finally
+                {
+                    if (moduleBuilder != null && !createdModulesUsed)
+                    {
+                        // dispose unused modules created above:
+                        for (int i = initialModules.Length; i < moduleBuilder.Count; i++)
+                        {
+                            moduleBuilder[i].Dispose();
+                        }
+                    }
+                }
+            }
+
+            if (lazyData.IsDisposed)
+            {
+                throw new ObjectDisposedException(nameof(AssemblyMetadata));
+            }
+
+            return lazyData;
+        }
+
         /// <summary>
         /// Disposes all modules contained in the assembly.
         /// </summary>
         public override void Dispose()
         {
-            foreach (var module in Modules)
+            var previousData = Interlocked.Exchange(ref lazyData, Data.Disposed);
+
+            if (previousData == Data.Disposed || !this.IsImageOwner)
+            {
+                // already disposed, or not an owner
+                return;
+            }
+
+            // AssemblyMetadata assumes their ownership of all modules passed to the constructor.
+            foreach (var module in initialModules)
             {
                 module.Dispose();
             }
+
+            if (previousData == null)
+            {
+                // no additional modules were created yet => nothing to dispose
+                return;
+            }
+
+            Debug.Assert(initialModules.Length == 1 || initialModules.Length == previousData.Modules.Length);
+            
+            // dispose additional modules created lazily:
+            for (int i = initialModules.Length; i < previousData.Modules.Length; i++)
+            {
+                previousData.Modules[i].Dispose();
+            }
         }
 
         /// <summary>
         /// Checks if the first module has a single row in Assembly table and that all other modules have none.
         /// </summary>
+        /// <exception cref="BadImageFormatException">The PE image format is invalid.</exception>
+        /// <exception cref="IOException">IO error reading the metadata. See <see cref="Exception.InnerException"/> for details.</exception>
+        /// <exception cref="ObjectDisposedException">The object has been disposed.</exception>
         internal bool IsValidAssembly()
         {
-            if (!ManifestModule.Module.IsManifestModule)
+            var modules = GetModules();
+
+            if (!modules[0].Module.IsManifestModule)
             {
                 return false;
             }
 
-            for (int i = 1; i < Modules.Length; i++)
+            for (int i = 1; i < modules.Length; i++)
             {
-                var module = Modules[i].Module;
-                // Ignore winmd modules since runtime winmd
-                // modules may be loaded as non-primary modules.
-                if (!module.IsLinkedModule &&
-                    (module.MetadataReader.MetadataKind != MetadataKind.WindowsMetadata))
+                // Ignore winmd modules since runtime winmd modules may be loaded as non-primary modules.
+                var module = modules[i].Module;
+                if (!module.IsLinkedModule && module.MetadataReader.MetadataKind != MetadataKind.WindowsMetadata)
                 {
                     return false;
                 }
@@ -233,14 +402,6 @@ internal bool IsValidAssembly()
             return true;
         }
 
-        /// <summary>
-        /// The manifest module of the assembly.
-        /// </summary>
-        public ModuleMetadata ManifestModule
-        {
-            get { return Modules[0]; }
-        }
-
         /// <summary>
         /// Returns the metadata kind. <seealso cref="MetadataImageKind"/>
         /// </summary>
@@ -248,10 +409,5 @@ public override MetadataImageKind Kind
         {
             get { return MetadataImageKind.Assembly; }
         }
-
-        internal override bool IsImageOwner
-        {
-            get { return ManifestModule.IsImageOwner; }
-        }
     }
 }
diff --git a/Src/Compilers/Core/Portable/MetadataReference/Metadata.cs b/Src/Compilers/Core/Portable/MetadataReference/Metadata.cs
index bad630dc9cc7e1c7509f32bc1cc212ed55166be7..4346becf324455d1ded897253e4980d9ba61b140 100644
--- a/Src/Compilers/Core/Portable/MetadataReference/Metadata.cs
+++ b/Src/Compilers/Core/Portable/MetadataReference/Metadata.cs
@@ -10,8 +10,11 @@ namespace Microsoft.CodeAnalysis
     /// </summary>
     public abstract class Metadata : IDisposable
     {
-        internal Metadata()
+        internal readonly bool IsImageOwner;
+
+        internal Metadata(bool isImageOwner)
         {
+            this.IsImageOwner = isImageOwner;
         }
 
         /// <summary>
@@ -33,8 +36,5 @@ public Metadata Copy()
         {
             return CommonCopy();
         }
-
-        // does this instance own the PE image?
-        internal abstract bool IsImageOwner { get; }
     }
 }
diff --git a/Src/Compilers/Core/Portable/MetadataReference/ModuleMetadata.cs b/Src/Compilers/Core/Portable/MetadataReference/ModuleMetadata.cs
index 3c0ce5b583086eaf9a69fcb78871b9d7005e4404..c82deefe3498b6127340c3e7f4f9832edeb1933b 100644
--- a/Src/Compilers/Core/Portable/MetadataReference/ModuleMetadata.cs
+++ b/Src/Compilers/Core/Portable/MetadataReference/ModuleMetadata.cs
@@ -18,29 +18,25 @@ public sealed partial class ModuleMetadata : Metadata
     {
         private bool isDisposed;
 
-        private readonly bool isImageOwner;
         private readonly PEModule module;
 
         private ModuleMetadata(PEReader peReader)
+            : base(isImageOwner: true)
         {
-            this.module = new PEModule(peReader: peReader, metadataReader: null);
-            this.isImageOwner = true;
+            this.module = new PEModule(peReader: peReader, metadataOpt: IntPtr.Zero, metadataSizeOpt: 0);
         }
 
-        private ModuleMetadata(MetadataReader metadataReader)
+        private ModuleMetadata(IntPtr metadata, int size)
+            : base(isImageOwner: true)
         {
-            this.module = new PEModule(peReader: null, metadataReader: metadataReader);
-            this.isImageOwner = true;
+            this.module = new PEModule(peReader: null, metadataOpt: metadata, metadataSizeOpt: size);
         }
 
+        // creates a copy
         private ModuleMetadata(ModuleMetadata metadata)
+            : base(isImageOwner: false)
         {
             this.module = metadata.Module;
-
-            // This instance will not be the owner of the
-            // resources backing the metadata. 
-
-            this.isImageOwner = false;
         }
 
         /// <summary>
@@ -51,22 +47,19 @@ private ModuleMetadata(ModuleMetadata metadata)
         /// <param name="size">The size of the metadata block.</param>
         /// <exception cref="ArgumentNullException"><paramref name="metadata"/> is null.</exception>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="size"/> is not positive.</exception>
-        /// <exception cref="BadImageFormatException"><paramref name="metadata"/> doesn't contain valid metadata.</exception>
-        /// <exception cref="NotSupportedException"><paramref name="metadata"/> doesn't represent an assembly (manifest module).</exception>
         public static ModuleMetadata CreateFromMetadata(IntPtr metadata, int size)
         {
             if (metadata == IntPtr.Zero)
             {
-                throw new ArgumentNullException("metadata");
+                throw new ArgumentNullException(nameof(metadata));
             }
 
             if (size <= 0)
             {
-                throw new ArgumentOutOfRangeException(CodeAnalysisResources.SizeHasToBePositive, "size");
+                throw new ArgumentOutOfRangeException(CodeAnalysisResources.SizeHasToBePositive, nameof(size));
             }
 
-            var reader = new MetadataReader(metadata, size, MetadataReaderOptions.ApplyWindowsRuntimeProjections, stringInterner: StringTable.AddShared);
-            return new ModuleMetadata(reader);
+            return new ModuleMetadata(metadata, size);
         }
 
         /// <summary>
@@ -76,17 +69,16 @@ public static ModuleMetadata CreateFromMetadata(IntPtr metadata, int size)
         /// <param name="size">The size of the image pointed to by <paramref name="peImage"/>.</param>
         /// <exception cref="ArgumentNullException"><paramref name="peImage"/> is null.</exception>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="size"/> is not positive.</exception>
-        /// <exception cref="BadImageFormatException"><paramref name="peImage"/> is not valid portable executable image containing CLI metadata</exception>
         public static ModuleMetadata CreateFromImage(IntPtr peImage, int size)
         {
             if (peImage == IntPtr.Zero)
             {
-                throw new ArgumentNullException("peImage");
+                throw new ArgumentNullException(nameof(peImage));
             }
 
             if (size <= 0)
             {
-                throw new ArgumentOutOfRangeException(CodeAnalysisResources.SizeHasToBePositive, "size");
+                throw new ArgumentOutOfRangeException(CodeAnalysisResources.SizeHasToBePositive, nameof(size));
             }
 
             return new ModuleMetadata(new PEReader(peImage, size));
@@ -97,7 +89,6 @@ public static ModuleMetadata CreateFromImage(IntPtr peImage, int size)
         /// </summary>
         /// <param name="peImage">The portable executable image beginning with the DOS header ("MZ").</param>
         /// <exception cref="ArgumentException"><paramref name="peImage"/> is null.</exception>
-        /// <exception cref="BadImageFormatException"><paramref name="peImage"/> is not valid portable executable image containing CLI metadata</exception>
         public static ModuleMetadata CreateFromImage(IEnumerable<byte> peImage)
         {
             return CreateFromImage(peImage.AsImmutableOrNull());
@@ -108,12 +99,11 @@ public static ModuleMetadata CreateFromImage(IEnumerable<byte> peImage)
         /// </summary>
         /// <param name="peImage">Portable executable image beginning with the DOS header ("MZ").</param>
         /// <exception cref="ArgumentException"><paramref name="peImage"/> is null.</exception>
-        /// <exception cref="BadImageFormatException"><paramref name="peImage"/> is not valid portable executable image containing CLI metadata</exception>
         public static ModuleMetadata CreateFromImage(ImmutableArray<byte> peImage)
         {
             if (peImage.IsDefault)
             {
-                throw new ArgumentException("peImage");
+                throw new ArgumentException(nameof(peImage));
             }
 
             return new ModuleMetadata(new PEReader(peImage));
@@ -127,7 +117,6 @@ public static ModuleMetadata CreateFromImage(ImmutableArray<byte> peImage)
         /// False to close the stream upon disposal of the metadata (the responsibility for disposal of the stream is transferred upon entry of the constructor
         /// unless the arguments given are invalid).
         /// </param>
-        /// <exception cref="BadImageFormatException"><paramref name="peStream"/> is not valid portable executable image containing CLI metadata</exception>
         /// <exception cref="ArgumentException">The stream doesn't support seek operations.</exception>
         /// <exception cref="ArgumentNullException"><paramref name="peStream"/> is null.</exception>
         public static ModuleMetadata CreateFromImageStream(Stream peStream, bool leaveOpen = false)
@@ -144,20 +133,25 @@ public static ModuleMetadata CreateFromImageStream(Stream peStream, bool leaveOp
         /// Unless <see cref="PEStreamOptions.LeaveOpen"/> is specified, the responsibility for disposal of the stream is transferred upon entry of the constructor
         /// unless the arguments given are invalid.
         /// </param>
-        /// <exception cref="BadImageFormatException"><paramref name="peStream"/> is not valid portable executable image containing CLI metadata</exception>
         /// <exception cref="ArgumentException">The stream doesn't support read and seek operations.</exception>
         /// <exception cref="ArgumentNullException"><paramref name="peStream"/> is null.</exception>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="options"/> has an invalid value.</exception>
+        /// <exception cref="BadImageFormatException">
+        /// <see cref="PEStreamOptions.PrefetchMetadata"/> or <see cref="PEStreamOptions.PrefetchEntireImage"/> is specified and the PE headers of the image are invalid.
+        /// </exception>
+        /// <exception cref="IOException">
+        /// <see cref="PEStreamOptions.PrefetchMetadata"/> or <see cref="PEStreamOptions.PrefetchEntireImage"/> is specified and an error occurs while reading the stream.
+        /// </exception>
         public static ModuleMetadata CreateFromImageStream(Stream peStream, PEStreamOptions options)
         {
             if (peStream == null)
             {
-                throw new ArgumentNullException("peStream");
+                throw new ArgumentNullException(nameof(peStream));
             }
 
             if (!peStream.CanRead || !peStream.CanSeek)
             {
-                throw new ArgumentException(CodeAnalysisResources.StreamMustSupportReadAndSeek, "peImage");
+                throw new ArgumentException(CodeAnalysisResources.StreamMustSupportReadAndSeek, nameof(peStream));
             }
 
             // ownership of the stream is passed on PEReader:
@@ -208,7 +202,7 @@ internal PEModule Module
             {
                 if (IsDisposed)
                 {
-                    throw new ObjectDisposedException(GetType().Name);
+                    throw new ObjectDisposedException(nameof(ModuleMetadata));
                 }
 
                 return module;
@@ -218,6 +212,7 @@ internal PEModule Module
         /// <summary>
         /// Name of the module.
         /// </summary>
+        /// <exception cref="BadImageFormatException">Invalid metadata.</exception>
         /// <exception cref="ObjectDisposedException">Module has been disposed.</exception>
         public string Name
         {
@@ -252,14 +247,14 @@ public ImmutableArray<string> GetModuleNames()
             return Module.GetMetadataModuleNamesOrThrow();
         }
 
+        /// <summary>
+        /// Returns the metadata reader.
+        /// </summary>
+        /// <exception cref="ObjectDisposedException">Module has been disposed.</exception>
+        /// <exception cref="BadImageFormatException">When an invalid module name is encountered.</exception>
         internal MetadataReader MetadataReader
         {
             get { return Module.MetadataReader; }
         }
-
-        internal override bool IsImageOwner
-        {
-            get { return isImageOwner; }
-        }
     }
 }
diff --git a/Src/Compilers/Core/Portable/ReferenceManager/CommonReferenceManager.Resolution.cs b/Src/Compilers/Core/Portable/ReferenceManager/CommonReferenceManager.Resolution.cs
index 58b14e5decbaffd84a9a2588a3de6054b4e2a42e..8d23fc835be36ef60e75760dfa2bb847b387ace1 100644
--- a/Src/Compilers/Core/Portable/ReferenceManager/CommonReferenceManager.Resolution.cs
+++ b/Src/Compilers/Core/Portable/ReferenceManager/CommonReferenceManager.Resolution.cs
@@ -258,7 +258,7 @@ public ReferencedAssemblyIdentity(AssemblyIdentity identity, MetadataReference m
 
                             if (assemblyMetadata.IsValidAssembly())
                             {
-                                PEAssembly assembly = assemblyMetadata.Assembly;
+                                PEAssembly assembly = assemblyMetadata.GetAssembly();
                                 existingReference = TryAddAssembly(
                                     assembly.Identity,
                                     peReference,
diff --git a/Src/Compilers/VisualBasic/Desktop/CommandLine/CommandLineArguments.vb b/Src/Compilers/VisualBasic/Desktop/CommandLine/CommandLineArguments.vb
index e2915e069331f2b4e90966ef4d0b6ec3f6be2dea..bc34900c44db24f014f301cd74b70cbb7283f28a 100644
--- a/Src/Compilers/VisualBasic/Desktop/CommandLine/CommandLineArguments.vb
+++ b/Src/Compilers/VisualBasic/Desktop/CommandLine/CommandLineArguments.vb
@@ -79,33 +79,28 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                         ' CommonReferenceManager<TCompilation, TAssemblySymbol>.IndexOfCorLibrary
                         ' should be equivalent.
                         If Not refProps.EmbedInteropTypes AndAlso refProps.Kind = MetadataImageKind.Assembly Then
-                            Dim metadata As Metadata
-
                             Try
-                                metadata = DirectCast(reference, PortableExecutableReference).GetMetadata()
-                            Catch
-                                ' Failed to get metadata, there will be some errors reported later.
-                                Return True
-                            End Try
-
-                            If metadata Is Nothing Then
-                                ' Failed to get metadata, there will be some errors reported later.
-                                Return True
-                            End If
+                                Dim assemblyMetadata = TryCast(DirectCast(reference, PortableExecutableReference).GetMetadata(), AssemblyMetadata)
 
-                            Dim assemblyMetadata = DirectCast(metadata, AssemblyMetadata)
+                                If assemblyMetadata Is Nothing OrElse Not assemblyMetadata.IsValidAssembly() Then
+                                    ' There will be some errors reported later.
+                                    Return True
+                                End If
 
-                            If Not assemblyMetadata.IsValidAssembly Then
-                                ' There will be some errors reported later.
-                                Return True
-                            End If
+                                Dim assembly As PEAssembly = assemblyMetadata.GetAssembly()
 
-                            Dim assembly As PEAssembly = assemblyMetadata.Assembly
+                                If assembly.AssemblyReferences.Length = 0 AndAlso Not assembly.ContainsNoPiaLocalTypes AndAlso assembly.DeclaresTheObjectClass Then
+                                    ' This reference looks like a valid Cor library candidate, bail out.
+                                    Return True
+                                End If
 
-                            If assembly.AssemblyReferences.Length = 0 AndAlso Not assembly.ContainsNoPiaLocalTypes AndAlso assembly.DeclaresTheObjectClass Then
-                                ' This reference looks like a valid Cor library candidate, bail out.
+                            Catch e As BadImageFormatException
+                                ' error reported later
                                 Return True
-                            End If
+                            Catch e As IOException
+                                ' error reported later
+                                Return True
+                            End Try
                         End If
                     Next
 
diff --git a/Src/Compilers/VisualBasic/Desktop/CommandLine/CommandLineParser.vb b/Src/Compilers/VisualBasic/Desktop/CommandLine/CommandLineParser.vb
index 9db54afe202cd784d3e8ed1a7ab36cae5f248080..c85e3cfea5b38e4079df2fa1464f1d10f5715ae7 100644
--- a/Src/Compilers/VisualBasic/Desktop/CommandLine/CommandLineParser.vb
+++ b/Src/Compilers/VisualBasic/Desktop/CommandLine/CommandLineParser.vb
@@ -1180,7 +1180,7 @@ lVbRuntimePlus:
                     ' Prefer 'System.Runtime.dll' if it does not have any references
                     If systemRuntimeMetadata.Kind = MetadataImageKind.Assembly Then
                         Dim assemblyMetadata = DirectCast(systemRuntimeMetadata, AssemblyMetadata)
-                        If assemblyMetadata.ManifestModule.Module.IsLinkedModule AndAlso assemblyMetadata.Assembly.AssemblyReferences.Length = 0 Then
+                        If assemblyMetadata.GetModules()(0).Module.IsLinkedModule AndAlso assemblyMetadata.GetAssembly.AssemblyReferences.Length = 0 Then
                             Return New CommandLineReference(systemRuntimePath, New MetadataReferenceProperties(MetadataImageKind.Assembly))
                         End If
                     End If
diff --git a/Src/Compilers/VisualBasic/Portable/Symbols/ReferenceManager.vb b/Src/Compilers/VisualBasic/Portable/Symbols/ReferenceManager.vb
index 39aea1b738c0e51ccb934048368a3909b0b0b0c6..0c941d815dcda23fa57484929697eb4d40e14ab1 100644
--- a/Src/Compilers/VisualBasic/Portable/Symbols/ReferenceManager.vb
+++ b/Src/Compilers/VisualBasic/Portable/Symbols/ReferenceManager.vb
@@ -195,7 +195,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                     referencedAssembliesByIdentity.Add(symbol.Identity, symbol)
                 Next
 
-                Dim assembly = metadata.Assembly
+                Dim assembly = metadata.GetAssembly
                 Dim peReferences = assembly.AssemblyReferences.SelectAsArray(AddressOf MapAssemblyIdentityToResolvedSymbol, referencedAssembliesByIdentity)
                 Dim assemblySymbol = New PEAssemblySymbol(assembly, DocumentationProvider.Default, isLinked:=False, importOptions:=importOptions)
 
diff --git a/Src/Compilers/VisualBasic/Test/Emit/Attributes/AssemblyAttributes.vb b/Src/Compilers/VisualBasic/Test/Emit/Attributes/AssemblyAttributes.vb
index 3ae2d9dd0cc7ccf3096f449725dedc0f779cdaff..e80d35c47b9e652be42a1364854707608067def2 100644
--- a/Src/Compilers/VisualBasic/Test/Emit/Attributes/AssemblyAttributes.vb
+++ b/Src/Compilers/VisualBasic/Test/Emit/Attributes/AssemblyAttributes.vb
@@ -1144,7 +1144,7 @@ End Class
             End Select
         Next
 
-        metadata = AssemblyMetadata.CreateFromImage(consoleappCompilation.EmitToArray()).Assembly.ManifestModule
+        metadata = AssemblyMetadata.CreateFromImage(consoleappCompilation.EmitToArray()).GetAssembly.ManifestModule
         metadataReader = metadata.GetMetadataReader()
 
         Assert.Equal(1, metadataReader.GetTableRowCount(TableIndex.ModuleRef))
diff --git a/Src/Compilers/VisualBasic/Test/Emit/Emit/EditAndContinueTests.vb b/Src/Compilers/VisualBasic/Test/Emit/Emit/EditAndContinueTests.vb
index bf9549b76b78905785b79dd04693882068541837..e5136a3102aaf3b470805dea9621103f362f4da7 100644
--- a/Src/Compilers/VisualBasic/Test/Emit/Emit/EditAndContinueTests.vb
+++ b/Src/Compilers/VisualBasic/Test/Emit/Emit/EditAndContinueTests.vb
@@ -3778,7 +3778,7 @@ End Class
             Dim compilation0 = CreateCompilationWithMscorlib(source, options:=TestOptions.DebugDll)
             Dim compilation1 = CreateCompilationWithMscorlib(source, options:=TestOptions.DebugDll)
 
-            Dim moduleMetadata0 = DirectCast(metadata0.GetMetadata(), AssemblyMetadata).Modules(0)
+            Dim moduleMetadata0 = DirectCast(metadata0.GetMetadata(), AssemblyMetadata).GetModules(0)
             Dim method0 = compilation0.GetMember(Of MethodSymbol)("C.F")
             Dim generation0 = EmitBaseline.CreateInitialBaseline(
                 moduleMetadata0,
diff --git a/Src/Compilers/VisualBasic/Test/Emit/Emit/EmitMetadata.vb b/Src/Compilers/VisualBasic/Test/Emit/Emit/EmitMetadata.vb
index 05789b50b8264cbd8274d4dfec25efa8295e8e65..5dde84fee3c81fe2af4a4179d311ea64362a6abf 100644
--- a/Src/Compilers/VisualBasic/Test/Emit/Emit/EmitMetadata.vb
+++ b/Src/Compilers/VisualBasic/Test/Emit/Emit/EmitMetadata.vb
@@ -216,7 +216,7 @@ End Class
             Dim dllImage = CompileAndVerify(c1).EmittedAssemblyData
 
             Using metadata = AssemblyMetadata.CreateFromImage(dllImage)
-                Dim emitAssemblyRefs As PEAssembly = metadata.Assembly
+                Dim emitAssemblyRefs As PEAssembly = metadata.GetAssembly
 
                 Dim refs = emitAssemblyRefs.Modules(0).ReferencedAssemblies.AsEnumerable().OrderBy(Function(r) r.Name).ToArray()
 
@@ -241,7 +241,7 @@ End Class
             dllImage = CompileAndVerify(c2).EmittedAssemblyData
 
             Using metadata = AssemblyMetadata.CreateFromImage(dllImage)
-                Dim emitAssemblyRefs2 As PEAssembly = metadata.Assembly
+                Dim emitAssemblyRefs2 As PEAssembly = metadata.GetAssembly
                 Dim refs2 = emitAssemblyRefs2.Modules(0).ReferencedAssemblies.AsEnumerable().OrderBy(Function(r) r.Name).ToArray()
 
                 Assert.Equal(2, refs2.Count)
@@ -279,7 +279,7 @@ End Class
             Dim manifestModule = CompileAndVerify(c1).EmittedAssemblyData
 
             Using metadata = AssemblyMetadata.Create(ModuleMetadata.CreateFromImage(manifestModule), netModule1, netModule2)
-                Dim emitAddModule As PEAssembly = metadata.Assembly
+                Dim emitAddModule As PEAssembly = metadata.GetAssembly
 
                 Assert.Equal(3, emitAddModule.Modules.Length)
 
diff --git a/Src/Compilers/VisualBasic/Test/Semantic/Compilation/ReferenceManagerTests.vb b/Src/Compilers/VisualBasic/Test/Semantic/Compilation/ReferenceManagerTests.vb
index 6182176ef5fc288b3e68400730985d16bfb93c2f..2b8d5221e43370c745730479acf913918a4f0f14 100644
--- a/Src/Compilers/VisualBasic/Test/Semantic/Compilation/ReferenceManagerTests.vb
+++ b/Src/Compilers/VisualBasic/Test/Semantic/Compilation/ReferenceManagerTests.vb
@@ -1472,7 +1472,7 @@ End Class
             Assert.Equal(comp1.Assembly, moduleSymbol1.ContainingAssembly)
 
             Dim moduleReferences1 = moduleSymbol1.GetReferencedAssemblies()
-            Assert.Contains(assemblyMd.Assembly.Identity, moduleReferences1.AsEnumerable())
+            Assert.Contains(assemblyMd.GetAssembly.Identity, moduleReferences1.AsEnumerable())
 
             Dim moduleTypeSymbol1 = comp1.GlobalNamespace.GetMember(Of NamedTypeSymbol)("TypeFromModule")
             Assert.Equal(moduleSymbol1, moduleTypeSymbol1.ContainingModule)
@@ -1612,7 +1612,7 @@ End Class
 
             Dim CopyRefMetaData = refmetadata.Copy
             Assert.NotEqual(refmetadata, CopyRefMetaData)
-            Assert.Equal(refmetadata.Assembly.ToString, CopyRefMetaData.Assembly.ToString)
+            Assert.Equal(refmetadata.GetAssembly.ToString, CopyRefMetaData.GetAssembly.ToString)
 
             Dim mca1 As Metadata = refa.GetMetadata()
             Dim Copymca1 = mca1.Copy()
diff --git a/Src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/MetadataCacheTests.vb b/Src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/MetadataCacheTests.vb
index ac806adc01ba0e12136845b67b561b3ceecfd8b4..20e78490ea4a3e34ea186c880ce7edc050ae3738 100644
--- a/Src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/MetadataCacheTests.vb
+++ b/Src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/MetadataCacheTests.vb
@@ -108,7 +108,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.UnitTests
 
                 Assert.True(String.Equals(MetadataCache.AssembliesFromFiles.Keys.Single().FullPath, mscorlibPath, StringComparison.OrdinalIgnoreCase))
 
-                Dim assembly = cachedAssembly.Metadata.GetTarget().Assembly
+                Dim assembly = cachedAssembly.Metadata.GetTarget().GetAssembly
                 Assert.NotNull(assembly)
 
                 Assert.True(assembly.Identity.Name.Equals("mscorlib"))
@@ -120,7 +120,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.UnitTests
                 Dim mscorlibAsm = DirectCast(cachedAssembly.CachedSymbols.First(), PEAssemblySymbol)
 
                 Assert.NotNull(mscorlibAsm)
-                Assert.Same(mscorlibAsm.Assembly, cachedAssembly.Metadata.GetTarget().Assembly)
+                Assert.Same(mscorlibAsm.Assembly, cachedAssembly.Metadata.GetTarget().GetAssembly)
                 Assert.True(mscorlibAsm.Identity.Name.Equals("mscorlib"))
                 Assert.True(mscorlibAsm.Name.Equals("mscorlib"))
                 Assert.Equal(1, mscorlibAsm.Modules.Length)
@@ -512,7 +512,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.UnitTests
                 Assert.Same(mscorlibInfo.CachedSymbols.First(), mscorlibAsm)
 
                 Dim MTTestLib1Info = MetadataCache.AssembliesFromFiles(FileKey.Create(MTTestLib1Path))
-                Dim assembly = MTTestLib1Info.Metadata.GetTarget().Assembly
+                Dim assembly = MTTestLib1Info.Metadata.GetTarget().GetAssembly
                 Assert.NotNull(assembly)
                 Assert.Equal(1, MTTestLib1Info.CachedSymbols.Count)
 
@@ -772,7 +772,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.UnitTests
                 Assert.Equal(0, MetadataCache.ModulesFromFiles.Count)
 
                 Dim cachedAssembly = MetadataCache.AssembliesFromFiles(FileKey.Create(multimoduleRef.FilePath))
-                Dim assembly = cachedAssembly.Metadata.GetTarget().Assembly
+                Dim assembly = cachedAssembly.Metadata.GetTarget().GetAssembly
                 Assert.NotNull(assembly)
 
                 Assert.True(assembly.Identity.Name.Equals("MultiModule"))
diff --git a/Src/Test/Utilities/CommonTestBase.cs b/Src/Test/Utilities/CommonTestBase.cs
index dfa71a5b360c923572c464021965e64af570d290..757478e84ee76629a109bf367b904e7c925aedd7 100644
--- a/Src/Test/Utilities/CommonTestBase.cs
+++ b/Src/Test/Utilities/CommonTestBase.cs
@@ -356,7 +356,7 @@ static internal void RunValidators(CompilationVerifier verifier, EmitOptions emi
             {
                 using (var emittedMetadata = AssemblyMetadata.Create(verifier.GetAllModuleMetadata()))
                 {
-                    assemblyValidator(emittedMetadata.Assembly, emitOptions);
+                    assemblyValidator(emittedMetadata.GetAssembly(), emitOptions);
                 }
             }
 
diff --git a/Src/Test/Utilities/HostedRuntimeEnvironment.cs b/Src/Test/Utilities/HostedRuntimeEnvironment.cs
index 81f331bce6e6b38a77896b9895c098ceff8d0d95..232015260fd270c12839f4276eb392a6fc2af9a1 100644
--- a/Src/Test/Utilities/HostedRuntimeEnvironment.cs
+++ b/Src/Test/Utilities/HostedRuntimeEnvironment.cs
@@ -142,7 +142,7 @@ internal static void EmitReferences(Compilation compilation, List<ModuleData> de
                         ImmutableArray<byte> bytes = module.Module.PEReaderOpt.GetEntireImage().GetContent();
                         if (isManifestModule)
                         {
-                            dependencies.Add(new ModuleData(((AssemblyMetadata)metadata).Assembly.Identity, OutputKind.DynamicallyLinkedLibrary, bytes, pdb: default(ImmutableArray<byte>), inMemoryModule: !(r is MetadataFileReference)));
+                            dependencies.Add(new ModuleData(((AssemblyMetadata)metadata).GetAssembly().Identity, OutputKind.DynamicallyLinkedLibrary, bytes, pdb: default(ImmutableArray<byte>), inMemoryModule: !(r is MetadataFileReference)));
                         }
                         else
                         {
@@ -161,7 +161,7 @@ internal static void EmitReferences(Compilation compilation, List<ModuleData> de
 
         private static IEnumerable<ModuleMetadata> EnumerateModules(Metadata metadata)
         {
-            return (metadata.Kind == MetadataImageKind.Assembly) ? ((AssemblyMetadata)metadata).Modules.AsEnumerable() : SpecializedCollections.SingletonEnumerable((ModuleMetadata)metadata);
+            return (metadata.Kind == MetadataImageKind.Assembly) ? ((AssemblyMetadata)metadata).GetModules().AsEnumerable() : SpecializedCollections.SingletonEnumerable((ModuleMetadata)metadata);
         }
 
         internal static bool EmitCompilation(