Add NerdbankMessagePackFormatter

Directory.Packages.props

@@ -22,11 +22,12 @@
     <PackageVersion Include="Microsoft.VisualStudio.Threading.Analyzers" Version="$(VisualStudioThreadingVersion)" />
     <PackageVersion Include="Microsoft.VisualStudio.Threading" Version="$(VisualStudioThreadingVersion)" />
     <PackageVersion Include="Microsoft.VisualStudio.Validation" Version="17.8.8" />
+    <PackageVersion Include="Nerdbank.MessagePack" Version="0.3.71-beta" />
     <PackageVersion Include="Nerdbank.Streams" Version="2.11.74" />
     <PackageVersion Include="Newtonsoft.Json" Version="13.0.1" />
-    <PackageVersion Include="System.Collections.Immutable" Version="6.0.0" />
+    <PackageVersion Include="System.Collections.Immutable" Version="8.0.0" />
     <PackageVersion Include="System.Diagnostics.DiagnosticSource" Version="6.0.1" />
-    <PackageVersion Include="System.IO.Pipelines" Version="8.0.0" />
+    <PackageVersion Include="System.IO.Pipelines" Version="9.0.0" />
     <PackageVersion Include="System.IO.Pipes" Version="4.3.0" />
     <PackageVersion Include="System.Net.Http" Version="4.3.4" />
     <PackageVersion Include="System.Text.Json" Version="8.0.5" />

nuget.config

@@ -5,10 +5,25 @@
   </config>
   <packageSources>
     <clear />
+    <add key="PublicCI" value="https://pkgs.dev.azure.com/andrewarnott/OSS/_packaging/PublicCI/nuget/v3/index.json" />
+    <add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
     <add key="msft_consumption" value="https://pkgs.dev.azure.com/azure-public/vside/_packaging/msft_consumption/nuget/v3/index.json" />
   </packageSources>
   <disabledPackageSources>
     <!-- Defend against user or machine level disabling of sources that we list in this file. -->
     <clear />
   </disabledPackageSources>
+  <packageSourceMapping>
+    <!-- key value for <packageSource> should match key values from <packageSources> element -->
+    <packageSource key="msft_consumption">
+      <package pattern="*" />
+    </packageSource>
+    <packageSource key="nuget.org">
+      <package pattern="System.*" />
+      <package pattern="Microsoft.Bcl.*" />
+    </packageSource>
+    <packageSource key="PublicCI">
+      <package pattern="Nerdbank.MessagePack" />
+    </packageSource>
+  </packageSourceMapping>
 </configuration>

src/StreamJsonRpc/FormatterBase.cs

@@ -6,7 +6,9 @@
 using System.IO.Pipelines;
 using System.Reflection;
 using System.Runtime.Serialization;
+using Nerdbank.MessagePack;
 using Nerdbank.Streams;
+using PolyType;
 using StreamJsonRpc.Protocol;
 using StreamJsonRpc.Reflection;
 
@@ -320,7 +322,7 @@ public void Dispose()
     /// <summary>
     /// A base class for top-level property bags that should be declared in the derived formatter class.
     /// </summary>
-    protected abstract class TopLevelPropertyBagBase
+    protected internal abstract class TopLevelPropertyBagBase
     {
         private readonly bool isOutbound;
         private Dictionary<string, (Type, object?)>? outboundProperties;
@@ -436,6 +438,7 @@ protected abstract class JsonRpcErrorBase : JsonRpcError, IJsonRpcMessageBufferM
         /// </summary>
         [Newtonsoft.Json.JsonIgnore]
         [IgnoreDataMember]
+        [PropertyShape(Ignore = true)]
         public TopLevelPropertyBagBase? TopLevelPropertyBag { get; set; }
 
         void IJsonRpcMessageBufferManager.DeserializationComplete(JsonRpcMessage message)
@@ -480,6 +483,7 @@ protected abstract class JsonRpcResultBase : JsonRpcResult, IJsonRpcMessageBuffe
         /// </summary>
         [Newtonsoft.Json.JsonIgnore]
         [IgnoreDataMember]
+        [PropertyShape(Ignore = true)]
         public TopLevelPropertyBagBase? TopLevelPropertyBag { get; set; }
 
         void IJsonRpcMessageBufferManager.DeserializationComplete(JsonRpcMessage message)

src/StreamJsonRpc/JsonRpc.cs

@@ -1697,7 +1697,7 @@ protected virtual async ValueTask<JsonRpcMessage> DispatchRequestAsync(JsonRpcRe
     }
 
     /// <summary>
-    /// Sends the JSON-RPC message to <see cref="IJsonRpcMessageHandler"/> intance to be transmitted.
+    /// Sends the JSON-RPC message to <see cref="IJsonRpcMessageHandler"/> instance to be transmitted.
     /// </summary>
     /// <param name="message">The message to send.</param>
     /// <param name="cancellationToken">A token to cancel the send request.</param>

src/StreamJsonRpc/NerdbankMessagePackFormatter.Constants.cs

@@ -0,0 +1,60 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Diagnostics;
+using Nerdbank.MessagePack;
+using StreamJsonRpc.Protocol;
+using NBMP = Nerdbank.MessagePack;
+
+namespace StreamJsonRpc;
+
+/// <summary>
+/// Serializes JSON-RPC messages using MessagePack (a fast, compact binary format).
+/// </summary>
+public partial class NerdbankMessagePackFormatter
+{
+    /// <summary>
+    /// The constant "jsonrpc", in its various forms.
+    /// </summary>
+    private static readonly MessagePackString VersionPropertyName = new(Constants.jsonrpc);
+
+    /// <summary>
+    /// The constant "id", in its various forms.
+    /// </summary>
+    private static readonly MessagePackString IdPropertyName = new(Constants.id);
+
+    /// <summary>
+    /// The constant "method", in its various forms.
+    /// </summary>
+    private static readonly MessagePackString MethodPropertyName = new(Constants.Request.method);
+
+    /// <summary>
+    /// The constant "result", in its various forms.
+    /// </summary>
+    private static readonly MessagePackString ResultPropertyName = new(Constants.Result.result);
+
+    /// <summary>
+    /// The constant "error", in its various forms.
+    /// </summary>
+    private static readonly MessagePackString ErrorPropertyName = new(Constants.Error.error);
+
+    /// <summary>
+    /// The constant "params", in its various forms.
+    /// </summary>
+    private static readonly MessagePackString ParamsPropertyName = new(Constants.Request.@params);
+
+    /// <summary>
+    /// The constant "traceparent", in its various forms.
+    /// </summary>
+    private static readonly MessagePackString TraceParentPropertyName = new(Constants.Request.traceparent);
+
+    /// <summary>
+    /// The constant "tracestate", in its various forms.
+    /// </summary>
+    private static readonly MessagePackString TraceStatePropertyName = new(Constants.Request.tracestate);
+
+    /// <summary>
+    /// The constant "2.0", in its various forms.
+    /// </summary>
+    private static readonly MessagePackString Version2 = new("2.0");
+}

src/StreamJsonRpc/NerdbankMessagePackFormatter.FormatterProfile.cs

@@ -0,0 +1,31 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Nerdbank.MessagePack;
+using PolyType;
+
+namespace StreamJsonRpc;
+
+/// <summary>
+/// Serializes JSON-RPC messages using MessagePack (a fast, compact binary format).
+/// </summary>
+public sealed partial class NerdbankMessagePackFormatter
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="FormatterProfile"/> class.
+    /// </summary>
+    /// <param name="serializer">The MessagePack serializer to use.</param>
+    /// <param name="shapeProvider">The type shape provider to use.</param>
+    public class FormatterProfile(MessagePackSerializer serializer, ITypeShapeProvider shapeProvider)
+    {
+        /// <summary>
+        /// Gets the MessagePack serializer.
+        /// </summary>
+        internal MessagePackSerializer Serializer => serializer;
+
+        /// <summary>
+        /// Gets the type shape provider.
+        /// </summary>
+        internal ITypeShapeProvider ShapeProvider => shapeProvider;
+    }
+}

src/StreamJsonRpc/NerdbankMessagePackFormatter.FormatterProfileBuilder.cs

@@ -0,0 +1,218 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Collections.Immutable;
+using System.IO.Pipelines;
+using Nerdbank.MessagePack;
+using PolyType;
+using PolyType.Abstractions;
+using StreamJsonRpc.Reflection;
+
+namespace StreamJsonRpc;
+
+/// <summary>
+/// Serializes JSON-RPC messages using MessagePack (a fast, compact binary format).
+/// </summary>
+public sealed partial class NerdbankMessagePackFormatter
+{
+    /// <summary>
+    /// Provides methods to build a serialization profile for the <see cref="NerdbankMessagePackFormatter"/>.
+    /// </summary>
+    public class FormatterProfileBuilder
+    {
+        private readonly NerdbankMessagePackFormatter formatter;
+        private readonly FormatterProfile baseProfile;
+
+        private ImmutableArray<ITypeShapeProvider>.Builder? typeShapeProvidersBuilder = null;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="FormatterProfileBuilder"/> class.
+        /// </summary>
+        /// <param name="formatter">The formatter to use.</param>
+        /// <param name="baseProfile">The base profile to build upon.</param>
+        internal FormatterProfileBuilder(NerdbankMessagePackFormatter formatter, FormatterProfile baseProfile)
+        {
+            this.formatter = formatter;
+            this.baseProfile = baseProfile;
+        }
+
+        /// <summary>
+        /// Adds a type shape provider to the context.
+        /// </summary>
+        /// <param name="provider">The type shape provider to add.</param>
+        public void AddTypeShapeProvider(ITypeShapeProvider provider)
+        {
+            this.typeShapeProvidersBuilder ??= ImmutableArray.CreateBuilder<ITypeShapeProvider>();
+            this.typeShapeProvidersBuilder.Add(provider);
+        }
+
+        /// <summary>
+        /// Registers an async enumerable type with the context.
+        /// </summary>
+        /// <typeparam name="TEnumerable">The type of the async enumerable.</typeparam>
+        /// <typeparam name="TElement">The type of the elements in the async enumerable.</typeparam>
+        public void RegisterAsyncEnumerableType<TEnumerable, TElement>()
+            where TEnumerable : IAsyncEnumerable<TElement>
+        {
+            MessagePackConverter<TEnumerable> converter = this.formatter.asyncEnumerableConverterResolver.GetConverter<TEnumerable>();
+            this.baseProfile.Serializer.RegisterConverter(converter);
+        }
+
+        /// <summary>
+        /// Registers a converter with the context.
+        /// </summary>
+        /// <typeparam name="T">The type the converter handles.</typeparam>
+        /// <param name="converter">The converter to register.</param>
+        public void RegisterConverter<T>(MessagePackConverter<T> converter)
+        {
+            this.baseProfile.Serializer.RegisterConverter(converter);
+        }
+
+        /// <summary>
+        /// Registers known subtypes for a base type with the context.
+        /// </summary>
+        /// <typeparam name="TBase">The base type.</typeparam>
+        /// <param name="mapping">The mapping of known subtypes.</param>
+        public void RegisterKnownSubTypes<TBase>(KnownSubTypeMapping<TBase> mapping)
+        {
+            this.baseProfile.Serializer.RegisterKnownSubTypes(mapping);
+        }
+
+        /// <summary>
+        /// Registers a progress type with the context.
+        /// </summary>
+        /// <typeparam name="TProgress">The type of the progress.</typeparam>
+        /// <typeparam name="TReport">The type of the report.</typeparam>
+        public void RegisterProgressType<TProgress, TReport>()
+            where TProgress : IProgress<TReport>
+        {
+            MessagePackConverter<TProgress> converter = this.formatter.progressConverterResolver.GetConverter<TProgress>();
+            this.baseProfile.Serializer.RegisterConverter(converter);
+        }
+
+        /// <summary>
+        /// Registers a duplex pipe type with the context.
+        /// </summary>
+        /// <typeparam name="TPipe">The type of the duplex pipe.</typeparam>
+        public void RegisterDuplexPipeType<TPipe>()
+            where TPipe : IDuplexPipe
+        {
+            MessagePackConverter<TPipe> converter = this.formatter.pipeConverterResolver.GetConverter<TPipe>();
+            this.baseProfile.Serializer.RegisterConverter(converter);
+        }
+
+        /// <summary>
+        /// Registers a pipe reader type with the context.
+        /// </summary>
+        /// <typeparam name="TReader">The type of the pipe reader.</typeparam>
+        public void RegisterPipeReaderType<TReader>()
+            where TReader : PipeReader
+        {
+            MessagePackConverter<TReader> converter = this.formatter.pipeConverterResolver.GetConverter<TReader>();
+            this.baseProfile.Serializer.RegisterConverter(converter);
+        }
+
+        /// <summary>
+        /// Registers a pipe writer type with the context.
+        /// </summary>
+        /// <typeparam name="TWriter">The type of the pipe writer.</typeparam>
+        public void RegisterPipeWriterType<TWriter>()
+            where TWriter : PipeWriter
+        {
+            MessagePackConverter<TWriter> converter = this.formatter.pipeConverterResolver.GetConverter<TWriter>();
+            this.baseProfile.Serializer.RegisterConverter(converter);
+        }
+
+        /// <summary>
+        /// Registers a stream type with the context.
+        /// </summary>
+        /// <typeparam name="TStream">The type of the stream.</typeparam>
+        public void RegisterStreamType<TStream>()
+            where TStream : Stream
+        {
+            MessagePackConverter<TStream> converter = this.formatter.pipeConverterResolver.GetConverter<TStream>();
+            this.baseProfile.Serializer.RegisterConverter(converter);
+        }
+
+        /// <summary>
+        /// Registers an exception type with the context.
+        /// </summary>
+        /// <typeparam name="TException">The type of the exception.</typeparam>
+        public void RegisterExceptionType<TException>()
+            where TException : Exception
+        {
+            MessagePackConverter<TException> converter = this.formatter.exceptionResolver.GetConverter<TException>();
+            this.baseProfile.Serializer.RegisterConverter(converter);
+        }
+
+        /// <summary>
+        /// Registers an RPC marshalable type with the context.
+        /// </summary>
+        /// <typeparam name="T">The type to register.</typeparam>
+        public void RegisterRpcMarshalableType<T>()
+            where T : class
+        {
+            if (MessageFormatterRpcMarshaledContextTracker.TryGetMarshalOptionsForType(
+                typeof(T),
+                out JsonRpcProxyOptions? proxyOptions,
+                out JsonRpcTargetOptions? targetOptions,
+                out RpcMarshalableAttribute? attribute))
+            {
+                var converter = (RpcMarshalableConverter<T>)Activator.CreateInstance(
+                    typeof(RpcMarshalableConverter<>).MakeGenericType(typeof(T)),
+                    this.formatter,
+                    proxyOptions,
+                    targetOptions,
+                    attribute)!;
+
+                this.baseProfile.Serializer.RegisterConverter(converter);
+                return;
+            }
+
+            // TODO: Throw?
+            throw new NotSupportedException();
+        }
+
+        /// <summary>
+        /// Builds the formatter profile.
+        /// </summary>
+        /// <returns>The built formatter profile.</returns>
+        public FormatterProfile Build()
+        {
+            if (this.typeShapeProvidersBuilder is null || this.typeShapeProvidersBuilder.Count < 1)
+            {
+                return this.baseProfile;
+            }
+
+            ITypeShapeProvider provider = this.typeShapeProvidersBuilder.Count == 1
+                ? this.typeShapeProvidersBuilder[0]
+                : new CompositeTypeShapeProvider(this.typeShapeProvidersBuilder.ToImmutable());
+
+            return new FormatterProfile(this.baseProfile.Serializer, provider);
+        }
+    }
+
+    private class CompositeTypeShapeProvider : ITypeShapeProvider
+    {
+        private readonly ImmutableArray<ITypeShapeProvider> providers;
+
+        internal CompositeTypeShapeProvider(ImmutableArray<ITypeShapeProvider> providers)
+        {
+            this.providers = providers;
+        }
+
+        public ITypeShape? GetShape(Type type)
+        {
+            foreach (ITypeShapeProvider provider in this.providers)
+            {
+                ITypeShape? shape = provider.GetShape(type);
+                if (shape is not null)
+                {
+                    return shape;
+                }
+            }
+
+            return null;
+        }
+    }
+}