Remove reference to TestBase from CompilationVerifier

src/Compilers/CSharp/Test/Emit/CSharpCompilerEmitTest.csproj

@@ -146,14 +146,13 @@
     <Compile Include="Emit\EditAndContinue\LocalSlotMappingTests.cs" />
     <Compile Include="Emit\EmitCustomModifiers.cs" />
     <Compile Include="Emit\EmitErrorTests.cs" />
-    <Compile Include="Emit\EmitMetadata.cs" />
+    <Compile Include="Emit\EmitMetadataTests.cs" />
     <Compile Include="Emit\EmitMetadataTestBase.cs" />
     <Compile Include="Attributes\EmitTestStrongNameProvider.cs" />
     <Compile Include="Emit\EndToEndTests.cs" />
     <Compile Include="Emit\EntryPointTests.cs" />
     <Compile Include="Emit\NoPiaEmbedTypes.cs" />
     <Compile Include="Emit\OptionalArgumentsTests.cs" />
-    <Compile Include="Emit\OutputStreams.cs" />
     <Compile Include="Emit\ResourceTests.cs" />
     <Compile Include="CodeGen\CodeGenScriptTests.cs" />
     <Compile Include="PDB\CheckSumTest.cs" />

src/Compilers/CSharp/Test/Emit/Emit/OutputStreams.cs

-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-using System;
-using System.IO;
-using Microsoft.CodeAnalysis.CSharp.Symbols;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Text;
-
-namespace Microsoft.CodeAnalysis.CSharp.UnitTests.Emit
-{
-    internal class NameResolver
-    {
-        public string GetDebugInformationFileName(SyntaxTree syntaxTree)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Stream GetXmlInclude(SyntaxTree syntaxTree, string xmlIncludeFile)
-        {
-            throw new NotImplementedException();
-        }
-    }
-}

src/Compilers/CSharp/Test/Symbol/Symbols/Source/FieldTests.cs

@@ -483,7 +483,7 @@ static System.Action<object> F()
                 Diagnostic(ErrorCode.WRN_UnreferencedFieldAssg, "value__").WithArguments("A.value__"));
 
             // PEVerify should not report "Field value__ ... is not marked RTSpecialName".
-            var verifier = new CompilationVerifier(this, compilation);
+            var verifier = new CompilationVerifier(compilation);
             verifier.EmitAndVerify(
                 "Error: Field name value__ is reserved for Enums only.",
                 "Error: Field name value__ is reserved for Enums only.",

src/Compilers/Test/Utilities/CSharp/BasicCompilationUtils.cs

@@ -53,11 +53,6 @@ protected override Compilation GetCompilationForEmit(IEnumerable<string> source,
                 throw new NotImplementedException();
             }
 
-            internal override IEnumerable<IModuleSymbol> ReferencesToModuleSymbols(IEnumerable<MetadataReference> references, MetadataImportOptions importOptions = MetadataImportOptions.Public)
-            {
-                throw new NotImplementedException();
-            }
-
             internal override string VisualizeRealIL(IModuleSymbol peModule, CodeAnalysis.CodeGen.CompilationTestData.MethodData methodData, IReadOnlyDictionary<int, string> markers)
             {
                 throw new NotImplementedException();

src/Compilers/Test/Utilities/CSharp/CSharpTestBase.cs

@@ -38,11 +38,6 @@ public abstract class CSharpTestBase : CSharpTestBaseBase
             return (CSharpCompilation)base.GetCompilationForEmit(source, additionalRefs, options, parseOptions);
         }
 
-        internal new IEnumerable<ModuleSymbol> ReferencesToModuleSymbols(IEnumerable<MetadataReference> references, MetadataImportOptions importOptions = MetadataImportOptions.Public)
-        {
-            return base.ReferencesToModuleSymbols(references, importOptions).Cast<ModuleSymbol>();
-        }
-
         private Action<IModuleSymbol> Translate2(Action<ModuleSymbol> action)
         {
             if (action != null)
@@ -219,24 +214,6 @@ public static CSharpCompilation CreateWinRtCompilation(string text, MetadataRefe
                                                     TestOptions.ReleaseExe);
         }
 
-        internal override IEnumerable<IModuleSymbol> ReferencesToModuleSymbols(IEnumerable<MetadataReference> references, MetadataImportOptions importOptions = MetadataImportOptions.Public)
-        {
-            var options = TestOptions.ReleaseDll.WithMetadataImportOptions(importOptions);
-            var tc1 = CSharpCompilation.Create("Dummy", new SyntaxTree[0], references, options);
-            return references.Select(r =>
-            {
-                if (r.Properties.Kind == MetadataImageKind.Assembly)
-                {
-                    var assemblySymbol = tc1.GetReferencedAssemblySymbol(r);
-                    return (object)assemblySymbol == null ? null : assemblySymbol.Modules[0];
-                }
-                else
-                {
-                    return tc1.GetReferencedModuleSymbol(r);
-                }
-            });
-        }
-
         protected override CompilationOptions CompilationOptionsReleaseDll
         {
             get { return TestOptions.ReleaseDll; }

src/Compilers/Test/Utilities/VisualBasic/BasicTestBase.vb

@@ -414,20 +414,6 @@ End Class
 Public MustInherit Class BasicTestBaseBase
     Inherits CommonTestBase
 
-    Friend Overrides Function ReferencesToModuleSymbols(references As IEnumerable(Of MetadataReference), Optional importOptions As MetadataImportOptions = MetadataImportOptions.Public) As IEnumerable(Of IModuleSymbol)
-        Dim options = DirectCast(CompilationOptionsReleaseDll, VisualBasicCompilationOptions).WithMetadataImportOptions(importOptions)
-        Dim tc1 = VisualBasicCompilation.Create("Dummy", references:=references, options:=options)
-        Return references.Select(
-            Function(r)
-                If r.Properties.Kind = MetadataImageKind.Assembly Then
-                    Dim assemblySymbol = tc1.GetReferencedAssemblySymbol(r)
-                    Return If(assemblySymbol Is Nothing, Nothing, assemblySymbol.Modules(0))
-                Else
-                    Return tc1.GetReferencedModuleSymbol(r)
-                End If
-            End Function)
-    End Function
-
     Protected Overrides ReadOnly Property CompilationOptionsReleaseDll As CompilationOptions
         Get
             Return TestOptions.ReleaseDll

src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Source/FieldTests.vb

@@ -491,7 +491,7 @@ End Module
             compilation.AssertNoErrors()
 
             ' PEVerify should not report "Field value__ ... is not marked RTSpecialName".
-            Dim verifier = New CompilationVerifier(Me, compilation)
+            Dim verifier = New CompilationVerifier(compilation)
             verifier.EmitAndVerify(
                 "Error: Field name value__ is reserved for Enums only.")
         End Sub

src/Test/Utilities/Portable/CommonTestBase.CompilationVerifier.cs

@@ -25,7 +25,6 @@ public partial class CommonTestBase
     {
         public class CompilationVerifier
         {
-            private readonly CommonTestBase _test;
             private readonly Compilation _compilation;
             private CompilationTestData _testData;
             private readonly IEnumerable<ModuleData> _dependencies;
@@ -36,35 +35,21 @@ public class CompilationVerifier
             internal ImmutableArray<byte> EmittedAssemblyData;
             internal ImmutableArray<byte> EmittedAssemblyPdb;
 
-            public CompilationVerifier(
-                CommonTestBase test,
+            private readonly Func<IModuleSymbol, CompilationTestData.MethodData, IReadOnlyDictionary<int, string>, string> _visualizeRealIL;
+
+            internal CompilationVerifier(
                 Compilation compilation,
+                Func<IModuleSymbol, CompilationTestData.MethodData, IReadOnlyDictionary<int, string>, string> visualizeRealIL = null,
                 IEnumerable<ModuleData> dependencies = null)
             {
-                _test = test;
                 _compilation = compilation;
                 _dependencies = dependencies;
+                _visualizeRealIL = visualizeRealIL;
             }
 
-            internal CompilationTestData TestData
-            {
-                get { return _testData; }
-            }
-
-            public Compilation Compilation
-            {
-                get { return _compilation; }
-            }
-
-            public TempRoot Temp
-            {
-                get { return _test.Temp; }
-            }
-
-            internal ImmutableArray<Diagnostic> Diagnostics
-            {
-                get { return _diagnostics; }
-            }
+            internal CompilationTestData TestData => _testData;
+            public Compilation Compilation => _compilation;
+            internal ImmutableArray<Diagnostic> Diagnostics => _diagnostics;
 
             internal ImmutableArray<ModuleMetadata> GetAllModuleMetadata()
             {
@@ -283,7 +268,7 @@ internal string VisualizeIL(CompilationTestData.MethodData methodData, bool real
                     _lazyModuleSymbol = GetModuleSymbolForEmittedImage(EmittedAssemblyData, MetadataImportOptions.All);
                 }
 
-                return _lazyModuleSymbol != null ? _test.VisualizeRealIL(_lazyModuleSymbol, methodData, markers) : null;
+                return _lazyModuleSymbol != null ? _visualizeRealIL(_lazyModuleSymbol, methodData, markers) : null;
             }
 
             public CompilationVerifier VerifyMemberInIL(string methodName, bool expected)
@@ -312,10 +297,32 @@ private IModuleSymbol GetModuleSymbolForEmittedImage(ImmutableArray<byte> peImag
 
                 var targetReference = LoadTestEmittedExecutableForSymbolValidation(peImage, _compilation.Options.OutputKind, display: _compilation.AssemblyName);
                 var references = _compilation.References.Concat(new[] { targetReference });
-                var assemblies = _test.ReferencesToModuleSymbols(references, importOptions);
+                var assemblies = GetReferencesToModuleSymbols(references, importOptions);
                 return assemblies.Last();
             }
 
+            private IEnumerable<IModuleSymbol> GetReferencesToModuleSymbols(IEnumerable<MetadataReference> references, MetadataImportOptions importOptions)
+            {
+                var dummy = _compilation
+                    .RemoveAllReferences()
+                    .RemoveAllSyntaxTrees()
+                    .WithReferences(references)
+                    .WithAssemblyName("Dummy")
+                    .WithOptions(_compilation.Options.WithMetadataImportOptions(importOptions));
+
+                return references.Select(reference =>
+                {
+                    if (reference.Properties.Kind == MetadataImageKind.Assembly)
+                    {
+                        return ((IAssemblySymbol)dummy.GetAssemblyOrModuleSymbol(reference))?.Modules.First();
+                    }
+                    else
+                    {
+                        return (IModuleSymbol)dummy.GetAssemblyOrModuleSymbol(reference);
+                    }
+                });
+            }
+
             internal static MetadataReference LoadTestEmittedExecutableForSymbolValidation(
                 ImmutableArray<byte> image,
                 OutputKind outputKind,

src/Test/Utilities/Portable/CommonTestBase.cs

@@ -23,8 +23,6 @@ namespace Microsoft.CodeAnalysis.Test.Utilities
     /// </summary>
     public abstract partial class CommonTestBase : TestBase
     {
-        internal abstract IEnumerable<IModuleSymbol> ReferencesToModuleSymbols(IEnumerable<MetadataReference> references, MetadataImportOptions importOptions = MetadataImportOptions.Public);
-
         #region Emit
 
         protected abstract Compilation GetCompilationForEmit(
@@ -214,9 +212,7 @@ static internal void RunValidators(CompilationVerifier verifier, Action<PEAssemb
             EmitOptions emitOptions,
             bool verify)
         {
-            CompilationVerifier verifier = null;
-
-            verifier = new CompilationVerifier(this, compilation, dependencies);
+            var verifier = new CompilationVerifier(compilation, VisualizeRealIL, dependencies);
 
             verifier.Emit(expectedOutput, expectedReturnCode, args, manifestResources, emitOptions, verify, expectedSignatures);