Added progress support for LSP

src/StreamJsonRpc.Tests/JsonRpcClient20InteropTests.cs

@@ -5,6 +5,7 @@
 using System.Diagnostics;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.VisualStudio.Threading;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using StreamJsonRpc;
@@ -149,6 +150,147 @@ public async Task InvokeWithParameterPassedAsObjectAsync_NoParameter()
         Assert.Null(request["params"]);
     }
 
+    [Fact]
+    public async Task InvokeWithProgressParameterAsArray()
+    {
+        int sum = 0;
+        ProgressWithCompletion<int> progress = new ProgressWithCompletion<int>(report =>
+        {
+            sum += report;
+        });
+
+        int n = 3;
+        Task<int> invokeTask = this.clientRpc.InvokeAsync<int>("test", new object[] { n, progress });
+
+        JToken request = await this.ReceiveAsync();
+
+        long progressID = request["params"][1].Value<long>();
+
+        // Send responses as $/progress
+        int sum2 = 0;
+        for (int i = 0; i < n; i++)
+        {
+            string content = "{ \"jsonrpc\": \"2.0\", \"method\": \"$/progress\", \"params\": { \"token\": " + progressID + ", \"value\": " + i + ", } ,}";
+            JObject json = JObject.Parse(content);
+
+            this.Send(json);
+
+            sum2 += i;
+        }
+
+        System.Threading.Thread.Sleep(1000);
+        Assert.Equal(sum2, sum);
+
+        this.Send(new
+        {
+            jsonrpc = "2.0",
+            id = request["id"].Value<long>(),
+            result = sum,
+        });
+
+        int result = await invokeTask;
+        Assert.Equal(sum2, result);
+    }
+
+    [Fact]
+    public async Task InvokeWithProgressParameter()
+    {
+        int sum = 0;
+        ProgressWithCompletion<int> progress = new ProgressWithCompletion<int>(report =>
+        {
+            sum += report;
+        });
+
+        int n = 3;
+        Task<int> invokeTask = this.clientRpc.InvokeWithParameterObjectAsync<int>("test", new { Bar = n, Progress = progress });
+
+        JToken request = await this.ReceiveAsync();
+
+        long progressID = request["params"]["Progress"].Value<long>();
+
+        // Send responses as $/progress
+        int sum2 = 0;
+        for (int i = 0; i < n; i++)
+        {
+            string content = "{ \"jsonrpc\": \"2.0\", \"method\": \"$/progress\", \"params\": { \"token\": " + progressID + ", \"value\": " + i + ", } ,}";
+            JObject json = JObject.Parse(content);
+
+            this.Send(json);
+
+            sum2 += i;
+        }
+
+        System.Threading.Thread.Sleep(1000);
+        Assert.Equal(sum2, sum);
+
+        this.Send(new
+        {
+            jsonrpc = "2.0",
+            id = request["id"].Value<long>(),
+            result = sum,
+        });
+
+        int result = await invokeTask;
+        Assert.Equal(sum2, result);
+    }
+
+    [Fact]
+    public async Task InvokeWithProgressParameter_NoMemoryLeakConfirm()
+    {
+        WeakReference weakRef = await this.InvokeWithProgressParameter_NoMemoryLeakConfirm_Helper();
+        GC.Collect();
+        Assert.False(weakRef.IsAlive);
+    }
+
+    [Fact]
+    public async Task InvokeWithProgressParameterAsObject_CheckProgressObjectIsReplacedForId()
+    {
+        ProgressWithCompletion<int> progress = new ProgressWithCompletion<int>(report => { });
+
+        Task<int> invokeTask = this.clientRpc.InvokeWithParameterObjectAsync<int>("test", new { Bar = "value", Progress = progress });
+
+        JToken request = await this.ReceiveAsync();
+
+        Assert.Equal(JTokenType.Object, request["params"].Type);
+        Assert.Equal("value", request["params"]["Bar"].ToString());
+        Assert.Equal(JTokenType.Integer, request["params"]["Progress"].Type);
+    }
+
+    [Fact]
+    public async Task InvokeWithProgressParameterAsArray_CheckProgressObjectIsReplacedForId()
+    {
+        ProgressWithCompletion<int> progress = new ProgressWithCompletion<int>(report => { });
+
+        Task<int> invokeTask = this.clientRpc.InvokeAsync<int>("test", new object[] { "value", progress });
+
+        JToken request = await this.ReceiveAsync();
+
+        Assert.Equal(JTokenType.Array, request["params"].Type);
+        Assert.Equal("value", request["params"][0].ToString());
+        Assert.Equal(JTokenType.Integer, request["params"][1].Type);
+    }
+
+    [Fact]
+    public async Task InvokeWithProgressParameter_IncrementalId()
+    {
+        ProgressWithCompletion<int> progress = new ProgressWithCompletion<int>(report => { });
+
+        Task<int> invokeTask = this.clientRpc.InvokeAsync<int>("test", new object[] { "value", progress });
+        JToken request = await this.ReceiveAsync();
+
+        long firstId = request["params"][1].Value<long>();
+
+        invokeTask = this.clientRpc.InvokeAsync<int>("test", new object[] { "value", progress });
+        request = await this.ReceiveAsync();
+
+        Assert.Equal(firstId + 1, request["params"][1].Value<long>());
+
+        invokeTask = this.clientRpc.InvokeAsync<int>("test", new object[] { "value", progress });
+        request = await this.ReceiveAsync();
+
+        Assert.Equal(firstId + 2, request["params"][1].Value<long>());
+    }
+
     [Fact]
     public void NotifyWithParameterPassedAsObjectAsync_ThrowsExceptions()
     {
@@ -352,4 +494,29 @@ public async Task ServerReturnsOurRequestIdAsString()
         string result = await invokeTask;
         Assert.Equal("pass", result);
     }
+
+    private async Task<WeakReference> InvokeWithProgressParameter_NoMemoryLeakConfirm_Helper()
+    {
+        ProgressWithCompletion<int> progress = new ProgressWithCompletion<int>(report => { });
+
+        WeakReference weakRef = new WeakReference(progress);
+
+        Task<int> invokeTask = this.clientRpc.InvokeWithParameterObjectAsync<int>("test", new { Bar = 1, Progress = progress });
+
+        JToken request = await this.ReceiveAsync();
+
+        this.Send(new
+        {
+            jsonrpc = "2.0",
+            id = request["id"].Value<long>(),
+            result = 5,
+        });
+
+        // Clear progress variable locally
+        progress = null;
+
+        int result = await invokeTask;
+
+        return weakRef;
+    }
 }

src/StreamJsonRpc.Tests/JsonRpcTests.cs

@@ -803,6 +803,58 @@ public async Task InvokeWithParameterObject_DefaultParameters()
         Assert.Equal(12, sum);
     }
 
+    [Fact]
+    public async Task InvokeWithParameterObject_ProgressParameter()
+    {
+        int report = 0;
+        ProgressWithCompletion<int> progress = new ProgressWithCompletion<int>(n =>
+        {
+            report = n;
+        });
+
+        int result = await this.clientRpc.InvokeWithParameterObjectAsync<int>(nameof(Server.MethodWithProgressParameter), new { p = progress }, this.TimeoutToken);
+
+        Assert.Equal(1, report);
+        Assert.Equal(1, result);
+    }
+
+    [Fact]
+    public async Task InvokeWithParameterObject_ProgressParameterAndFields()
+    {
+        int report = 0;
+        ProgressWithCompletion<int> progress = new ProgressWithCompletion<int>(n =>
+        {
+            report += n;
+        });
+
+        int sum = await this.clientRpc.InvokeWithParameterObjectAsync<int>(nameof(Server.MethodWithProgressAndMoreParameters), new { p = progress, x = 2, y = 5 }, this.TimeoutToken);
+
+        Assert.Equal(7, report);
+        Assert.Equal(7, sum);
+    }
+
+    [Fact]
+    public async Task InvokeWithParameterObject_ProgressAndDefaultParameters()
+    {
+        int report = 0;
+        ProgressWithCompletion<int> progress = new ProgressWithCompletion<int>(n =>
+        {
+            report += n;
+        });
+
+        int sum = await this.clientRpc.InvokeWithParameterObjectAsync<int>(nameof(Server.MethodWithProgressAndMoreParameters), new { p = progress, x = 2 }, this.TimeoutToken);
+
+        Assert.Equal(12, report);
+        Assert.Equal(12, sum);
+    }
+
+    [Fact]
+    public async Task InvokeWithParameterObject_ClassIncludingProgressProperty()
+    {
+        int sum = await this.clientRpc.InvokeWithParameterObjectAsync<int>(nameof(Server.MethodWithProgressAndMoreParameters), new XAndYFieldsWithProgress { x = 2, y = 5, p = new Progress<int>() }, this.TimeoutToken);
+        Assert.Equal(7, sum);
+    }
+
     [Fact]
     public async Task CanInvokeServerMethodWithNoParameterPassedAsArray()
     {
@@ -1360,6 +1412,9 @@ private void ReinitializeRpcWithoutListening()
         this.serverRpc = new JsonRpc(this.serverMessageHandler, this.server);
         this.clientRpc = new JsonRpc(this.clientMessageHandler);
 
+        ((IJsonRpcInstanceContainer)this.clientMessageFormatter).Rpc = this.clientRpc;
+        ((IJsonRpcInstanceContainer)this.serverMessageFormatter).Rpc = this.serverRpc;
+
         this.serverRpc.TraceSource = new TraceSource("Server", SourceLevels.Verbose);
         this.clientRpc.TraceSource = new TraceSource("Client", SourceLevels.Verbose);
 
@@ -1430,6 +1485,33 @@ public static int MethodWithDefaultParameter(int x, int y = 10)
             return x + y;
         }
 
+        public static int MethodWithProgressParameter(IProgress<int> p)
+        {
+            p.Report(1);
+            return 1;
+        }
+
+        public static int MethodWithProgressAndMoreParameters(IProgress<int> p, int x, int y = 10)
+        {
+            int sum = x + y;
+            p.Report(x);
+            p.Report(y);
+            return sum;
+        }
+
+        public static int MethodWithProgressArrayParameter(params IProgress<int>[] progressArray)
+        {
+            int report = 0;
+
+            foreach (IProgress<int> progress in progressArray)
+            {
+                report++;
+                progress.Report(report);
+            }
+
+            return 0;
+        }
+
         public int? MethodReturnsNullableInt(int a) => a > 0 ? (int?)a : null;
 
         public int MethodAcceptsNullableArgs(int? a, int? b) => (a.HasValue ? 1 : 0) + (b.HasValue ? 1 : 0);
@@ -1742,6 +1824,20 @@ public class XAndYFields
 #pragma warning restore SA1307 // Accessible fields should begin with upper-case letter
     }
 
+    [DataContract]
+    public class XAndYFieldsWithProgress
+    {
+        // We disable SA1307 because we must use lowercase members as required to match the parameter names.
+#pragma warning disable SA1307 // Accessible fields should begin with upper-case letter
+        [DataMember]
+        public int x;
+        [DataMember]
+        public int y;
+        [DataMember]
+        public IProgress<int> p;
+#pragma warning restore SA1307 // Accessible fields should begin with upper-case letter
+    }
+
     internal class InternalClass
     {
     }

src/StreamJsonRpc.Tests/MessagePackFormatterTests.cs

@@ -39,6 +39,59 @@ public void JsonRpcRequest_ArgsArray()
         Assert.Equal(((CustomType)original.ArgumentsList[2]).Age, ((CustomType)actual.ArgumentsList[2]).Age);
     }
 
+    [Fact]
+    public void JsonRpcRequest_ProgressArg()
+    {
+        var original = new JsonRpcRequest
+        {
+            Id = 5,
+            Method = "test",
+            ArgumentsList = new object[] { new Progress<object>() },
+        };
+
+        var actual = this.Roundtrip(original);
+        Assert.Equal(original.Id, actual.Id);
+        Assert.Equal(original.Method, actual.Method);
+        Assert.Equal(typeof(long), actual.ArgumentsList[0].GetType());
+    }
+
+    [Fact]
+    public void JsonRpcRequest_MultipleProgressArgs()
+    {
+        var original = new JsonRpcRequest
+        {
+            Id = 5,
+            Method = "test",
+            ArgumentsList = new object[] { new Progress<object>(), new Progress<object>(), new Progress<object>() },
+        };
+
+        var actual = this.Roundtrip(original);
+        Assert.Equal(original.Id, actual.Id);
+        Assert.Equal(original.Method, actual.Method);
+        Assert.Equal(typeof(long), actual.ArgumentsList[0].GetType());
+        Assert.Equal(typeof(long), actual.ArgumentsList[1].GetType());
+        Assert.Equal(typeof(long), actual.ArgumentsList[2].GetType());
+    }
+
+    [Fact]
+    public void JsonRpcRequest_MultipleArgsIncludingProgress()
+    {
+        var original = new JsonRpcRequest
+        {
+            Id = 5,
+            Method = "test",
+            ArgumentsList = new object[] { 0, new Progress<object>(), "foo", new ProgressWithCompletion<object>(report => { }) },
+        };
+
+        var actual = this.Roundtrip(original);
+        Assert.Equal(original.Id, actual.Id);
+        Assert.Equal(original.Method, actual.Method);
+        Assert.Equal(original.ArgumentsList[0], actual.ArgumentsList[0]);
+        Assert.Equal(typeof(long), actual.ArgumentsList[1].GetType());
+        Assert.Equal(original.ArgumentsList[2], actual.ArgumentsList[2]);
+        Assert.Equal(typeof(long), actual.ArgumentsList[3].GetType());
+    }
+
     [Fact]
     public void JsonRpcResult()
     {

src/StreamJsonRpc/IJsonRpcInstanceContainer.cs

@@ -0,0 +1,20 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace StreamJsonRpc
+{
+    /// <summary>
+    /// Interface to contain an instance of <see cref="JsonRpc"/>.
+    /// </summary>
+    public interface IJsonRpcInstanceContainer
+    {
+        /// <summary>
+        /// Gets or sets the <see cref="JsonRpc"/> instance.
+        /// </summary>
+        JsonRpc Rpc
+        {
+            get;
+            set;
+        }
+    }
+}