Revert "Make compilation outputs available via a workspace service (#34809)"

src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs

@@ -1790,35 +1790,30 @@ public void Debug()
             parsedArgs.Errors.Verify();
             Assert.False(parsedArgs.CompilationOptions.DebugPlusMode);
             Assert.False(parsedArgs.EmitPdb);
-            Assert.False(parsedArgs.EmitPdbFile);
             Assert.Equal(parsedArgs.EmitOptions.DebugInformationFormat, platformPdbKind);
 
             parsedArgs = DefaultParse(new[] { "/debug-", "a.cs" }, WorkingDirectory);
             parsedArgs.Errors.Verify();
             Assert.False(parsedArgs.CompilationOptions.DebugPlusMode);
             Assert.False(parsedArgs.EmitPdb);
-            Assert.False(parsedArgs.EmitPdbFile);
             Assert.Equal(parsedArgs.EmitOptions.DebugInformationFormat, platformPdbKind);
 
             parsedArgs = DefaultParse(new[] { "/debug", "a.cs" }, WorkingDirectory);
             parsedArgs.Errors.Verify();
             Assert.False(parsedArgs.CompilationOptions.DebugPlusMode);
             Assert.True(parsedArgs.EmitPdb);
-            Assert.True(parsedArgs.EmitPdbFile);
             Assert.Equal(parsedArgs.EmitOptions.DebugInformationFormat, platformPdbKind);
 
             parsedArgs = DefaultParse(new[] { "/debug+", "a.cs" }, WorkingDirectory);
             parsedArgs.Errors.Verify();
             Assert.True(parsedArgs.CompilationOptions.DebugPlusMode);
             Assert.True(parsedArgs.EmitPdb);
-            Assert.True(parsedArgs.EmitPdbFile);
             Assert.Equal(parsedArgs.EmitOptions.DebugInformationFormat, platformPdbKind);
 
             parsedArgs = DefaultParse(new[] { "/debug+", "/debug-", "a.cs" }, WorkingDirectory);
             parsedArgs.Errors.Verify();
             Assert.False(parsedArgs.CompilationOptions.DebugPlusMode);
             Assert.False(parsedArgs.EmitPdb);
-            Assert.False(parsedArgs.EmitPdbFile);
             Assert.Equal(parsedArgs.EmitOptions.DebugInformationFormat, platformPdbKind);
 
             parsedArgs = DefaultParse(new[] { "/debug:full", "a.cs" }, WorkingDirectory);
@@ -1832,7 +1827,6 @@ public void Debug()
             Assert.False(parsedArgs.CompilationOptions.DebugPlusMode);
             Assert.True(parsedArgs.EmitPdb);
             Assert.Equal(parsedArgs.EmitOptions.DebugInformationFormat, platformPdbKind);
-            Assert.Equal(Path.Combine(WorkingDirectory, "a.pdb"), parsedArgs.GetPdbFilePath("a.dll"));
 
             parsedArgs = DefaultParse(new[] { "/debug:pdbonly", "a.cs" }, WorkingDirectory);
             parsedArgs.Errors.Verify();
@@ -1845,14 +1839,12 @@ public void Debug()
             Assert.False(parsedArgs.CompilationOptions.DebugPlusMode);
             Assert.True(parsedArgs.EmitPdb);
             Assert.Equal(parsedArgs.EmitOptions.DebugInformationFormat, DebugInformationFormat.PortablePdb);
-            Assert.Equal(Path.Combine(WorkingDirectory, "a.pdb"), parsedArgs.GetPdbFilePath("a.dll"));
 
             parsedArgs = DefaultParse(new[] { "/debug:embedded", "a.cs" }, WorkingDirectory);
             parsedArgs.Errors.Verify();
             Assert.False(parsedArgs.CompilationOptions.DebugPlusMode);
             Assert.True(parsedArgs.EmitPdb);
             Assert.Equal(parsedArgs.EmitOptions.DebugInformationFormat, DebugInformationFormat.Embedded);
-            Assert.Equal(Path.Combine(WorkingDirectory, "a.pdb"), parsedArgs.GetPdbFilePath("a.dll"));
 
             parsedArgs = DefaultParse(new[] { "/debug:PDBONLY", "a.cs" }, WorkingDirectory);
             parsedArgs.Errors.Verify();
@@ -1920,23 +1912,14 @@ public void Pdb()
         {
             var parsedArgs = DefaultParse(new[] { "/pdb:something", "a.cs" }, WorkingDirectory);
             Assert.Equal(Path.Combine(WorkingDirectory, "something.pdb"), parsedArgs.PdbPath);
-            Assert.Equal(Path.Combine(WorkingDirectory, "something.pdb"), parsedArgs.GetPdbFilePath("a.dll"));
-            Assert.False(parsedArgs.EmitPdbFile);
 
-            parsedArgs = DefaultParse(new[] { "/pdb:something", "/debug:embedded", "a.cs" }, WorkingDirectory);
-            Assert.Equal(Path.Combine(WorkingDirectory, "something.pdb"), parsedArgs.PdbPath);
-            Assert.Equal(Path.Combine(WorkingDirectory, "something.pdb"), parsedArgs.GetPdbFilePath("a.dll"));
-            Assert.False(parsedArgs.EmitPdbFile);
-
-            parsedArgs = DefaultParse(new[] { "/debug", "a.cs" }, WorkingDirectory);
+            // No pdb
+            parsedArgs = DefaultParse(new[] { @"/debug", "a.cs" }, WorkingDirectory);
             parsedArgs.Errors.Verify();
             Assert.Null(parsedArgs.PdbPath);
-            Assert.True(parsedArgs.EmitPdbFile);
-            Assert.Equal(Path.Combine(WorkingDirectory, "a.pdb"), parsedArgs.GetPdbFilePath("a.dll"));
 
             parsedArgs = DefaultParse(new[] { "/pdb", "/debug", "a.cs" }, WorkingDirectory);
             parsedArgs.Errors.Verify(Diagnostic(ErrorCode.ERR_NoFileSpec).WithArguments("/pdb"));
-            Assert.Equal(Path.Combine(WorkingDirectory, "a.pdb"), parsedArgs.GetPdbFilePath("a.dll"));
 
             parsedArgs = DefaultParse(new[] { "/pdb:", "/debug", "a.cs" }, WorkingDirectory);
             parsedArgs.Errors.Verify(Diagnostic(ErrorCode.ERR_NoFileSpec).WithArguments("/pdb:"));
@@ -3327,7 +3310,6 @@ public void ParseOut()
             Assert.Equal("MyBinary.dll", parsedArgs.OutputFileName);
             Assert.Equal("MyBinary.dll", parsedArgs.CompilationOptions.ModuleName);
             Assert.Equal(@"C:\MyFolder", parsedArgs.OutputDirectory);
-            Assert.Equal(@"C:\MyFolder\MyBinary.dll", parsedArgs.GetOutputFilePath(parsedArgs.OutputFileName));
 
             // Should handle quotes
             parsedArgs = DefaultParse(new[] { @"/out:""C:\My Folder\MyBinary.dll""", "a.cs" }, baseDirectory);
@@ -3344,7 +3326,6 @@ public void ParseOut()
             Assert.Equal("MyBinary.dll", parsedArgs.OutputFileName);
             Assert.Equal("MyBinary.dll", parsedArgs.CompilationOptions.ModuleName);
             Assert.Equal(baseDirectory, parsedArgs.OutputDirectory);
-            Assert.Equal(Path.Combine(baseDirectory, "MyBinary.dll"), parsedArgs.GetOutputFilePath(parsedArgs.OutputFileName));
 
             // Should expand partially qualified paths
             parsedArgs = DefaultParse(new[] { @"/out:..\MyBinary.dll", "a.cs" }, baseDirectory);

src/Compilers/Core/Portable/CommandLine/CommandLineArguments.cs

@@ -292,51 +292,6 @@ internal CommandLineArguments()
         {
         }
 
-        /// <summary>
-        /// Returns a full path of the file that the compiler will generate the assembly to if compilation succeeds.
-        /// </summary>
-        /// <remarks>
-        /// The method takes <paramref name="outputFileName"/> rather than using the value of <see cref="OutputFileName"/> 
-        /// since the latter might be unspecified, in which case actual output path can't be determined for C# command line
-        /// without creating a compilation and finding an entry point. VB does not allow <see cref="OutputFileName"/> to 
-        /// be unspecified.
-        /// </remarks>
-        public string GetOutputFilePath(string outputFileName)
-        {
-            if (outputFileName == null)
-            {
-                throw new ArgumentNullException(nameof(outputFileName));
-            }
-
-            return Path.Combine(OutputDirectory, outputFileName);
-        }
-
-        /// <summary>
-        /// Returns a full path of the PDB file that the compiler will generate the debug symbols to 
-        /// if <see cref="EmitPdbFile"/> is true and the compilation succeeds.
-        /// </summary>
-        /// <remarks>
-        /// The method takes <paramref name="outputFileName"/> rather than using the value of <see cref="OutputFileName"/> 
-        /// since the latter might be unspecified, in which case actual output path can't be determined for C# command line
-        /// without creating a compilation and finding an entry point. VB does not allow <see cref="OutputFileName"/> to 
-        /// be unspecified.
-        /// </remarks>
-        public string GetPdbFilePath(string outputFileName)
-        {
-            if (outputFileName == null)
-            {
-                throw new ArgumentNullException(nameof(outputFileName));
-            }
-
-            return PdbPath ?? Path.Combine(OutputDirectory, Path.ChangeExtension(outputFileName, ".pdb"));
-        }
-
-        /// <summary>
-        /// Returns true if the PDB is generated to a PDB file, as opposed to embedded to the output binary and not generated at all.
-        /// </summary>
-        public bool EmitPdbFile
-            => EmitPdb && EmitOptions.DebugInformationFormat != DebugInformationFormat.Embedded;
-
         #region Metadata References
 
         /// <summary>

src/Compilers/Core/Portable/CommandLine/CommonCompiler.cs

@@ -882,8 +882,8 @@ private void CompileAndEmit(
             cancellationToken.ThrowIfCancellationRequested();
 
             string outputName = GetOutputFileName(compilation, cancellationToken);
-            var finalPeFilePath = Arguments.GetOutputFilePath(outputName);
-            var finalPdbFilePath = Arguments.GetPdbFilePath(outputName);
+            var finalPeFilePath = Path.Combine(Arguments.OutputDirectory, outputName);
+            var finalPdbFilePath = Arguments.PdbPath ?? Path.ChangeExtension(finalPeFilePath, ".pdb");
             var finalXmlFilePath = Arguments.DocumentationPath;
 
             NoThrowStreamDisposer sourceLinkStreamDisposerOpt = null;
@@ -1035,8 +1035,10 @@ private void CompileAndEmit(
 
                     if (success)
                     {
+                        bool emitPdbFile = Arguments.EmitPdb && emitOptions.DebugInformationFormat != Emit.DebugInformationFormat.Embedded;
+
                         var peStreamProvider = new CompilerEmitStreamProvider(this, finalPeFilePath);
-                        var pdbStreamProviderOpt = Arguments.EmitPdbFile ? new CompilerEmitStreamProvider(this, finalPdbFilePath) : null;
+                        var pdbStreamProviderOpt = emitPdbFile ? new CompilerEmitStreamProvider(this, finalPdbFilePath) : null;
 
                         string finalRefPeFilePath = Arguments.OutputRefFilePath;
                         var refPeStreamProviderOpt = finalRefPeFilePath != null ? new CompilerEmitStreamProvider(this, finalRefPeFilePath) : null;

src/Compilers/Core/Portable/PublicAPI.Unshipped.txt

@@ -1,8 +1,5 @@
 *REMOVED*Microsoft.CodeAnalysis.Operations.IEventAssignmentOperation.EventReference.get -> Microsoft.CodeAnalysis.Operations.IEventReferenceOperation
 *REMOVED*Microsoft.CodeAnalysis.SpecialType.Count = 43 -> Microsoft.CodeAnalysis.SpecialType
-Microsoft.CodeAnalysis.CommandLineArguments.EmitPdbFile.get -> bool
-Microsoft.CodeAnalysis.CommandLineArguments.GetOutputFilePath(string outputFileName) -> string
-Microsoft.CodeAnalysis.CommandLineArguments.GetPdbFilePath(string outputFileName) -> string
 Microsoft.CodeAnalysis.IArrayTypeSymbol.ElementNullableAnnotation.get -> Microsoft.CodeAnalysis.NullableAnnotation
 Microsoft.CodeAnalysis.IDiscardSymbol.NullableAnnotation.get -> Microsoft.CodeAnalysis.NullableAnnotation
 Microsoft.CodeAnalysis.IEventSymbol.NullableAnnotation.get -> Microsoft.CodeAnalysis.NullableAnnotation

src/EditorFeatures/Test/EditAndContinue/EditAndContinueMethodDebugInfoReaderTests.cs → src/EditorFeatures/CSharpTest/EditAndContinue/EditAndContinueMethodDebugInfoReaderTests.cs

@@ -1,20 +1,19 @@
 // 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 System.Reflection.Metadata;
+using System.Reflection;
 using System.Reflection.Metadata.Ecma335;
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
-using Microsoft.CodeAnalysis.Debugging;
+using Microsoft.CodeAnalysis.EditAndContinue;
 using Microsoft.CodeAnalysis.Emit;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.UnitTests;
 using Microsoft.DiaSymReader;
 using Microsoft.DiaSymReader.PortablePdb;
-using Moq;
 using Roslyn.Test.Utilities;
 using Xunit;
 
-namespace Microsoft.CodeAnalysis.EditAndContinue.UnitTests
+namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.EditAndContinue
 {
     public class EditAndContinueMethodDebugInfoReaderTests
     {
@@ -23,24 +22,26 @@ private class DummyMetadataImportProvider : IMetadataImportProvider
             public object GetMetadataImport() => throw new NotImplementedException();
         }
 
-        [Fact]
-        public void Create_Errors()
+        private class DummySymReaderMetadataProvider : ISymReaderMetadataProvider
         {
-            Assert.Throws<ArgumentNullException>(() => EditAndContinueMethodDebugInfoReader.Create((ISymUnmanagedReader5)null));
-            Assert.Throws<ArgumentNullException>(() => EditAndContinueMethodDebugInfoReader.Create((MetadataReader)null));
-            Assert.Throws<ArgumentNullException>(() => EditAndContinueMethodDebugInfoReader.Create(null, 1));
+            public unsafe bool TryGetStandaloneSignature(int standaloneSignatureToken, out byte* signature, out int length)
+                => throw new NotImplementedException();
 
-            var mockSymReader = new Mock<ISymUnmanagedReader5>().Object;
-            Assert.Throws<ArgumentOutOfRangeException>(() => EditAndContinueMethodDebugInfoReader.Create(mockSymReader, 0));
-            Assert.Throws<ArgumentOutOfRangeException>(() => EditAndContinueMethodDebugInfoReader.Create(mockSymReader, -1));
+            public bool TryGetTypeDefinitionInfo(int typeDefinitionToken, out string namespaceName, out string typeName, out TypeAttributes attributes)
+                => throw new NotImplementedException();
+
+            public bool TryGetTypeReferenceInfo(int typeReferenceToken, out string namespaceName, out string typeName)
+                => throw new NotImplementedException();
         }
 
         [Theory]
-        [InlineData(DebugInformationFormat.PortablePdb, true)]
-        [InlineData(DebugInformationFormat.PortablePdb, false)]
-        [InlineData(DebugInformationFormat.Pdb, true)]
-        public void DebugInfo(DebugInformationFormat format, bool useSymReader)
+        [InlineData(DebugInformationFormat.PortablePdb)]
+        [InlineData(DebugInformationFormat.Pdb)]
+        public void DebugInfo(DebugInformationFormat format)
         {
+            var symBinder = new SymBinder();
+            var metadataImportProvider = new DummyMetadataImportProvider();
+
             var source = @"
 using System;
 delegate void D();
@@ -60,22 +61,22 @@ public static void Main()
             compilation.EmitToArray(new EmitOptions(debugInformationFormat: format), pdbStream: pdbStream);
             pdbStream.Position = 0;
 
-            DebugInformationReaderProvider provider;
-            EditAndContinueMethodDebugInfoReader reader;
+            var pdbStreamCom = SymUnmanagedStreamFactory.CreateStream(pdbStream);
 
-            if (format == DebugInformationFormat.PortablePdb && useSymReader)
+            ISymUnmanagedReader5 symReader5;
+            if (format == DebugInformationFormat.PortablePdb)
             {
-                var pdbStreamCom = SymUnmanagedStreamFactory.CreateStream(pdbStream);
-                var metadataImportProvider = new DummyMetadataImportProvider();
-                Assert.Equal(0, new SymBinder().GetReaderFromPdbStream(metadataImportProvider, pdbStreamCom, out var symReader));
-                reader = EditAndContinueMethodDebugInfoReader.Create((ISymUnmanagedReader5)symReader, version: 1);
+                int hr = symBinder.GetReaderFromPdbStream(metadataImportProvider, pdbStreamCom, out var symReader);
+                Assert.Equal(0, hr);
+                symReader5 = (ISymUnmanagedReader5)symReader;
             }
             else
             {
-                provider = DebugInformationReaderProvider.CreateFromStream(pdbStream);
-                reader = provider.CreateEditAndContinueMethodDebugInfoReader();
+                symReader5 = SymUnmanagedReaderFactory.CreateReader<ISymUnmanagedReader5>(pdbStream, new DummySymReaderMetadataProvider());
             }
 
+            var reader = EditAndContinueMethodDebugInfoReader.Create(symReader5, version: 1);
+
             // Main method
             var debugInfo = reader.GetDebugInfo(MetadataTokens.MethodDefinitionHandle(5));
             Assert.Equal(0, debugInfo.GetMethodOrdinal());