add new compilation options to data sync to OOP. (#32726)

2 new options. NullableContextOptions and MetadataImportOptions

if compiler team do this (https://github.com/dotnet/roslyn/issues/12795), IDE side can simply use compiler's serialization rather than doing it in IDE side

src/Workspaces/CSharp/Portable/Execution/CSharpOptionsSerializationService.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.Generic;
-using System.Collections.Immutable;
 using System.Composition;
 using System.Linq;
 using System.Threading;
@@ -23,6 +21,7 @@ public override void WriteTo(CompilationOptions options, ObjectWriter writer, Ca
             var csharpOptions = (CSharpCompilationOptions)options;
             writer.WriteValue(csharpOptions.Usings.ToArray());
             writer.WriteBoolean(csharpOptions.AllowUnsafe);
+            writer.WriteByte((byte)csharpOptions.NullableContextOptions);
         }
 
         public override void WriteTo(ParseOptions options, ObjectWriter writer, CancellationToken cancellationToken)
@@ -81,16 +80,19 @@ public override CompilationOptions ReadCompilationOptionsFrom(ObjectReader reade
                 out var outputKind, out var reportSuppressedDiagnostics, out var moduleName, out var mainTypeName, out var scriptClassName,
                 out var optimizationLevel, out var checkOverflow, out var cryptoKeyContainer, out var cryptoKeyFile, out var cryptoPublicKey,
                 out var delaySign, out var platform, out var generalDiagnosticOption, out var warningLevel, out var specificDiagnosticOptions,
-                out var concurrentBuild, out var deterministic, out var publicSign, out var xmlReferenceResolver, out var sourceReferenceResolver,
-                out var metadataReferenceResolver, out var assemblyIdentityComparer, out var strongNameProvider, cancellationToken);
+                out var concurrentBuild, out var deterministic, out var publicSign, out var metadataImportOptions,
+                out var xmlReferenceResolver, out var sourceReferenceResolver, out var metadataReferenceResolver, out var assemblyIdentityComparer,
+                out var strongNameProvider, cancellationToken);
 
             var usings = reader.ReadArray<string>();
             var allowUnsafe = reader.ReadBoolean();
+            var nullableContextOptions = (NullableContextOptions)reader.ReadByte();
 
             return new CSharpCompilationOptions(
                 outputKind, reportSuppressedDiagnostics, moduleName, mainTypeName, scriptClassName, usings, optimizationLevel, checkOverflow, allowUnsafe,
                 cryptoKeyContainer, cryptoKeyFile, cryptoPublicKey, delaySign, platform, generalDiagnosticOption, warningLevel, specificDiagnosticOptions, concurrentBuild,
-                deterministic, xmlReferenceResolver, sourceReferenceResolver, metadataReferenceResolver, assemblyIdentityComparer, strongNameProvider, publicSign);
+                deterministic, xmlReferenceResolver, sourceReferenceResolver, metadataReferenceResolver, assemblyIdentityComparer, strongNameProvider, publicSign,
+                metadataImportOptions, nullableContextOptions);
         }
 
         public override ParseOptions ReadParseOptionsFrom(ObjectReader reader, CancellationToken cancellationToken)

src/Workspaces/Core/Portable/Execution/AbstractOptionsSerializationService.cs

@@ -65,6 +65,8 @@ protected void WriteCompilationOptionsTo(CompilationOptions options, ObjectWrite
             writer.WriteBoolean(options.Deterministic);
             writer.WriteBoolean(options.PublicSign);
 
+            writer.WriteByte((byte)options.MetadataImportOptions);
+
             // REVIEW: What should I do with these. we probably need to implement either out own one
             //         or somehow share these as service....
             //
@@ -95,6 +97,7 @@ protected void WriteCompilationOptionsTo(CompilationOptions options, ObjectWrite
             out bool concurrentBuild,
             out bool deterministic,
             out bool publicSign,
+            out MetadataImportOptions metadataImportOptions,
             out XmlReferenceResolver xmlReferenceResolver,
             out SourceReferenceResolver sourceReferenceResolver,
             out MetadataReferenceResolver metadataReferenceResolver,
@@ -152,6 +155,8 @@ protected void WriteCompilationOptionsTo(CompilationOptions options, ObjectWrite
             deterministic = reader.ReadBoolean();
             publicSign = reader.ReadBoolean();
 
+            metadataImportOptions = (MetadataImportOptions)reader.ReadByte();
+
             // REVIEW: What should I do with these. are these service required when compilation is built ourselves, not through
             //         compiler.
             xmlReferenceResolver = XmlFileResolver.Default;

src/Workspaces/CoreTest/Execution/SnapshotSerializationTests.cs

@@ -609,6 +609,43 @@ public void TestEncodingSerialization()
             }
         }
 
+        [Fact]
+        public void TestCompilationOptions_NullableAndImport()
+        {
+            var csharpOptions = CSharp.CSharpCompilation.Create("dummy").Options.WithNullableContextOptions(CSharp.NullableContextOptions.SafeOnly).WithMetadataImportOptions(MetadataImportOptions.All);
+            var vbOptions = VisualBasic.VisualBasicCompilation.Create("dummy").Options.WithMetadataImportOptions(MetadataImportOptions.Internal);
+
+            var hostServices = MefHostServices.Create(MefHostServices.DefaultAssemblies);
+
+            var workspace = new AdhocWorkspace(hostServices);
+            var serializer = workspace.Services.GetService<ISerializerService>();
+
+            VerifyOptions(csharpOptions);
+            VerifyOptions(vbOptions);
+
+            void VerifyOptions(CompilationOptions originalOptions)
+            {
+                using (var stream = SerializableBytes.CreateWritableStream())
+                {
+                    using (var objectWriter = new ObjectWriter(stream))
+                    {
+                        serializer.Serialize(originalOptions, objectWriter, CancellationToken.None);
+                    }
+
+                    stream.Position = 0;
+                    using (var objectReader = ObjectReader.TryGetReader(stream))
+                    {
+                        var recoveredOptions = serializer.Deserialize<CompilationOptions>(originalOptions.GetWellKnownSynchronizationKind(), objectReader, CancellationToken.None);
+
+                        var original = serializer.CreateChecksum(originalOptions, CancellationToken.None);
+                        var recovered = serializer.CreateChecksum(recoveredOptions, CancellationToken.None);
+
+                        Assert.Equal(original, recovered);
+                    }
+                }
+            }
+        }
+
         private async Task<string> GetXmlDocumentAsync(HostServices services)
         {
             using (var tempRoot = new TempRoot())

src/Workspaces/VisualBasic/Portable/Execution/VisualBasicOptionsSerializationService.vb

@@ -72,6 +72,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Execution
             Dim concurrentBuild As Boolean
             Dim deterministic As Boolean
             Dim publicSign As Boolean
+            Dim metadataImportOptions As MetadataImportOptions = Nothing
             Dim xmlReferenceResolver As XmlReferenceResolver = Nothing
             Dim sourceReferenceResolver As SourceReferenceResolver = Nothing
             Dim metadataReferenceResolver As MetadataReferenceResolver = Nothing
@@ -81,8 +82,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Execution
             ReadCompilationOptionsFrom(reader, outputKind, reportSuppressedDiagnostics, moduleName, mainTypeName, scriptClassName,
                 optimizationLevel, checkOverflow, cryptoKeyContainer, cryptoKeyFile, cryptoPublicKey, delaySign,
                 platform, generalDiagnosticOption, warningLevel, specificDiagnosticOptions, concurrentBuild, deterministic,
-                publicSign, xmlReferenceResolver, sourceReferenceResolver, metadataReferenceResolver, assemblyIdentityComparer, strongNameProvider,
-                cancellationToken)
+                publicSign, metadataImportOptions, xmlReferenceResolver, sourceReferenceResolver, metadataReferenceResolver,
+                assemblyIdentityComparer, strongNameProvider, cancellationToken)
 
             Dim globalImports = GlobalImport.Parse(reader.ReadArray(Of String)())
             Dim rootNamespace = reader.ReadString()
@@ -102,7 +103,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Execution
                                                      cryptoKeyContainer, cryptoKeyFile, cryptoPublicKey, delaySign,
                                                      platform, generalDiagnosticOption, specificDiagnosticOptions, concurrentBuild, deterministic,
                                                      xmlReferenceResolver, sourceReferenceResolver, metadataReferenceResolver, assemblyIdentityComparer, strongNameProvider,
-                                                     publicSign, reportSuppressedDiagnostics)
+                                                     publicSign, reportSuppressedDiagnostics, metadataImportOptions)
         End Function
 
         Public Overrides Function ReadParseOptionsFrom(reader As ObjectReader, cancellationToken As CancellationToken) As ParseOptions