Remove serialization code

Binary serialization is not supported in CoreCLR and hence must be removed
from the subset which runs there.  This code is only used to support
CodeLens so rather than moving it around we are simply removing it
completely.  It will be relocated to CodeLens internally to continue supporting
their scenarios.

The Public API changes to DocumentId and ProjectId were necessary to
continue supporting serialization outside of the Roslyn code base.

closes #915

src/Compilers/CSharp/Desktop/CSharpCodeAnalysis.Desktop.csproj

@@ -78,9 +78,7 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="CSharpSerializableParseOptions.cs" />
     <Compile Include="CSharpFileSystemExtensions.cs" />
-    <Compile Include="CSharpSerializableCompilationOptions.cs" />
     <Compile Include="CommandLine\CommandLineArguments.cs" />
     <Compile Include="CommandLine\CommandLineDiagnosticFormatter.cs" />
     <Compile Include="CommandLine\CommandLineParser.cs" />
@@ -116,4 +114,4 @@
     <Import Project="..\..\..\..\build\VSL.Imports.Closed.targets" />
     <Import Project="$(SolutionDir)\.nuget\NuGet.targets" Condition="Exists('$(SolutionDir)\.nuget\NuGet.targets')" />
   </ImportGroup>
-</Project>
+</Project>
\ No newline at end of file

src/Compilers/CSharp/Desktop/CSharpSerializableCompilationOptions.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.Collections.Generic;
-using System.Collections.Immutable;
-using System.Linq;
-using System.Runtime.Serialization;
-
-namespace Microsoft.CodeAnalysis.CSharp
-{
-    [Serializable]
-    public sealed class CSharpSerializableCompilationOptions : SerializableCompilationOptions
-    {
-        private const string AllowUnsafeString = "AllowUnsafe";
-        private const string UsingsString = "Usings";
-
-        private readonly CSharpCompilationOptions _options;
-
-        public CSharpSerializableCompilationOptions(CSharpCompilationOptions options)
-        {
-            if (options == null)
-            {
-                throw new ArgumentNullException("options");
-            }
-
-            _options = options;
-        }
-
-        private CSharpSerializableCompilationOptions(SerializationInfo info, StreamingContext context)
-        {
-            _options = new CSharpCompilationOptions(
-                outputKind: (OutputKind)info.GetInt32(OutputKindString),
-                moduleName: info.GetString(ModuleNameString),
-                mainTypeName: info.GetString(MainTypeNameString),
-                scriptClassName: info.GetString(ScriptClassNameString),
-                usings: (string[])info.GetValue(UsingsString, typeof(string[])),
-                cryptoKeyContainer: info.GetString(CryptoKeyContainerString),
-                cryptoKeyFile: info.GetString(CryptoKeyFileString),
-                cryptoPublicKey: ((byte[])info.GetValue(CryptoPublicKeyString, typeof(byte[]))).AsImmutableOrNull(),
-                delaySign: (bool?)info.GetValue(DelaySignString, typeof(bool?)),
-                optimizationLevel: (OptimizationLevel)info.GetInt32(OptimizeString),
-                checkOverflow: info.GetBoolean(CheckOverflowString),
-                allowUnsafe: info.GetBoolean(AllowUnsafeString),
-                platform: (Platform)info.GetInt32(PlatformString),
-                generalDiagnosticOption: (ReportDiagnostic)info.GetInt32(GeneralDiagnosticOptionString),
-                warningLevel: info.GetInt32(WarningLevelString),
-                specificDiagnosticOptions: ((Dictionary<string, ReportDiagnostic>)info.GetValue(SpecificDiagnosticOptionsString, typeof(Dictionary<string, ReportDiagnostic>))).ToImmutableDictionary(),
-                concurrentBuild: info.GetBoolean(ConcurrentBuildString),
-                extendedCustomDebugInformation: info.GetBoolean(ExtendedCustomDebugInformationString),
-                xmlReferenceResolver: XmlFileResolver.Default,
-                sourceReferenceResolver: SourceFileResolver.Default,
-                metadataReferenceResolver: new AssemblyReferenceResolver(MetadataFileReferenceResolver.Default, MetadataFileReferenceProvider.Default),
-                assemblyIdentityComparer: DesktopAssemblyIdentityComparer.Default,
-                strongNameProvider: new DesktopStrongNameProvider(),
-                metadataImportOptions: (MetadataImportOptions)info.GetByte(MetadataImportOptionsString),
-                features: ((string[])info.GetValue(FeaturesString, typeof(string[]))).AsImmutable());
-        }
-
-        public override void GetObjectData(SerializationInfo info, StreamingContext context)
-        {
-            CommonGetObjectData(_options, info, context);
-
-            info.AddValue(UsingsString, _options.Usings.ToArray());
-            info.AddValue(AllowUnsafeString, _options.AllowUnsafe);
-        }
-
-        public new CSharpCompilationOptions Options
-        {
-            get { return _options; }
-        }
-
-        protected override CompilationOptions CommonOptions
-        {
-            get { return _options; }
-        }
-    }
-}

src/Compilers/CSharp/Desktop/CSharpSerializableParseOptions.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 Roslyn.Utilities;
-using System.Runtime.Serialization;
-
-namespace Microsoft.CodeAnalysis.CSharp
-{
-    [Serializable]
-    public sealed class CSharpSerializableParseOptions : SerializableParseOptions
-    {
-        private readonly CSharpParseOptions _options;
-
-        public CSharpSerializableParseOptions(CSharpParseOptions options)
-        {
-            if (options == null)
-            {
-                throw new ArgumentNullException("options");
-            }
-
-            _options = options;
-        }
-
-        public new ParseOptions Options
-        {
-            get { return _options; }
-        }
-
-        protected override ParseOptions CommonOptions
-        {
-            get { return _options; }
-        }
-
-        private CSharpSerializableParseOptions(SerializationInfo info, StreamingContext context)
-        {
-            _options = new CSharpParseOptions(
-                languageVersion: (LanguageVersion)info.GetValue("LanguageVersion", typeof(LanguageVersion)),
-                documentationMode: (DocumentationMode)info.GetValue("DocumentationMode", typeof(DocumentationMode)),
-                kind: (SourceCodeKind)info.GetValue("Kind", typeof(SourceCodeKind)),
-                preprocessorSymbols: info.GetArray<string>("PreprocessorSymbols"));
-        }
-
-        public override void GetObjectData(SerializationInfo info, StreamingContext context)
-        {
-            CommonGetObjectData(_options, info, context);
-
-            info.AddValue("LanguageVersion", _options.LanguageVersion, typeof(LanguageVersion));
-            info.AddArray("PreprocessorSymbols", _options.PreprocessorSymbols);
-        }
-    }
-}

src/Compilers/CSharp/Desktop/PublicAPI.txt

@@ -4,20 +4,10 @@ Microsoft.CodeAnalysis.CSharp.CSharpCommandLineArguments.ParseOptions.get -> Mic
 Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser
 Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser.Parse(System.Collections.Generic.IEnumerable<string> args, string baseDirectory, string additionalReferencePaths = null) -> Microsoft.CodeAnalysis.CSharp.CSharpCommandLineArguments
 Microsoft.CodeAnalysis.CSharp.CSharpFileSystemExtensions
-Microsoft.CodeAnalysis.CSharp.CSharpSerializableCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpSerializableCompilationOptions.CSharpSerializableCompilationOptions(Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions options) -> void
-Microsoft.CodeAnalysis.CSharp.CSharpSerializableCompilationOptions.Options.get -> Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions
-Microsoft.CodeAnalysis.CSharp.CSharpSerializableParseOptions
-Microsoft.CodeAnalysis.CSharp.CSharpSerializableParseOptions.CSharpSerializableParseOptions(Microsoft.CodeAnalysis.CSharp.CSharpParseOptions options) -> void
-Microsoft.CodeAnalysis.CSharp.CSharpSerializableParseOptions.Options.get -> Microsoft.CodeAnalysis.ParseOptions
 override Microsoft.CodeAnalysis.CSharp.CSharpCommandLineArguments.CompilationOptionsCore.get -> Microsoft.CodeAnalysis.CompilationOptions
 override Microsoft.CodeAnalysis.CSharp.CSharpCommandLineArguments.ParseOptionsCore.get -> Microsoft.CodeAnalysis.ParseOptions
 override Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser.RegularFileExtension.get -> string
 override Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser.ScriptFileExtension.get -> string
-override Microsoft.CodeAnalysis.CSharp.CSharpSerializableCompilationOptions.CommonOptions.get -> Microsoft.CodeAnalysis.CompilationOptions
-override Microsoft.CodeAnalysis.CSharp.CSharpSerializableCompilationOptions.GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) -> void
-override Microsoft.CodeAnalysis.CSharp.CSharpSerializableParseOptions.CommonOptions.get -> Microsoft.CodeAnalysis.ParseOptions
-override Microsoft.CodeAnalysis.CSharp.CSharpSerializableParseOptions.GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) -> void
 static Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser.ParseConditionalCompilationSymbols(string value, out System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.Diagnostic> diagnostics) -> System.Collections.Generic.IEnumerable<string>
 static Microsoft.CodeAnalysis.CSharp.CSharpFileSystemExtensions.Emit(this Microsoft.CodeAnalysis.CSharp.CSharpCompilation compilation, string outputPath, string pdbPath = null, string xmlDocumentationPath = null, string win32ResourcesPath = null, System.Collections.Generic.IEnumerable<Microsoft.CodeAnalysis.ResourceDescription> manifestResources = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.Emit.EmitResult
 static readonly Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser.Default -> Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser

src/Compilers/CSharp/Test/Symbol/Compilation/CSharpCompilationOptionsTests.cs

@@ -359,36 +359,6 @@ private static CSharpCompilationOptions CreateCSharpCompilationOptions()
                 assemblyIdentityComparer, strongNameProvider, metadataImportOptions, features);
         }
 
-        [Fact]
-        public void Serializability1()
-        {
-            VerifySerializability(new CSharpSerializableCompilationOptions(new CSharpCompilationOptions(
-                outputKind: OutputKind.WindowsApplication,
-                usings: new[] { "F", "G" },
-                generalDiagnosticOption: ReportDiagnostic.Hidden,
-                specificDiagnosticOptions: new[] { KeyValuePair.Create("CS0001", ReportDiagnostic.Suppress) })));
-        }
-
-        [Fact]
-        public void Serializability2()
-        {
-            var parseOptions = new CSharpParseOptions(LanguageVersion.CSharp3, DocumentationMode.Diagnose, SourceCodeKind.Interactive);
-            var compilationOptions = new CSharpCompilationOptions(
-                OutputKind.DynamicallyLinkedLibrary,
-                moduleName: "M",
-                optimizationLevel: OptimizationLevel.Release);
-            compilationOptions = compilationOptions.
-                WithConcurrentBuild(!compilationOptions.ConcurrentBuild).
-                WithExtendedCustomDebugInformation(!compilationOptions.ExtendedCustomDebugInformation);
-            var deserializedCompilationOptions = VerifySerializability(new CSharpSerializableCompilationOptions(compilationOptions)).Options;
-
-            Assert.Equal(compilationOptions.OutputKind, deserializedCompilationOptions.OutputKind);
-            Assert.Equal(compilationOptions.ModuleName, deserializedCompilationOptions.ModuleName);
-            Assert.Equal(compilationOptions.OptimizationLevel, deserializedCompilationOptions.OptimizationLevel);
-            Assert.Equal(compilationOptions.ConcurrentBuild, deserializedCompilationOptions.ConcurrentBuild);
-            Assert.Equal(compilationOptions.ExtendedCustomDebugInformation, deserializedCompilationOptions.ExtendedCustomDebugInformation);
-        }
-
         [Fact]
         public void WithCryptoPublicKey()
         {

src/Compilers/CSharp/Test/Syntax/Parsing/CSharpParseOptionsTests.cs

@@ -71,15 +71,5 @@ public void TestFieldsForEqualsAndGetHashCode()
                 "PreprocessorSymbolNames",
                 "PreprocessorSymbols");
         }
-
-        [Fact]
-        public void Serializability()
-        {
-            VerifySerializability(new CSharpSerializableParseOptions(new CSharpParseOptions(
-                languageVersion: LanguageVersion.CSharp6,
-                documentationMode: DocumentationMode.None,
-                kind: SourceCodeKind.Interactive,
-                preprocessorSymbols: new[] { "A", "B" })));
-        }
     }
 }

src/Compilers/Core/Desktop/CodeAnalysis.Desktop.csproj

@@ -97,9 +97,6 @@
     <Compile Include="MetadataFileReferenceResolver.cs" />
     <Compile Include="PathKind.cs" />
     <Compile Include="PathUtilities.cs" />
-    <Compile Include="SerializableCompilationOptions.cs" />
-    <Compile Include="SerializableParseOptions.cs" />
-    <Compile Include="SerializationInfoExtensions.cs" />
     <Compile Include="SourceFileResolver.cs" />
     <Compile Include="SqmServiceProvider.cs" />
     <Compile Include="XmlFileResolver.cs" />

src/Compilers/Core/Desktop/PublicAPI.txt

@@ -77,10 +77,6 @@ Microsoft.CodeAnalysis.RuleSetInclude.Action.get -> Microsoft.CodeAnalysis.Repor
 Microsoft.CodeAnalysis.RuleSetInclude.IncludePath.get -> string
 Microsoft.CodeAnalysis.RuleSetInclude.LoadRuleSet(Microsoft.CodeAnalysis.RuleSet parent) -> Microsoft.CodeAnalysis.RuleSet
 Microsoft.CodeAnalysis.RuleSetInclude.RuleSetInclude(string includePath, Microsoft.CodeAnalysis.ReportDiagnostic action) -> void
-Microsoft.CodeAnalysis.SerializableCompilationOptions
-Microsoft.CodeAnalysis.SerializableCompilationOptions.Options.get -> Microsoft.CodeAnalysis.CompilationOptions
-Microsoft.CodeAnalysis.SerializableParseOptions
-Microsoft.CodeAnalysis.SerializableParseOptions.Options.get -> Microsoft.CodeAnalysis.ParseOptions
 Microsoft.CodeAnalysis.SourceFileResolver
 Microsoft.CodeAnalysis.SourceFileResolver.BaseDirectory.get -> string
 Microsoft.CodeAnalysis.SourceFileResolver.SearchPaths.get -> System.Collections.Immutable.ImmutableArray<string>
@@ -93,10 +89,6 @@ abstract Microsoft.CodeAnalysis.CommandLineArguments.CompilationOptionsCore.get
 abstract Microsoft.CodeAnalysis.CommandLineArguments.ParseOptionsCore.get -> Microsoft.CodeAnalysis.ParseOptions
 abstract Microsoft.CodeAnalysis.CommandLineParser.RegularFileExtension.get -> string
 abstract Microsoft.CodeAnalysis.CommandLineParser.ScriptFileExtension.get -> string
-abstract Microsoft.CodeAnalysis.SerializableCompilationOptions.CommonOptions.get -> Microsoft.CodeAnalysis.CompilationOptions
-abstract Microsoft.CodeAnalysis.SerializableCompilationOptions.GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) -> void
-abstract Microsoft.CodeAnalysis.SerializableParseOptions.CommonOptions.get -> Microsoft.CodeAnalysis.ParseOptions
-abstract Microsoft.CodeAnalysis.SerializableParseOptions.GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) -> void
 override Microsoft.CodeAnalysis.CommandLineAnalyzerReference.Equals(object obj) -> bool
 override Microsoft.CodeAnalysis.CommandLineAnalyzerReference.GetHashCode() -> int
 override Microsoft.CodeAnalysis.CommandLineReference.Equals(object obj) -> bool
@@ -128,8 +120,6 @@ static Microsoft.CodeAnalysis.FileSystemExtensions.Emit(this Microsoft.CodeAnaly
 static Microsoft.CodeAnalysis.RuleSet.GetDiagnosticOptionsFromRulesetFile(string rulesetFileFullPath, out System.Collections.Generic.Dictionary<string, Microsoft.CodeAnalysis.ReportDiagnostic> specificDiagnosticOptions) -> Microsoft.CodeAnalysis.ReportDiagnostic
 static Microsoft.CodeAnalysis.RuleSet.GetEffectiveIncludesFromFile(string filePath) -> System.Collections.Immutable.ImmutableArray<string>
 static Microsoft.CodeAnalysis.RuleSet.LoadEffectiveRuleSetFromFile(string filePath) -> Microsoft.CodeAnalysis.RuleSet
-static Microsoft.CodeAnalysis.SerializableCompilationOptions.CommonGetObjectData(Microsoft.CodeAnalysis.CompilationOptions options, System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) -> void
-static Microsoft.CodeAnalysis.SerializableParseOptions.CommonGetObjectData(Microsoft.CodeAnalysis.ParseOptions options, System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) -> void
 static readonly Microsoft.CodeAnalysis.DesktopAssemblyIdentityComparer.Default -> Microsoft.CodeAnalysis.DesktopAssemblyIdentityComparer
 static readonly Microsoft.CodeAnalysis.SourceFileResolver.Default -> Microsoft.CodeAnalysis.SourceFileResolver
 static readonly Microsoft.CodeAnalysis.XmlFileResolver.Default -> Microsoft.CodeAnalysis.XmlFileResolver

src/Compilers/Core/Desktop/SerializableCompilationOptions.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.Collections.Generic;
-using System.Linq;
-using System.Runtime.Serialization;
-
-namespace Microsoft.CodeAnalysis
-{
-    /// <summary>
-    /// Represents compilation options common to C# and VB.
-    /// </summary>
-    [Serializable]
-    public abstract class SerializableCompilationOptions : ISerializable
-    {
-        internal const string OutputKindString = "OutputKind";
-        internal const string ModuleNameString = "ModuleName";
-        internal const string MainTypeNameString = "MainTypeName";
-        internal const string ScriptClassNameString = "ScriptClassName";
-        internal const string CryptoKeyContainerString = "CryptoKeyContainer";
-        internal const string CryptoKeyFileString = "CryptoKeyFile";
-        internal const string CryptoPublicKeyString = "CryptoPublicKey";
-        internal const string DelaySignString = "DelaySign";
-        internal const string CheckOverflowString = "CheckOverflow";
-        internal const string PlatformString = "Platform";
-        internal const string GeneralDiagnosticOptionString = "GeneralDiagnosticOption";
-        internal const string WarningLevelString = "WarningLevel";
-        internal const string SpecificDiagnosticOptionsString = "SpecificDiagnosticOptions";
-        internal const string DebugInformationKindString = "DebugInformationKind";
-        internal const string OptimizeString = "Optimize";
-        internal const string ConcurrentBuildString = "ConcurrentBuild";
-        internal const string ExtendedCustomDebugInformationString = "ExtendedCustomDebugInformation";
-        internal const string MetadataImportOptionsString = "MetadataImportOptions";
-        internal const string FeaturesString = "Features";
-
-        internal SerializableCompilationOptions()
-        {
-        }
-
-        protected static void CommonGetObjectData(CompilationOptions options, SerializationInfo info, StreamingContext context)
-        {
-            info.AddValue(OutputKindString, (int)options.OutputKind);
-            info.AddValue(ModuleNameString, options.ModuleName);
-            info.AddValue(MainTypeNameString, options.MainTypeName);
-            info.AddValue(ScriptClassNameString, options.ScriptClassName);
-            info.AddValue(CryptoKeyContainerString, options.CryptoKeyContainer);
-            info.AddValue(CryptoKeyFileString, options.CryptoKeyFile);
-            info.AddValue(CryptoPublicKeyString, options.CryptoPublicKey.ToArray());
-            info.AddValue(DelaySignString, options.DelaySign);
-            info.AddValue(CheckOverflowString, options.CheckOverflow);
-            info.AddValue(PlatformString, (int)options.Platform);
-            info.AddValue(GeneralDiagnosticOptionString, (int)options.GeneralDiagnosticOption);
-            info.AddValue(WarningLevelString, options.WarningLevel);
-            info.AddValue(SpecificDiagnosticOptionsString, new Dictionary<string, ReportDiagnostic>(options.SpecificDiagnosticOptions));
-            info.AddValue(OptimizeString, (int)options.OptimizationLevel);
-            info.AddValue(ConcurrentBuildString, options.ConcurrentBuild);
-            info.AddValue(ExtendedCustomDebugInformationString, options.ExtendedCustomDebugInformation);
-            info.AddValue(MetadataImportOptionsString, (byte)options.MetadataImportOptions);
-            info.AddValue(FeaturesString, options.Features.ToArray());
-        }
-
-        public CompilationOptions Options { get { return CommonOptions; } }
-        protected abstract CompilationOptions CommonOptions { get; }
-
-        public abstract void GetObjectData(SerializationInfo info, StreamingContext context);
-    }
-}

src/Compilers/Core/Desktop/SerializableParseOptions.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.Runtime.Serialization;
-
-namespace Microsoft.CodeAnalysis
-{
-    /// <summary>
-    /// Represents parse options common to C# and VB.
-    /// </summary>
-    [Serializable]
-    public abstract class SerializableParseOptions : ISerializable
-    {
-        internal SerializableParseOptions()
-        {
-        }
-
-        public ParseOptions Options { get { return CommonOptions; } }
-        protected abstract ParseOptions CommonOptions { get; }
-
-        public abstract void GetObjectData(SerializationInfo info, StreamingContext context);
-
-        protected static void CommonGetObjectData(ParseOptions options, SerializationInfo info, StreamingContext context)
-        {
-            //public readonly SourceCodeKind Kind;
-            info.AddValue("Kind", options.Kind, typeof(SourceCodeKind));
-
-            //public readonly DocumentationMode DocumentationMode;
-            info.AddValue("DocumentationMode", options.DocumentationMode, typeof(DocumentationMode));
-        }
-    }
-}

src/Compilers/Core/Desktop/SerializationInfoExtensions.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.Collections.Immutable;
-using System.Linq;
-using System.Runtime.Serialization;
-
-namespace Roslyn.Utilities
-{
-    internal static class SerializationInfoExtensions
-    {
-        public static void AddArray<T>(this SerializationInfo info, string name, ImmutableArray<T> value) where T : class
-        {
-            // we will copy the content into an array and serialize the copy
-            // we could serialize elementwise, but that would require serializing
-            // name and type for every serialized element which seems worse than creating a copy.
-            info.AddValue(name, value.IsDefault ? null : value.ToArray(), typeof(T[]));
-        }
-
-        public static ImmutableArray<T> GetArray<T>(this SerializationInfo info, string name) where T : class
-        {
-            var arr = (T[])info.GetValue(name, typeof(T[]));
-            return ImmutableArray.Create<T>(arr);
-        }
-
-        public static void AddByteArray(this SerializationInfo info, string name, ImmutableArray<byte> value)
-        {
-            // we will copy the content into an array and serialize the copy
-            // we could serialize elementwise, but that would require serializing
-            // name and type for every serialized element which seems worse than creating a copy.
-            info.AddValue(name, value.IsDefault ? null : value.ToArray(), typeof(byte[]));
-        }
-
-        public static ImmutableArray<byte> GetByteArray(this SerializationInfo info, string name)
-        {
-            var arr = (byte[])info.GetValue(name, typeof(byte[]));
-            return ImmutableArray.Create<byte>(arr);
-        }
-    }
-}

src/Compilers/VisualBasic/Desktop/BasicCodeAnalysis.Desktop.vbproj

@@ -86,8 +86,6 @@
     <Compile Include="CommandLine\CommandLineParser.vb" />
     <Compile Include="CommandLine\VisualBasicCompiler.vb" />
     <Compile Include="VisualBasicFileSystemExtensions.vb" />
-    <Compile Include="VisualBasicSerializableCompilationOptions.vb" />
-    <Compile Include="VisualBasicSerializableParseOptions.vb" />
   </ItemGroup>
   <ItemGroup>
     <Reference Include="System" />

src/Compilers/VisualBasic/Desktop/PublicAPI.txt

@@ -2,20 +2,10 @@ Microsoft.CodeAnalysis.VisualBasic.VisualBasicCommandLineArguments
 Microsoft.CodeAnalysis.VisualBasic.VisualBasicCommandLineParser
 Microsoft.CodeAnalysis.VisualBasic.VisualBasicCommandLineParser.New(isInteractive As Boolean = False) -> Void
 Microsoft.CodeAnalysis.VisualBasic.VisualBasicCommandLineParser.Parse(args As System.Collections.Generic.IEnumerable(Of String), baseDirectory As String, additionalReferencePaths As String = Nothing) -> Microsoft.CodeAnalysis.VisualBasic.VisualBasicCommandLineArguments
-Microsoft.CodeAnalysis.VisualBasic.VisualBasicSerializableCompilationOptions
-Microsoft.CodeAnalysis.VisualBasic.VisualBasicSerializableCompilationOptions.New(options As Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilationOptions) -> Void
-Microsoft.CodeAnalysis.VisualBasic.VisualBasicSerializableCompilationOptions.Options() -> Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilationOptions
-Microsoft.CodeAnalysis.VisualBasic.VisualBasicSerializableParseOptions
-Microsoft.CodeAnalysis.VisualBasic.VisualBasicSerializableParseOptions.New(options As Microsoft.CodeAnalysis.VisualBasic.VisualBasicParseOptions) -> Void
-Microsoft.CodeAnalysis.VisualBasic.VisualBasicSerializableParseOptions.Options() -> Microsoft.CodeAnalysis.VisualBasic.VisualBasicParseOptions
 Overrides Microsoft.CodeAnalysis.VisualBasic.VisualBasicCommandLineArguments.CompilationOptionsCore() -> Microsoft.CodeAnalysis.CompilationOptions
 Overrides Microsoft.CodeAnalysis.VisualBasic.VisualBasicCommandLineArguments.ParseOptionsCore() -> Microsoft.CodeAnalysis.ParseOptions
 Overrides Microsoft.CodeAnalysis.VisualBasic.VisualBasicCommandLineParser.RegularFileExtension() -> String
 Overrides Microsoft.CodeAnalysis.VisualBasic.VisualBasicCommandLineParser.ScriptFileExtension() -> String
-Overrides Microsoft.CodeAnalysis.VisualBasic.VisualBasicSerializableCompilationOptions.CommonOptions() -> Microsoft.CodeAnalysis.CompilationOptions
-Overrides Microsoft.CodeAnalysis.VisualBasic.VisualBasicSerializableCompilationOptions.GetObjectData(info As System.Runtime.Serialization.SerializationInfo, context As System.Runtime.Serialization.StreamingContext) -> Void
-Overrides Microsoft.CodeAnalysis.VisualBasic.VisualBasicSerializableParseOptions.CommonOptions() -> Microsoft.CodeAnalysis.ParseOptions
-Overrides Microsoft.CodeAnalysis.VisualBasic.VisualBasicSerializableParseOptions.GetObjectData(info As System.Runtime.Serialization.SerializationInfo, context As System.Runtime.Serialization.StreamingContext) -> Void
 Shared Microsoft.CodeAnalysis.VisualBasic.VisualBasicCommandLineParser.ParseConditionalCompilationSymbols(symbolList As String, ByRef diagnostics As System.Collections.Generic.IEnumerable(Of Microsoft.CodeAnalysis.Diagnostic), symbols As System.Collections.Generic.IEnumerable(Of System.Collections.Generic.KeyValuePair(Of String, Object)) = Nothing) -> System.Collections.Generic.IReadOnlyDictionary(Of String, Object)
 Shared ReadOnly Microsoft.CodeAnalysis.VisualBasic.VisualBasicCommandLineParser.Default -> Microsoft.CodeAnalysis.VisualBasic.VisualBasicCommandLineParser
 Shared ReadOnly Microsoft.CodeAnalysis.VisualBasic.VisualBasicCommandLineParser.Interactive -> Microsoft.CodeAnalysis.VisualBasic.VisualBasicCommandLineParser

src/Compilers/VisualBasic/Desktop/VisualBasicSerializableCompilationOptions.vb

-' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-Imports System.Collections.Immutable
-Imports System.Runtime.Serialization
-Imports Microsoft.CodeAnalysis
-
-Namespace Microsoft.CodeAnalysis.VisualBasic
-    <Serializable>
-    Public NotInheritable Class VisualBasicSerializableCompilationOptions
-        Inherits SerializableCompilationOptions
-
-        Private _options As VisualBasicCompilationOptions
-
-        Private Const s_globalImportsString = "GlobalImports"
-        Private Const s_rootNamespaceString = "RootNamespace"
-        Private Const s_optionStrictString = "OptionStrict"
-        Private Const s_optionInferString = "OptionInfer"
-        Private Const s_optionExplicitString = "OptionExplicit"
-        Private Const s_optionCompareTextString = "OptionCompareText"
-        Private Const s_embedVbCoreRuntimeString = "EmbedVbCoreRuntime"
-        Private Const s_suppressEmbeddedDeclarationsString = "SuppressEmbeddedDeclarations"
-        Private Const s_parseOptionsString = "ParseOptions"
-
-        Public Sub New(options As VisualBasicCompilationOptions)
-            If options Is Nothing Then
-                Throw New ArgumentNullException("options")
-            End If
-
-            _options = options
-        End Sub
-
-        Friend Sub New(info As SerializationInfo, context As StreamingContext)
-            Dim serializableOptions = DirectCast(info.GetValue(s_parseOptionsString, GetType(VisualBasicSerializableParseOptions)), VisualBasicSerializableParseOptions)
-
-            _options = New VisualBasicCompilationOptions(
-                outputKind:=DirectCast(info.GetInt32(OutputKindString), OutputKind),
-                moduleName:=info.GetString(ModuleNameString),
-                mainTypeName:=info.GetString(MainTypeNameString),
-                scriptClassName:=info.GetString(ScriptClassNameString),
-                cryptoKeyContainer:=info.GetString(CryptoKeyContainerString),
-                cryptoKeyFile:=info.GetString(CryptoKeyFileString),
-                cryptoPublicKey:=DirectCast(info.GetValue(CryptoPublicKeyString, GetType(Byte())), Byte()).AsImmutableOrNull(),
-                delaySign:=DirectCast(info.GetValue(DelaySignString, GetType(Boolean?)), Boolean?),
-                optimizationLevel:=DirectCast(info.GetInt32(OptimizeString), OptimizationLevel),
-                checkOverflow:=info.GetBoolean(CheckOverflowString),
-                platform:=DirectCast(info.GetInt32(PlatformString), Platform),
-                generalDiagnosticOption:=DirectCast(info.GetInt32(GeneralDiagnosticOptionString), ReportDiagnostic),
-                specificDiagnosticOptions:=DirectCast(info.GetValue(SpecificDiagnosticOptionsString, GetType(Dictionary(Of String, ReportDiagnostic))), Dictionary(Of String, ReportDiagnostic)).ToImmutableDictionary(),
-                concurrentBuild:=info.GetBoolean(ConcurrentBuildString),
-                extendedCustomDebugInformation:=info.GetBoolean(ExtendedCustomDebugInformationString),
-                xmlReferenceResolver:=XmlFileResolver.Default,
-                sourceReferenceResolver:=SourceFileResolver.Default,
-                metadataReferenceResolver:=New AssemblyReferenceResolver(MetadataFileReferenceResolver.Default, MetadataFileReferenceProvider.Default),
-                assemblyIdentityComparer:=DesktopAssemblyIdentityComparer.Default,
-                strongNameProvider:=New DesktopStrongNameProvider(),
-                metadataImportOptions:=DirectCast(info.GetByte(MetadataImportOptionsString), MetadataImportOptions),
-                features:=DirectCast(info.GetValue(FeaturesString, GetType(String())), String()).AsImmutable(),
-                globalImports:=DirectCast(info.GetValue(s_globalImportsString, GetType(String())), String()).Select(AddressOf GlobalImport.Parse),
-                rootNamespace:=info.GetString(s_rootNamespaceString),
-                optionStrict:=CType(info.GetInt32(s_optionStrictString), OptionStrict),
-                optionInfer:=info.GetBoolean(s_optionInferString),
-                optionExplicit:=info.GetBoolean(s_optionExplicitString),
-                optionCompareText:=info.GetBoolean(s_optionCompareTextString),
-                embedVbCoreRuntime:=info.GetBoolean(s_embedVbCoreRuntimeString),
-                suppressEmbeddedDeclarations:=info.GetBoolean(s_suppressEmbeddedDeclarationsString),
-                parseOptions:=If(serializableOptions IsNot Nothing, serializableOptions.Options, Nothing))
-        End Sub
-
-        Public Overrides Sub GetObjectData(info As SerializationInfo, context As StreamingContext)
-            CommonGetObjectData(_options, info, context)
-
-            info.AddValue(s_globalImportsString, _options.GlobalImports.Select(Function(g) g.Name).ToArray())
-            info.AddValue(s_rootNamespaceString, _options.RootNamespace)
-            info.AddValue(s_optionStrictString, _options.OptionStrict)
-            info.AddValue(s_optionInferString, _options.OptionInfer)
-            info.AddValue(s_optionExplicitString, _options.OptionExplicit)
-            info.AddValue(s_optionCompareTextString, _options.OptionCompareText)
-            info.AddValue(s_embedVbCoreRuntimeString, _options.EmbedVbCoreRuntime)
-            info.AddValue(s_suppressEmbeddedDeclarationsString, _options.SuppressEmbeddedDeclarations)
-            info.AddValue(s_parseOptionsString, If(_options.ParseOptions IsNot Nothing, New VisualBasicSerializableParseOptions(_options.ParseOptions), Nothing))
-        End Sub
-
-        Public Shadows ReadOnly Property Options As VisualBasicCompilationOptions
-            Get
-                Return _options
-            End Get
-        End Property
-
-        Protected Overrides ReadOnly Property CommonOptions As CompilationOptions
-            Get
-                Return _options
-            End Get
-        End Property
-    End Class
-End Namespace

src/Compilers/VisualBasic/Desktop/VisualBasicSerializableParseOptions.vb

-' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
-
-Imports System.Runtime.Serialization
-
-Namespace Microsoft.CodeAnalysis.VisualBasic
-    <Serializable>
-    Public Class VisualBasicSerializableParseOptions
-        Inherits SerializableParseOptions
-
-        Private ReadOnly _options As VisualBasicParseOptions
-
-        Public Sub New(options As VisualBasicParseOptions)
-            If options Is Nothing Then
-                Throw New ArgumentNullException("options")
-            End If
-
-            _options = options
-        End Sub
-
-        Public Shadows ReadOnly Property Options As VisualBasicParseOptions
-            Get
-                Return _options
-            End Get
-        End Property
-
-        Protected Overrides ReadOnly Property CommonOptions As ParseOptions
-            Get
-                Return _options
-            End Get
-        End Property
-
-        Private Sub New(info As SerializationInfo, context As StreamingContext)
-            ' We serialize keys and values as two separate arrays 
-            ' to avoid the trouble dealing with situations where deserializer may want to deserialize
-            ' an array before its elements (which gets complicated when elements are structs).
-
-            Dim keys() As String = DirectCast(info.GetValue("Keys", GetType(String())), String())
-            Dim values() As Object = DirectCast(info.GetValue("Values", GetType(Object())), Object())
-
-            Dim count As Integer = keys.Length
-            Debug.Assert(values.Length = count)
-
-            Dim builder = ArrayBuilder(Of KeyValuePair(Of String, Object)).GetInstance
-
-            For i As Integer = 0 To count - 1
-                builder.Add(New KeyValuePair(Of String, Object)(keys(i), values(i)))
-            Next
-
-            _options = New VisualBasicParseOptions(
-                languageVersion:=DirectCast(info.GetValue("LanguageVersion", GetType(LanguageVersion)), LanguageVersion),
-                documentationMode:=DirectCast(info.GetValue("DocumentationMode", GetType(DocumentationMode)), DocumentationMode),
-                kind:=DirectCast(info.GetValue("Kind", GetType(SourceCodeKind)), SourceCodeKind),
-                preprocessorSymbols:=builder.ToImmutableAndFree())
-        End Sub
-
-        Public Overrides Sub GetObjectData(info As SerializationInfo, context As StreamingContext)
-            CommonGetObjectData(_options, info, context)
-
-            ' We serialize keys and values as two separate arrays 
-            ' to avoid the trouble dealing with situations where deserializer may want to deserialize
-            ' an array before its elements (which gets complicated when elements are structs).
-
-            Dim ppSymbols = _options.PreprocessorSymbols
-            Dim keys(ppSymbols.Length - 1) As String
-            Dim values(ppSymbols.Length - 1) As Object
-
-            For i As Integer = 0 To ppSymbols.Length - 1
-                Dim sym = ppSymbols(i)
-                keys(i) = sym.Key
-                values(i) = sym.Value
-            Next
-
-            info.AddValue("Keys", keys, GetType(String()))
-            info.AddValue("Values", values, GetType(Object()))
-            info.AddValue("LanguageVersion", _options.LanguageVersion, GetType(LanguageVersion))
-        End Sub
-    End Class
-End Namespace
-

src/Compilers/VisualBasic/Test/Semantic/Compilation/VisualBasicCompilationOptionsTests.vb

@@ -500,64 +500,6 @@ BC2042: The options /vbruntime* and /target:module cannot be combined.
                 "ParseOptions")
         End Sub
 
-        <Fact>
-        Public Sub Serializability1()
-            VerifySerializability(New VisualBasicSerializableCompilationOptions(New VisualBasicCompilationOptions(
-                outputKind:=OutputKind.WindowsApplication,
-                generalDiagnosticOption:=ReportDiagnostic.Hidden,
-                specificDiagnosticOptions:={KeyValuePair.Create("VB0001", ReportDiagnostic.Suppress)},
-                globalImports:={GlobalImport.Parse("Foo.Bar")})))
-        End Sub
-
-        <Fact>
-        Public Sub Serializability2()
-            VerifySerializability(New VisualBasicSerializableCompilationOptions(New VisualBasicCompilationOptions(
-                outputKind:=OutputKind.WindowsApplication,
-                parseOptions:=New VisualBasicParseOptions(
-                    languageVersion:=LanguageVersion.VisualBasic14,
-                    documentationMode:=DocumentationMode.Diagnose,
-                    preprocessorSymbols:={KeyValuePair.Create(Of String, Object)("s", 1), KeyValuePair.Create(Of String, Object)("t", 2)}))))
-        End Sub
-
-        <Fact>
-        Public Sub Serializability3()
-            Dim parseOptions = New VisualBasicParseOptions(
-                languageVersion:=LanguageVersion.VisualBasic10,
-                documentationMode:=DocumentationMode.Diagnose,
-                kind:=SourceCodeKind.Regular,
-                preprocessorSymbols:=ImmutableArray.Create(New KeyValuePair(Of String, Object)("key", "Value")))
-
-            Dim compilationOptions = New VisualBasicCompilationOptions(
-                OutputKind.ConsoleApplication,
-                globalImports:={GlobalImport.Parse("Foo.Bar")},
-                rootNamespace:="Alpha.Beta",
-                optionStrict:=OptionStrict.Custom,
-                optionInfer:=False,
-                optionExplicit:=False,
-                optionCompareText:=True,
-                embedVbCoreRuntime:=True,
-                parseOptions:=parseOptions)
-
-            Dim deserializedCompilationOptions = VerifySerializability(New VisualBasicSerializableCompilationOptions(compilationOptions)).Options
-
-            Assert.Equal(compilationOptions.GlobalImports.First().Name,
-                         deserializedCompilationOptions.GlobalImports.First().Name)
-            Assert.Equal(compilationOptions.RootNamespace,
-                         deserializedCompilationOptions.RootNamespace)
-            Assert.Equal(compilationOptions.OptionStrict,
-                         deserializedCompilationOptions.OptionStrict)
-            Assert.Equal(compilationOptions.OptionInfer,
-                         deserializedCompilationOptions.OptionInfer)
-            Assert.Equal(compilationOptions.OptionExplicit,
-                         deserializedCompilationOptions.OptionExplicit)
-            Assert.Equal(compilationOptions.OptionCompareText,
-                         deserializedCompilationOptions.OptionCompareText)
-            Assert.Equal(compilationOptions.EmbedVbCoreRuntime,
-                         deserializedCompilationOptions.EmbedVbCoreRuntime)
-            Assert.Equal(compilationOptions.ExtendedCustomDebugInformation,
-                         deserializedCompilationOptions.ExtendedCustomDebugInformation)
-        End Sub
-
         <Fact>
         Public Sub WithCryptoPublicKey()
             Dim options = New VisualBasicCompilationOptions(OutputKind.ConsoleApplication)

src/Compilers/VisualBasic/Test/Syntax/Parser/VisualBasicParseOptionsTests.vb

@@ -246,11 +246,4 @@ Public Class VisualBasicParseOptionsTests
                 "PreprocessorSymbolNames",
                 "PreprocessorSymbols")
     End Sub
-
-    <Fact>
-    Public Sub Serializability()
-        VerifySerializability(New VisualBasicSerializableParseOptions(New VisualBasicParseOptions(
-                    languageVersion:=LanguageVersion.VisualBasic14,
-                    documentationMode:=DocumentationMode.Diagnose)))
-    End Sub
 End Class

src/Test/Utilities/HostedRuntimeEnvironment.cs

@@ -973,4 +973,35 @@ private static string GetMessageFromResult(string expectedOutput, string actualO
             return sb.ToString();
         }
     }
+
+    internal static class SerializationInfoExtensions
+    {
+        public static void AddArray<T>(this SerializationInfo info, string name, ImmutableArray<T> value) where T : class
+        {
+            // we will copy the content into an array and serialize the copy
+            // we could serialize elementwise, but that would require serializing
+            // name and type for every serialized element which seems worse than creating a copy.
+            info.AddValue(name, value.IsDefault ? null : value.ToArray(), typeof(T[]));
+        }
+
+        public static ImmutableArray<T> GetArray<T>(this SerializationInfo info, string name) where T : class
+        {
+            var arr = (T[])info.GetValue(name, typeof(T[]));
+            return ImmutableArray.Create<T>(arr);
+        }
+
+        public static void AddByteArray(this SerializationInfo info, string name, ImmutableArray<byte> value)
+        {
+            // we will copy the content into an array and serialize the copy
+            // we could serialize elementwise, but that would require serializing
+            // name and type for every serialized element which seems worse than creating a copy.
+            info.AddValue(name, value.IsDefault ? null : value.ToArray(), typeof(byte[]));
+        }
+
+        public static ImmutableArray<byte> GetByteArray(this SerializationInfo info, string name)
+        {
+            var arr = (byte[])info.GetValue(name, typeof(byte[]));
+            return ImmutableArray.Create<byte>(arr);
+        }
+    }
 }

src/Workspaces/Core/Desktop/PublicAPI.txt

@@ -17,18 +17,6 @@ Microsoft.CodeAnalysis.MSBuild.MSBuildWorkspace.OpenSolutionAsync(string solutio
 Microsoft.CodeAnalysis.MSBuild.MSBuildWorkspace.Properties.get -> System.Collections.Immutable.ImmutableDictionary<string, string>
 Microsoft.CodeAnalysis.MSBuild.MSBuildWorkspace.SkipUnrecognizedProjects.get -> bool
 Microsoft.CodeAnalysis.MSBuild.MSBuildWorkspace.SkipUnrecognizedProjects.set -> void
-Microsoft.CodeAnalysis.SerializableDocumentId
-Microsoft.CodeAnalysis.SerializableDocumentId.DocumentId.get -> Microsoft.CodeAnalysis.DocumentId
-Microsoft.CodeAnalysis.SerializableDocumentId.SerializableDocumentId(Microsoft.CodeAnalysis.DocumentId documentId) -> void
-Microsoft.CodeAnalysis.SerializableProjectId
-Microsoft.CodeAnalysis.SerializableProjectId.ProjectId.get -> Microsoft.CodeAnalysis.ProjectId
-Microsoft.CodeAnalysis.SerializableProjectId.SerializableProjectId(Microsoft.CodeAnalysis.ProjectId projectId) -> void
-Microsoft.CodeAnalysis.SerializableProjectReference
-Microsoft.CodeAnalysis.SerializableProjectReference.ProjectReference.get -> Microsoft.CodeAnalysis.ProjectReference
-Microsoft.CodeAnalysis.SerializableProjectReference.SerializableProjectReference(Microsoft.CodeAnalysis.ProjectReference projectReference) -> void
-Microsoft.CodeAnalysis.SerializableVersionStamp
-Microsoft.CodeAnalysis.SerializableVersionStamp.SerializableVersionStamp(Microsoft.CodeAnalysis.VersionStamp versionStamp) -> void
-Microsoft.CodeAnalysis.SerializableVersionStamp.VersionStamp.get -> Microsoft.CodeAnalysis.VersionStamp
 override Microsoft.CodeAnalysis.FileTextLoader.LoadTextAndVersionAsync(Microsoft.CodeAnalysis.Workspace workspace, Microsoft.CodeAnalysis.DocumentId documentId, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task<Microsoft.CodeAnalysis.TextAndVersion>
 override Microsoft.CodeAnalysis.Host.Mef.MefV1HostServices.CreateWorkspaceServices(Microsoft.CodeAnalysis.Workspace workspace) -> Microsoft.CodeAnalysis.Host.HostWorkspaceServices
 override Microsoft.CodeAnalysis.MSBuild.MSBuildWorkspace.ApplyAnalyzerReferenceAdded(Microsoft.CodeAnalysis.ProjectId projectId, Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference analyzerReference) -> void

src/Workspaces/Core/Desktop/Workspace/Solution/SerializableDocumentId.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.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Microsoft.CodeAnalysis
-{
-    [Serializable]
-    public sealed class SerializableDocumentId
-    {
-        private readonly SerializableProjectId _projectId;
-        private readonly Guid _guid;
-        private readonly string _debugName;
-
-        public SerializableDocumentId(DocumentId documentId)
-        {
-            if (documentId == null)
-            {
-                throw new ArgumentNullException(nameof(documentId));
-            }
-
-            _projectId = new SerializableProjectId(documentId.ProjectId);
-            _guid = documentId.Id;
-            _debugName = documentId.DebugName;
-        }
-
-        public DocumentId DocumentId
-        {
-            get
-            {
-                return new DocumentId(_projectId.ProjectId, _guid, _debugName);
-            }
-        }
-    }
-}

src/Workspaces/Core/Desktop/Workspace/Solution/SerializableProjectId.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.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Microsoft.CodeAnalysis
-{
-    [Serializable]
-    public sealed class SerializableProjectId
-    {
-        private readonly Guid _guid;
-        private readonly string _debugName;
-
-        public SerializableProjectId(ProjectId projectId)
-        {
-            if (projectId == null)
-            {
-                throw new ArgumentNullException(nameof(projectId));
-            }
-
-            _guid = projectId.Id;
-            _debugName = projectId.DebugName;
-        }
-
-        public ProjectId ProjectId
-        {
-            get
-            {
-                return new ProjectId(_guid, _debugName);
-            }
-        }
-    }
-}

src/Workspaces/Core/Desktop/Workspace/Solution/SerializableProjectReference.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.Collections.Immutable;
-using System.Linq;
-using System.Runtime.Serialization;
-
-namespace Microsoft.CodeAnalysis
-{
-    [Serializable]
-    public sealed class SerializableProjectReference : ISerializable
-    {
-        private readonly ProjectReference _projectReference;
-
-        public SerializableProjectReference(ProjectReference projectReference)
-        {
-            if (projectReference == null)
-            {
-                throw new ArgumentNullException(nameof(projectReference));
-            }
-
-            _projectReference = projectReference;
-        }
-
-        private SerializableProjectReference(SerializationInfo info, StreamingContext context)
-        {
-            var projectId = ((SerializableProjectId)info.GetValue("projectId", typeof(SerializableProjectId))).ProjectId;
-            var aliases = ImmutableArray.Create((string[])info.GetValue("aliases", typeof(string[])));
-            var embedInteropTypes = info.GetBoolean("embedInteropTypes");
-
-            _projectReference = new ProjectReference(projectId, aliases, embedInteropTypes);
-        }
-
-        void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
-        {
-            info.AddValue("projectId", new SerializableProjectId(_projectReference.ProjectId));
-            info.AddValue("aliases", _projectReference.Aliases.IsEmpty ? null : _projectReference.Aliases.ToArray(), typeof(string[]));
-            info.AddValue("embedInteropTypes", _projectReference.EmbedInteropTypes);
-        }
-
-        public ProjectReference ProjectReference
-        {
-            get { return _projectReference; }
-        }
-    }
-}

src/Workspaces/Core/Desktop/Workspace/Solution/SerializableVersionStamp.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.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Roslyn.Utilities;
-
-namespace Microsoft.CodeAnalysis
-{
-    [Serializable]
-    public sealed class SerializableVersionStamp
-    {
-        private readonly byte[] _bytes;
-
-        public SerializableVersionStamp(VersionStamp versionStamp)
-        {
-            using (var memoryStream = new MemoryStream())
-            {
-                using (var objectWriter = new ObjectWriter(memoryStream))
-                {
-                    versionStamp.WriteTo(objectWriter);
-                }
-
-                _bytes = memoryStream.ToArray();
-            }
-        }
-
-        public VersionStamp VersionStamp
-        {
-            get
-            {
-                using (var stream = new MemoryStream(_bytes))
-                {
-                    using (var objectReader = new ObjectReader(stream))
-                    {
-                        return VersionStamp.ReadFrom(objectReader);
-                    }
-                }
-            }
-        }
-    }
-}

src/Workspaces/Core/Desktop/Workspaces.Desktop.csproj

@@ -122,10 +122,6 @@
     <Compile Include="Workspace\MSBuild\SolutionFile\ProjectBlock.cs" />
     <Compile Include="Workspace\MSBuild\SolutionFile\SectionBlock.cs" />
     <Compile Include="Workspace\MSBuild\SolutionFile\SolutionFile.cs" />
-    <Compile Include="Workspace\Solution\SerializableDocumentId.cs" />
-    <Compile Include="Workspace\Solution\SerializableProjectId.cs" />
-    <Compile Include="Workspace\Solution\SerializableProjectReference.cs" />
-    <Compile Include="Workspace\Solution\SerializableVersionStamp.cs" />
   </ItemGroup>
   <ItemGroup>
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.CSharp.Workspaces.Desktop" />

src/Workspaces/Core/Portable/PublicAPI.txt

@@ -152,6 +152,7 @@ Microsoft.CodeAnalysis.DocumentEventArgs
 Microsoft.CodeAnalysis.DocumentEventArgs.Document.get -> Microsoft.CodeAnalysis.Document
 Microsoft.CodeAnalysis.DocumentEventArgs.DocumentEventArgs(Microsoft.CodeAnalysis.Document document) -> void
 Microsoft.CodeAnalysis.DocumentId
+Microsoft.CodeAnalysis.DocumentId.DocumentId(Microsoft.CodeAnalysis.ProjectId projectId, System.Guid guid, string debugName = null) -> void
 Microsoft.CodeAnalysis.DocumentId.Equals(Microsoft.CodeAnalysis.DocumentId other) -> bool
 Microsoft.CodeAnalysis.DocumentId.Id.get -> System.Guid
 Microsoft.CodeAnalysis.DocumentId.ProjectId.get -> Microsoft.CodeAnalysis.ProjectId
@@ -574,6 +575,7 @@ Microsoft.CodeAnalysis.ProjectDiagnostic.ProjectId.get -> Microsoft.CodeAnalysis
 Microsoft.CodeAnalysis.ProjectId
 Microsoft.CodeAnalysis.ProjectId.Equals(Microsoft.CodeAnalysis.ProjectId other) -> bool
 Microsoft.CodeAnalysis.ProjectId.Id.get -> System.Guid
+Microsoft.CodeAnalysis.ProjectId.ProjectId(System.Guid guid, string debugName = null) -> void
 Microsoft.CodeAnalysis.ProjectInfo
 Microsoft.CodeAnalysis.ProjectInfo.AdditionalDocuments.get -> System.Collections.Generic.IReadOnlyList<Microsoft.CodeAnalysis.DocumentInfo>
 Microsoft.CodeAnalysis.ProjectInfo.AnalyzerReferences.get -> System.Collections.Generic.IReadOnlyList<Microsoft.CodeAnalysis.Diagnostics.AnalyzerReference>
@@ -1299,4 +1301,4 @@ virtual Microsoft.CodeAnalysis.Workspace.OnWorkspaceFailed(Microsoft.CodeAnalysi
 virtual Microsoft.CodeAnalysis.Workspace.OpenAdditionalDocument(Microsoft.CodeAnalysis.DocumentId documentId, bool activate = true) -> void
 virtual Microsoft.CodeAnalysis.Workspace.OpenDocument(Microsoft.CodeAnalysis.DocumentId documentId, bool activate = true) -> void
 virtual Microsoft.CodeAnalysis.Workspace.PartialSemanticsEnabled.get -> bool
-virtual Microsoft.CodeAnalysis.Workspace.TryApplyChanges(Microsoft.CodeAnalysis.Solution newSolution) -> bool
+virtual Microsoft.CodeAnalysis.Workspace.TryApplyChanges(Microsoft.CodeAnalysis.Solution newSolution) -> bool
\ No newline at end of file

src/Workspaces/Core/Portable/Workspace/Solution/DocumentId.cs

@@ -28,7 +28,7 @@ private DocumentId(ProjectId projectId, string debugName)
             _debugName = debugName;
         }
 
-        internal DocumentId(ProjectId projectId, Guid guid, string debugName)
+        public DocumentId(ProjectId projectId, Guid guid, string debugName = null)
         {
             this.ProjectId = projectId;
             this.Id = guid;

src/Workspaces/Core/Portable/Workspace/Solution/ProjectId.cs

@@ -28,7 +28,7 @@ private ProjectId(string debugName)
             _debugName = debugName;
         }
 
-        internal ProjectId(Guid guid, string debugName)
+        public ProjectId(Guid guid, string debugName = null)
         {
             this.Id = guid;
             _debugName = debugName;