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.98-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,26 @@
   </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.*" />
+      <package pattern="PolyType" />
+    </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.AsyncEnumerableConverters.cs

@@ -0,0 +1,154 @@
+// 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.Buffers;
+using System.Diagnostics.CodeAnalysis;
+using System.Text.Json.Nodes;
+using Nerdbank.MessagePack;
+using Nerdbank.Streams;
+using PolyType.Abstractions;
+using StreamJsonRpc.Reflection;
+
+namespace StreamJsonRpc;
+
+/// <summary>
+/// Serializes JSON-RPC messages using MessagePack (a fast, compact binary format).
+/// </summary>
+public partial class NerdbankMessagePackFormatter
+{
+    private static class AsyncEnumerableConverters
+    {
+        /// <summary>
+        /// Converts an enumeration token to an <see cref="IAsyncEnumerable{T}"/>
+        /// or an <see cref="IAsyncEnumerable{T}"/> into an enumeration token.
+        /// </summary>
+#pragma warning disable CA1812
+        internal class PreciseTypeConverter<T> : MessagePackConverter<IAsyncEnumerable<T>>
+#pragma warning restore CA1812
+        {
+            /// <summary>
+            /// The constant "token", in its various forms.
+            /// </summary>
+            private static readonly MessagePackString TokenPropertyName = new(MessageFormatterEnumerableTracker.TokenPropertyName);
+
+            /// <summary>
+            /// The constant "values", in its various forms.
+            /// </summary>
+            private static readonly MessagePackString ValuesPropertyName = new(MessageFormatterEnumerableTracker.ValuesPropertyName);
+
+            public override IAsyncEnumerable<T>? Read(ref MessagePackReader reader, SerializationContext context)
+            {
+                if (reader.TryReadNil())
+                {
+                    return default;
+                }
+
+                NerdbankMessagePackFormatter mainFormatter = context.GetFormatter();
+
+                context.DepthStep();
+
+                RawMessagePack? token = default;
+                IReadOnlyList<T>? initialElements = null;
+                int propertyCount = reader.ReadMapHeader();
+                for (int i = 0; i < propertyCount; i++)
+                {
+                    if (TokenPropertyName.TryRead(ref reader))
+                    {
+                        // The value needs to outlive the reader, so we clone it.
+                        token = new RawMessagePack(reader.ReadRaw(context)).ToOwned();
+                    }
+                    else if (ValuesPropertyName.TryRead(ref reader))
+                    {
+                        initialElements = context.GetConverter<IReadOnlyList<T>>(context.TypeShapeProvider).Read(ref reader, context);
+                    }
+                    else
+                    {
+                        reader.Skip(context);
+                    }
+                }
+
+                return mainFormatter.EnumerableTracker.CreateEnumerableProxy(token.HasValue ? token.Value : null, initialElements);
+            }
+
+            [SuppressMessage("Usage", "NBMsgPack031:Converters should read or write exactly one msgpack structure", Justification = "Writer is passed to helper method")]
+            public override void Write(ref MessagePackWriter writer, in IAsyncEnumerable<T>? value, SerializationContext context)
+            {
+                context.DepthStep();
+
+                NerdbankMessagePackFormatter mainFormatter = context.GetFormatter();
+                Serialize_Shared(mainFormatter, ref writer, value, context);
+            }
+
+            public override JsonObject? GetJsonSchema(JsonSchemaContext context, ITypeShape typeShape)
+            {
+                return CreateUndocumentedSchema(typeof(PreciseTypeConverter<T>));
+            }
+
+            internal static void Serialize_Shared(NerdbankMessagePackFormatter mainFormatter, ref MessagePackWriter writer, IAsyncEnumerable<T>? value, SerializationContext context)
+            {
+                if (value is null)
+                {
+                    writer.WriteNil();
+                }
+                else
+                {
+                    (IReadOnlyList<T> elements, bool finished) = value.TearOffPrefetchedElements();
+                    long token = mainFormatter.EnumerableTracker.GetToken(value);
+
+                    int propertyCount = 0;
+                    if (elements.Count > 0)
+                    {
+                        propertyCount++;
+                    }
+
+                    if (!finished)
+                    {
+                        propertyCount++;
+                    }
+
+                    writer.WriteMapHeader(propertyCount);
+
+                    if (!finished)
+                    {
+                        writer.Write(TokenPropertyName);
+                        writer.Write(token);
+                    }
+
+                    if (elements.Count > 0)
+                    {
+                        writer.Write(ValuesPropertyName);
+                        context.GetConverter<IReadOnlyList<T>>(context.TypeShapeProvider).Write(ref writer, elements, context);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Converts an instance of <see cref="IAsyncEnumerable{T}"/> to an enumeration token.
+        /// </summary>
+#pragma warning disable CA1812
+        internal class GeneratorConverter<TClass, TElement> : MessagePackConverter<TClass>
+            where TClass : IAsyncEnumerable<TElement>
+#pragma warning restore CA1812
+        {
+            public override TClass Read(ref MessagePackReader reader, SerializationContext context)
+            {
+                throw new NotSupportedException();
+            }
+
+            [SuppressMessage("Usage", "NBMsgPack031:Converters should read or write exactly one msgpack structure", Justification = "Writer is passed to helper method")]
+            public override void Write(ref MessagePackWriter writer, in TClass? value, SerializationContext context)
+            {
+                NerdbankMessagePackFormatter mainFormatter = context.GetFormatter();
+
+                context.DepthStep();
+                PreciseTypeConverter<TElement>.Serialize_Shared(mainFormatter, ref writer, value, context);
+            }
+
+            public override JsonObject? GetJsonSchema(JsonSchemaContext context, ITypeShape typeShape)
+            {
+                return CreateUndocumentedSchema(typeof(GeneratorConverter<TClass, TElement>));
+            }
+        }
+    }
+}

src/StreamJsonRpc/NerdbankMessagePackFormatter.Constants.cs

@@ -0,0 +1,58 @@
+// 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 StreamJsonRpc.Protocol;
+
+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.EnumeratorResultsConverter.cs

@@ -0,0 +1,61 @@
+// 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.CodeAnalysis;
+using System.Text.Json.Nodes;
+using Nerdbank.MessagePack;
+using PolyType.Abstractions;
+using StreamJsonRpc.Reflection;
+
+namespace StreamJsonRpc;
+
+/// <summary>
+/// Serializes JSON-RPC messages using MessagePack (a fast, compact binary format).
+/// </summary>
+public partial class NerdbankMessagePackFormatter
+{
+    private class EnumeratorResultsConverter<T> : MessagePackConverter<MessageFormatterEnumerableTracker.EnumeratorResults<T>>
+    {
+        [SuppressMessage("Usage", "NBMsgPack031:Converters should read or write exactly one msgpack structure", Justification = "Reader is passed to user data context")]
+        public override MessageFormatterEnumerableTracker.EnumeratorResults<T>? Read(ref MessagePackReader reader, SerializationContext context)
+        {
+            if (reader.TryReadNil())
+            {
+                return default;
+            }
+
+            NerdbankMessagePackFormatter formatter = context.GetFormatter();
+            context.DepthStep();
+
+            Verify.Operation(reader.ReadArrayHeader() == 2, "Expected array of length 2.");
+            return new MessageFormatterEnumerableTracker.EnumeratorResults<T>()
+            {
+                Values = formatter.userDataProfile.Deserialize<IReadOnlyList<T>>(ref reader, context.CancellationToken),
+                Finished = formatter.userDataProfile.Deserialize<bool>(ref reader, context.CancellationToken),
+            };
+        }
+
+        [SuppressMessage("Usage", "NBMsgPack031:Converters should read or write exactly one msgpack structure", Justification = "Writer is passed to user data context")]
+        public override void Write(ref MessagePackWriter writer, in MessageFormatterEnumerableTracker.EnumeratorResults<T>? value, SerializationContext context)
+        {
+            if (value is null)
+            {
+                writer.WriteNil();
+            }
+            else
+            {
+                NerdbankMessagePackFormatter formatter = context.GetFormatter();
+                context.DepthStep();
+
+                writer.WriteArrayHeader(2);
+                formatter.userDataProfile.Serialize(ref writer, value.Values, context.CancellationToken);
+                formatter.userDataProfile.Serialize(ref writer, value.Finished, context.CancellationToken);
+            }
+        }
+
+        public override JsonObject? GetJsonSchema(JsonSchemaContext context, ITypeShape typeShape)
+        {
+            return CreateUndocumentedSchema(typeof(EnumeratorResultsConverter<T>));
+        }
+    }
+}