Simplify serialization for Add-Using OOP.

src/Features/Core/Portable/AddImport/AddImportFixData.cs

@@ -131,29 +131,5 @@ public static AddImportFixData CreateForPackageSymbol(ImmutableArray<TextChange>
                 PackageVersionOpt = packageVersionOpt,
             };
         }
-
-        public SerializableAddImportFixData Dehydrate()
-        {
-            return new SerializableAddImportFixData
-            {
-                Kind = Kind,
-                TextChanges = TextChanges.ToArray(),
-                Title = Title,
-                Tags = Tags.NullToEmpty().ToArray(),
-                Priority = Priority,
-
-                ProjectReferenceToAdd = ProjectReferenceToAdd,
-
-                PortableExecutableReferenceProjectId = PortableExecutableReferenceProjectId,
-                PortableExecutableReferenceFilePathToAdd = PortableExecutableReferenceFilePathToAdd,
-
-                AssemblyReferenceAssemblyName = AssemblyReferenceAssemblyName,
-                AssemblyReferenceFullyQualifiedTypeName = AssemblyReferenceFullyQualifiedTypeName,
-
-                PackageSource = PackageSource,
-                PackageName = PackageName,
-                PackageVersionOpt = PackageVersionOpt
-            };
-        }
     }
 }
\ No newline at end of file

src/Features/Core/Portable/AddImport/Remote/AbstractAddImportFeatureService_Remote.cs

@@ -18,11 +18,11 @@ internal abstract partial class AbstractAddImportFeatureService<TSimpleNameSynta
             RemoteHostClient.Session session, Document document, TextSpan span, string diagnosticId,
             bool searchReferenceAssemblies, ImmutableArray<PackageSource> packageSources)
         {
-            var result = await session.InvokeAsync<SerializableAddImportFixData[]>(
+            var result = await session.InvokeAsync<ImmutableArray<AddImportFixData>>(
                 nameof(IRemoteAddImportFeatureService.GetFixesAsync),
-                new object[] { document.Id, span, diagnosticId, searchReferenceAssemblies, packageSources.ToArray() }).ConfigureAwait(false);
+                new object[] { document.Id, span, diagnosticId, searchReferenceAssemblies, packageSources }).ConfigureAwait(false);
 
-            return result.Select(d => d.Rehydrate()).ToImmutableArray();
+            return result;
         }
 
         /// <summary>
@@ -54,31 +54,31 @@ public Task UpdateContinuouslyAsync(string sourceName, string localSettingsDirec
                 throw new NotImplementedException();
             }
 
-            public async Task<SerializablePackageWithTypeResult[]> FindPackagesWithTypeAsync(
+            public async Task<ImmutableArray<PackageWithTypeResult>> FindPackagesWithTypeAsync(
                 string source, string name, int arity)
             {
                 var result = await _symbolSearchService.FindPackagesWithTypeAsync(
                     source, name, arity, _cancellationToken).ConfigureAwait(false);
 
-                return result.Select(SerializablePackageWithTypeResult.Dehydrate).ToArray();
+                return result;
             }
 
-            public async Task<SerializablePackageWithAssemblyResult[]> FindPackagesWithAssemblyAsync(
+            public async Task<ImmutableArray<PackageWithAssemblyResult>> FindPackagesWithAssemblyAsync(
                 string source, string name)
             {
                 var result = await _symbolSearchService.FindPackagesWithAssemblyAsync(
                     source, name, _cancellationToken).ConfigureAwait(false);
 
-                return result.Select(SerializablePackageWithAssemblyResult.Dehydrate).ToArray();
+                return result;
             }
 
-            public async Task<SerializableReferenceAssemblyWithTypeResult[]> FindReferenceAssembliesWithTypeAsync(
+            public async Task<ImmutableArray<ReferenceAssemblyWithTypeResult>> FindReferenceAssembliesWithTypeAsync(
                 string name, int arity)
             {
                 var result = await _symbolSearchService.FindReferenceAssembliesWithTypeAsync(
                     name, arity, _cancellationToken).ConfigureAwait(false);
 
-                return result.Select(SerializableReferenceAssemblyWithTypeResult.Dehydrate).ToArray();
+                return result;
             }
         }
     }

src/Features/Core/Portable/AddImport/Remote/IRemoteAddImportFeatureService.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.Threading;
+using System.Collections.Immutable;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Packaging;
 using Microsoft.CodeAnalysis.Text;
@@ -9,8 +9,8 @@ namespace Microsoft.CodeAnalysis.AddImport
 {
     internal interface IRemoteAddImportFeatureService
     {
-        Task<SerializableAddImportFixData[]> GetFixesAsync(
+        Task<ImmutableArray<AddImportFixData>> GetFixesAsync(
             DocumentId documentId, TextSpan span, string diagnosticId,
-            bool searchReferenceAssemblies, PackageSource[] packageSources);
+            bool searchReferenceAssemblies, ImmutableArray<PackageSource> packageSources);
     }
 }
\ No newline at end of file

src/Features/Core/Portable/AddImport/Remote/SerializableAddImportFixData.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 Microsoft.CodeAnalysis.CodeActions;
-using Microsoft.CodeAnalysis.Text;
-using Roslyn.Utilities;
-
-namespace Microsoft.CodeAnalysis.AddImport
-{
-    internal class SerializableAddImportFixData
-    {
-        public AddImportFixKind Kind;
-
-        /// <summary>
-        /// Text changes to make to the document.  Usually just the import to add.  May also
-        /// include a change to the name node the feature was invoked on to fix the casing of it.
-        /// May be empty for fixes that don't need to add an import and only do something like
-        /// add a project/metadata reference.
-        /// </summary>
-        public TextChange[] TextChanges;
-
-        /// <summary>
-        /// String to display in the lightbulb menu.
-        /// </summary>
-        public string Title;
-
-        /// <summary>
-        /// Tags that control what glyph is displayed in the lightbulb menu.
-        /// </summary>
-        public string[] Tags;
-
-        /// <summary>
-        /// The priority this item should have in the lightbulb list.
-        /// </summary>
-        public CodeActionPriority Priority;
-
-        #region When adding P2P refrences.
-
-        /// <summary>
-        /// The optional id for a <see cref="Project"/> we'd like to add a reference to.
-        /// </summary>
-        public ProjectId ProjectReferenceToAdd;
-
-        #endregion
-
-        #region When adding a metadata reference
-
-        /// <summary>
-        /// If we're adding <see cref="PortableExecutableReferenceFilePathToAdd"/> then this
-        /// is the id for the <see cref="Project"/> we can find that <see cref="PortableExecutableReference"/>
-        /// referenced from.
-        /// </summary>
-        public ProjectId PortableExecutableReferenceProjectId;
-
-        /// <summary>
-        /// If we want to add a <see cref="PortableExecutableReference"/> metadata reference, this 
-        /// is the <see cref="PortableExecutableReference.FilePath"/> for it.
-        /// </summary>
-        public string PortableExecutableReferenceFilePathToAdd;
-
-        #endregion
-
-        #region When adding an assembly reference
-
-        public string AssemblyReferenceAssemblyName;
-        public string AssemblyReferenceFullyQualifiedTypeName;
-
-        #endregion
-
-        #region When adding a package reference
-
-        public string PackageSource;
-        public string PackageName;
-        public string PackageVersionOpt;
-
-        #endregion
-
-        public AddImportFixData Rehydrate()
-        {
-            switch (Kind)
-            {
-                case AddImportFixKind.ProjectSymbol:
-                    return AddImportFixData.CreateForProjectSymbol(
-                        TextChanges.ToImmutableArray(), Title, Tags.ToImmutableArray(),
-                        Priority, ProjectReferenceToAdd);
-
-                case AddImportFixKind.MetadataSymbol:
-                    return AddImportFixData.CreateForMetadataSymbol(
-                        TextChanges.ToImmutableArray(), Title, Tags.ToImmutableArray(),
-                        Priority, PortableExecutableReferenceProjectId, PortableExecutableReferenceFilePathToAdd);
-
-                case AddImportFixKind.PackageSymbol:
-                    return AddImportFixData.CreateForPackageSymbol(
-                        TextChanges.ToImmutableArray(), PackageSource, PackageName, PackageVersionOpt);
-
-                case AddImportFixKind.ReferenceAssemblySymbol:
-                    return AddImportFixData.CreateForReferenceAssemblySymbol(
-                        TextChanges.ToImmutableArray(), Title, 
-                        AssemblyReferenceAssemblyName, AssemblyReferenceFullyQualifiedTypeName);
-            }
-
-            throw ExceptionUtilities.Unreachable;
-        }
-    }
-}
\ No newline at end of file

src/Features/Core/Portable/Features.csproj

@@ -109,7 +109,6 @@
     <Compile Include="AddImport\CodeActions\MetadataSymbolReferenceCodeAction.cs" />
     <Compile Include="AddImport\CodeActions\ProjectSymbolReferenceCodeAction.cs" />
     <Compile Include="AddImport\IAddImportFeatureService.cs" />
-    <Compile Include="AddImport\Remote\SerializableAddImportFixData.cs" />
     <Compile Include="AddImport\Remote\IRemoteAddImportFeatureService.cs" />
     <Compile Include="AddImport\SearchScopes\AllSymbolsProjectSearchScope.cs" />
     <Compile Include="AddImport\SearchScopes\MetadataSymbolsSearchScope.cs" />

src/Workspaces/Remote/ServiceHub/Services/CodeAnalysisService_AddImport.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.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.AddImport;
@@ -14,9 +13,9 @@ namespace Microsoft.CodeAnalysis.Remote
 {
     internal partial class CodeAnalysisService : IRemoteAddImportFeatureService
     {
-        public async Task<SerializableAddImportFixData[]> GetFixesAsync(
+        public async Task<ImmutableArray<AddImportFixData>> GetFixesAsync(
             DocumentId documentId, TextSpan span, string diagnosticId,
-            bool searchReferenceAssemblies, PackageSource[] packageSources)
+            bool searchReferenceAssemblies, ImmutableArray<PackageSource> packageSources)
         {
             using (UserOperationBooster.Boost())
             {
@@ -29,9 +28,9 @@ internal partial class CodeAnalysisService : IRemoteAddImportFeatureService
 
                 var result = await service.GetFixesAsync(
                     document, span, diagnosticId, symbolSearchService, searchReferenceAssemblies, 
-                    packageSources.ToImmutableArray(), CancellationToken).ConfigureAwait(false);
+                    packageSources, CancellationToken).ConfigureAwait(false);
 
-                return result.Select(d => d.Dehydrate()).ToArray();
+                return result;
             }
         }
 
@@ -57,28 +56,28 @@ public SymbolSearchService(CodeAnalysisService codeAnalysisService)
             public async Task<ImmutableArray<PackageWithTypeResult>> FindPackagesWithTypeAsync(
                 string source, string name, int arity, CancellationToken cancellationToken)
             {
-                var result = await codeAnalysisService.Rpc.InvokeAsync<SerializablePackageWithTypeResult[]>(
+                var result = await codeAnalysisService.Rpc.InvokeAsync<ImmutableArray<PackageWithTypeResult>>(
                     nameof(FindPackagesWithTypeAsync), source, name, arity).ConfigureAwait(false);
 
-                return result.Select(r => r.Rehydrate()).ToImmutableArray();
+                return result;
             }
 
             public async Task<ImmutableArray<PackageWithAssemblyResult>> FindPackagesWithAssemblyAsync(
                 string source, string assemblyName, CancellationToken cancellationToken)
             {
-                var result = await codeAnalysisService.Rpc.InvokeAsync<SerializablePackageWithAssemblyResult[]>(
+                var result = await codeAnalysisService.Rpc.InvokeAsync<ImmutableArray<PackageWithAssemblyResult>>(
                     nameof(FindPackagesWithAssemblyAsync), source, assemblyName).ConfigureAwait(false);
 
-                return result.Select(r => r.Rehydrate()).ToImmutableArray();
+                return result;
             }
 
             public async Task<ImmutableArray<ReferenceAssemblyWithTypeResult>> FindReferenceAssembliesWithTypeAsync(
                 string name, int arity, CancellationToken cancellationToken)
             {
-                var result = await codeAnalysisService.Rpc.InvokeAsync<SerializableReferenceAssemblyWithTypeResult[]>(
+                var result = await codeAnalysisService.Rpc.InvokeAsync<ImmutableArray<ReferenceAssemblyWithTypeResult>>(
                     nameof(FindReferenceAssembliesWithTypeAsync), name, arity).ConfigureAwait(false);
 
-                return result.Select(r => r.Rehydrate()).ToImmutableArray();
+                return result;
             }
         }
     }

src/Workspaces/Remote/ServiceHub/Shared/RoslynJsonConverter.RoslynOnly.cs

@@ -3,6 +3,8 @@
 using System;
 using System.Collections.Immutable;
 using System.Linq;
+using Microsoft.CodeAnalysis.AddImport;
+using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.DocumentHighlighting;
 using Microsoft.CodeAnalysis.Packaging;
 using Microsoft.CodeAnalysis.SymbolSearch;
@@ -27,6 +29,8 @@ internal partial class AggregateJsonConverter : JsonConverter
             Add(builder, new PackageWithTypeResultJsonConverter());
             Add(builder, new PackageWithAssemblyResultJsonConverter());
             Add(builder, new ReferenceAssemblyWithTypeResultJsonConverter());
+
+            Add(builder, new AddImportFixDataJsonConverter());
         }
 
         private class TodoCommentDescriptorJsonConverter : BaseJsonConverter<TodoCommentDescriptor>
@@ -286,5 +290,97 @@ protected override void WriteValue(JsonWriter writer, TaggedText source, JsonSer
                 writer.WriteEndObject();
             }
         }
+
+        private class AddImportFixDataJsonConverter : BaseJsonConverter<AddImportFixData>
+        {
+            protected override AddImportFixData ReadValue(JsonReader reader, JsonSerializer serializer)
+            {
+                Contract.ThrowIfFalse(reader.TokenType == JsonToken.StartObject);
+
+                var kind = (AddImportFixKind)ReadProperty<long>(reader);
+                var textChanges = ReadProperty<ImmutableArray<TextChange>>(serializer, reader);
+                var title = ReadProperty<string>(reader);
+                var tags = ReadProperty<ImmutableArray<string>>(serializer, reader);
+                var priority = (CodeActionPriority)ReadProperty<long>(reader);
+
+                var projectReferenceToAdd = ReadProperty<ProjectId>(serializer, reader);
+
+                var portableExecutableReferenceProjectId = ReadProperty<ProjectId>(serializer, reader);
+                var portableExecutableReferenceFilePathToAdd = ReadProperty<string>(reader);
+
+                var assemblyReferenceAssemblyName = ReadProperty<string>(reader);
+                var assemblyReferenceFullyQualifiedTypeName = ReadProperty<string>(reader);
+
+                var packageSource = ReadProperty<string>(reader);
+                var packageName = ReadProperty<string>(reader);
+                var packageVersionOpt = ReadProperty<string>(reader);
+
+                Contract.ThrowIfFalse(reader.Read());
+                Contract.ThrowIfFalse(reader.TokenType == JsonToken.EndObject);
+
+                switch (kind)
+                {
+                    case AddImportFixKind.ProjectSymbol:
+                        return AddImportFixData.CreateForProjectSymbol(textChanges, title, tags, priority, projectReferenceToAdd);
+
+                    case AddImportFixKind.MetadataSymbol:
+                        return AddImportFixData.CreateForMetadataSymbol(textChanges, title, tags, priority, portableExecutableReferenceProjectId, portableExecutableReferenceFilePathToAdd);
+
+                    case AddImportFixKind.PackageSymbol:
+                        return AddImportFixData.CreateForPackageSymbol(textChanges, packageSource, packageName, packageVersionOpt);
+
+                    case AddImportFixKind.ReferenceAssemblySymbol:
+                        return AddImportFixData.CreateForReferenceAssemblySymbol(textChanges, title, assemblyReferenceAssemblyName, assemblyReferenceFullyQualifiedTypeName);
+                }
+
+                throw ExceptionUtilities.Unreachable;
+            }
+
+            protected override void WriteValue(JsonWriter writer, AddImportFixData source, JsonSerializer serializer)
+            {
+                writer.WriteStartObject();
+
+                writer.WritePropertyName(nameof(AddImportFixData.Kind));
+                writer.WriteValue((int)source.Kind);
+
+                writer.WritePropertyName(nameof(AddImportFixData.TextChanges));
+                serializer.Serialize(writer, source.TextChanges);
+
+                writer.WritePropertyName(nameof(AddImportFixData.Title));
+                writer.WriteValue(source.Title);
+
+                writer.WritePropertyName(nameof(AddImportFixData.Tags));
+                serializer.Serialize(writer, source.Tags.NullToEmpty());
+
+                writer.WritePropertyName(nameof(AddImportFixData.Priority));
+                writer.WriteValue((int)source.Priority);
+
+                writer.WritePropertyName(nameof(AddImportFixData.ProjectReferenceToAdd));
+                serializer.Serialize(writer, source.ProjectReferenceToAdd);
+
+                writer.WritePropertyName(nameof(AddImportFixData.PortableExecutableReferenceProjectId));
+                serializer.Serialize(writer, source.PortableExecutableReferenceProjectId);
+
+                writer.WritePropertyName(nameof(AddImportFixData.PortableExecutableReferenceFilePathToAdd));
+                writer.WriteValue(source.PortableExecutableReferenceFilePathToAdd);
+
+                writer.WritePropertyName(nameof(AddImportFixData.AssemblyReferenceAssemblyName));
+                writer.WriteValue(source.AssemblyReferenceAssemblyName);
+
+                writer.WritePropertyName(nameof(AddImportFixData.AssemblyReferenceFullyQualifiedTypeName));
+                writer.WriteValue(source.AssemblyReferenceFullyQualifiedTypeName);
+
+                writer.WritePropertyName(nameof(AddImportFixData.PackageSource));
+                writer.WriteValue(source.PackageSource);
+
+                writer.WritePropertyName(nameof(AddImportFixData.PackageName));
+                writer.WriteValue(source.PackageName);
+
+                writer.WritePropertyName(nameof(AddImportFixData.PackageVersionOpt));
+                writer.WriteValue(source.PackageVersionOpt);
+
+                writer.WriteEndObject();
+            }
+        }
     }
 }
\ No newline at end of file