From 92777551e9e56641721f59d41aa192d8fd8b1ed7 Mon Sep 17 00:00:00 2001
From: tmat <tomas.matousek@microsoft.com>
Date: Thu, 24 Feb 2022 11:35:35 -0800
Subject: [PATCH 1/5] Implement textDocument/_vs_validateBreakableRange
 protocol

---
 eng/Versions.props                            |   2 +-
 .../Protocol/DefaultCapabilitiesProvider.cs   |   1 +
 .../ValidateBreakableRangeHandler.cs          |  57 ++++++++++
 .../ValidateBreakableRangeTests.cs            | 100 ++++++++++++++++++
 4 files changed, 159 insertions(+), 1 deletion(-)
 create mode 100644 src/Features/LanguageServer/Protocol/Handler/Breakpoints/ValidateBreakableRangeHandler.cs
 create mode 100644 src/Features/LanguageServer/ProtocolUnitTests/ValidateBreakableRange/ValidateBreakableRangeTests.cs

diff --git a/eng/Versions.props b/eng/Versions.props
index 935eaa1113fd8..8b8b2d3a2ebf7 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -29,7 +29,7 @@
     <VisualStudioEditorNewPackagesVersion>17.0.487</VisualStudioEditorNewPackagesVersion>
     <ILAsmPackageVersion>5.0.0-alpha1.19409.1</ILAsmPackageVersion>
     <ILDAsmPackageVersion>5.0.0-preview.1.20112.8</ILDAsmPackageVersion>
-    <MicrosoftVisualStudioLanguageServerProtocolPackagesVersion>17.1.11</MicrosoftVisualStudioLanguageServerProtocolPackagesVersion>
+    <MicrosoftVisualStudioLanguageServerProtocolPackagesVersion>17.2.3</MicrosoftVisualStudioLanguageServerProtocolPackagesVersion>
     <MicrosoftVisualStudioShellPackagesVersion>17.0.31723.112</MicrosoftVisualStudioShellPackagesVersion>
     <RefOnlyMicrosoftBuildPackagesVersion>16.5.0</RefOnlyMicrosoftBuildPackagesVersion>
     <!-- The version of Roslyn we build Source Generators against that are built in this
diff --git a/src/Features/LanguageServer/Protocol/DefaultCapabilitiesProvider.cs b/src/Features/LanguageServer/Protocol/DefaultCapabilitiesProvider.cs
index 5d453960a2dbc..1a49c0899535e 100644
--- a/src/Features/LanguageServer/Protocol/DefaultCapabilitiesProvider.cs
+++ b/src/Features/LanguageServer/Protocol/DefaultCapabilitiesProvider.cs
@@ -95,6 +95,7 @@ private static VSServerCapabilities GetVSServerCapabilities()
             vsServerCapabilities.OnAutoInsertProvider = new VSInternalDocumentOnAutoInsertOptions { TriggerCharacters = new[] { "'", "/", "\n" } };
             vsServerCapabilities.DocumentHighlightProvider = true;
             vsServerCapabilities.ProjectContextProvider = true;
+            vsServerCapabilities.BreakableRangeProvider = true;
 
             // Diagnostic requests are only supported from PullDiagnosticsInProcLanguageClient.
             vsServerCapabilities.SupportsDiagnosticRequests = false;
diff --git a/src/Features/LanguageServer/Protocol/Handler/Breakpoints/ValidateBreakableRangeHandler.cs b/src/Features/LanguageServer/Protocol/Handler/Breakpoints/ValidateBreakableRangeHandler.cs
new file mode 100644
index 0000000000000..ca651d5a212ca
--- /dev/null
+++ b/src/Features/LanguageServer/Protocol/Handler/Breakpoints/ValidateBreakableRangeHandler.cs
@@ -0,0 +1,57 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Composition;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Host.Mef;
+using LSP = Microsoft.VisualStudio.LanguageServer.Protocol;
+using Microsoft.CodeAnalysis.Debugging;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Microsoft.CodeAnalysis.LanguageServer.Handler
+{
+    [ExportRoslynLanguagesLspRequestHandlerProvider, Shared]
+    [ProvidesMethod(LSP.VSInternalMethods.TextDocumentValidateBreakableRangeName)]
+    internal sealed class ValidateBreakableRangeHandler : AbstractStatelessRequestHandler<LSP.VSInternalValidateBreakableRangeParams, LSP.Range?>
+    {
+        [ImportingConstructor]
+        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+        public ValidateBreakableRangeHandler()
+        {
+        }
+
+        public override string Method => LSP.VSInternalMethods.TextDocumentValidateBreakableRangeName;
+        public override bool MutatesSolutionState => false;
+        public override bool RequiresLSPSolution => true;
+
+        public override LSP.TextDocumentIdentifier? GetTextDocumentIdentifier(LSP.VSInternalValidateBreakableRangeParams request)
+            => request.TextDocument;
+
+        public override async Task<LSP.Range?> HandleRequestAsync(LSP.VSInternalValidateBreakableRangeParams request, RequestContext context, CancellationToken cancellationToken)
+        {
+            var document = context.Document;
+            if (document == null)
+            {
+                return null;
+            }
+
+            var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
+            var span = ProtocolConversions.RangeToTextSpan(request.Range, text);
+            var breakpointService = document.Project.LanguageServices.GetRequiredService<IBreakpointResolutionService>();
+
+            var result = await breakpointService.ResolveBreakpointAsync(document, span, cancellationToken).ConfigureAwait(false);
+            if (result == null)
+            {
+                return null;
+            }
+
+            // zero-width range means line breakpoint:
+            var breakpointSpan = result.IsLineBreakpoint ? new TextSpan(span.Start, length: 0) : result.TextSpan;
+
+            return ProtocolConversions.TextSpanToRange(breakpointSpan, text);
+        }
+    }
+}
diff --git a/src/Features/LanguageServer/ProtocolUnitTests/ValidateBreakableRange/ValidateBreakableRangeTests.cs b/src/Features/LanguageServer/ProtocolUnitTests/ValidateBreakableRange/ValidateBreakableRangeTests.cs
new file mode 100644
index 0000000000000..67735af6f2669
--- /dev/null
+++ b/src/Features/LanguageServer/ProtocolUnitTests/ValidateBreakableRange/ValidateBreakableRangeTests.cs
@@ -0,0 +1,100 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable enable
+
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Roslyn.Test.Utilities;
+using Xunit;
+using LSP = Microsoft.VisualStudio.LanguageServer.Protocol;
+
+namespace Microsoft.CodeAnalysis.LanguageServer.UnitTests.ValidateBreakableRange
+{
+    public class ValidateBreakableRange : AbstractLanguageServerProtocolTests
+    {
+        [Fact]
+        public async Task SimpleStatement()
+        {
+            var markup =
+@"class A
+{
+    void M()
+    {
+        {|caret:|}M();
+    }
+}";
+            using var testLspServer = await CreateTestLspServerAsync(markup);
+
+            var caret = testLspServer.GetLocations("caret").Single();
+
+            var expected = new LSP.Range()
+            {
+                Start = caret.Range.Start,
+                End = new LSP.Position(caret.Range.Start.Line, caret.Range.Start.Character + "M();".Length),
+            };
+
+            var result = await RunAsync(testLspServer, caret);
+            AssertJsonEquals(expected, result);
+        }
+
+        [Fact]
+        public async Task LineBreakpoint()
+        {
+            var markup =
+@"class A
+{
+    void M()
+    {
+#if FALSE
+        {|caret:|}M();
+#endif
+    }
+}";
+            using var testLspServer = await CreateTestLspServerAsync(markup);
+
+            var caret = testLspServer.GetLocations("caret").Single();
+
+            var expected = new LSP.Range()
+            {
+                Start = caret.Range.Start,
+                End = caret.Range.Start,
+            };
+
+            var result = await RunAsync(testLspServer, caret);
+            AssertJsonEquals(expected, result);
+        }
+
+        [Fact]
+        public async Task NoBreakpointSpan()
+        {
+            var markup =
+@"class A
+{
+    void M()
+    {
+        {|caret:|}const int a = 1;
+    }
+}";
+            using var testLspServer = await CreateTestLspServerAsync(markup);
+
+            var caret = testLspServer.GetLocations("caret").Single();
+
+            var result = await RunAsync(testLspServer, caret);
+            Assert.Null(result);
+        }
+
+        private static async Task<LSP.Range?> RunAsync(TestLspServer testLspServer, LSP.Location caret)
+        {
+            return await testLspServer.ExecuteRequestAsync<LSP.VSInternalValidateBreakableRangeParams, LSP.Range?>(
+                LSP.VSInternalMethods.TextDocumentValidateBreakableRangeName,
+                new LSP.VSInternalValidateBreakableRangeParams()
+                {
+                    TextDocument = new LSP.TextDocumentIdentifier { Uri = caret.Uri },
+                    Range = caret.Range
+                }, new LSP.ClientCapabilities(), null, CancellationToken.None);
+        }
+    }
+}

From 442d939f820d9c19ddd6c2c1ca54525b706e439a Mon Sep 17 00:00:00 2001
From: tmat <tomas.matousek@microsoft.com>
Date: Thu, 24 Feb 2022 11:37:42 -0800
Subject: [PATCH 2/5] Throw

---
 .../Handler/Breakpoints/ValidateBreakableRangeHandler.cs    | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/Features/LanguageServer/Protocol/Handler/Breakpoints/ValidateBreakableRangeHandler.cs b/src/Features/LanguageServer/Protocol/Handler/Breakpoints/ValidateBreakableRangeHandler.cs
index ca651d5a212ca..11bd43b83f47b 100644
--- a/src/Features/LanguageServer/Protocol/Handler/Breakpoints/ValidateBreakableRangeHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/Breakpoints/ValidateBreakableRangeHandler.cs
@@ -10,6 +10,7 @@
 using LSP = Microsoft.VisualStudio.LanguageServer.Protocol;
 using Microsoft.CodeAnalysis.Debugging;
 using Microsoft.CodeAnalysis.Text;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.LanguageServer.Handler
 {
@@ -33,10 +34,7 @@ public ValidateBreakableRangeHandler()
         public override async Task<LSP.Range?> HandleRequestAsync(LSP.VSInternalValidateBreakableRangeParams request, RequestContext context, CancellationToken cancellationToken)
         {
             var document = context.Document;
-            if (document == null)
-            {
-                return null;
-            }
+            Contract.ThrowIfNull(document);
 
             var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
             var span = ProtocolConversions.RangeToTextSpan(request.Range, text);

From b71ec614cf383f43b4bc1830c3cd1e8ed0f984a1 Mon Sep 17 00:00:00 2001
From: tmat <tomas.matousek@microsoft.com>
Date: Thu, 24 Feb 2022 12:35:48 -0800
Subject: [PATCH 3/5] Feedback

---
 .../Handler/Breakpoints/ValidateBreakableRangeHandler.cs       | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/Features/LanguageServer/Protocol/Handler/Breakpoints/ValidateBreakableRangeHandler.cs b/src/Features/LanguageServer/Protocol/Handler/Breakpoints/ValidateBreakableRangeHandler.cs
index 11bd43b83f47b..3a5719dc9887e 100644
--- a/src/Features/LanguageServer/Protocol/Handler/Breakpoints/ValidateBreakableRangeHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/Breakpoints/ValidateBreakableRangeHandler.cs
@@ -15,7 +15,7 @@
 namespace Microsoft.CodeAnalysis.LanguageServer.Handler
 {
     [ExportRoslynLanguagesLspRequestHandlerProvider, Shared]
-    [ProvidesMethod(LSP.VSInternalMethods.TextDocumentValidateBreakableRangeName)]
+    [Method(LSP.VSInternalMethods.TextDocumentValidateBreakableRangeName)]
     internal sealed class ValidateBreakableRangeHandler : AbstractStatelessRequestHandler<LSP.VSInternalValidateBreakableRangeParams, LSP.Range?>
     {
         [ImportingConstructor]
@@ -24,7 +24,6 @@ public ValidateBreakableRangeHandler()
         {
         }
 
-        public override string Method => LSP.VSInternalMethods.TextDocumentValidateBreakableRangeName;
         public override bool MutatesSolutionState => false;
         public override bool RequiresLSPSolution => true;
 

From ca113f371f7060388a12c425f7dc4bdf1eadc3e5 Mon Sep 17 00:00:00 2001
From: tmat <tomas.matousek@microsoft.com>
Date: Thu, 24 Feb 2022 12:40:51 -0800
Subject: [PATCH 4/5] Fix

---
 .../Handler/Breakpoints/ValidateBreakableRangeHandler.cs       | 2 +-
 .../ValidateBreakableRange/ValidateBreakableRangeTests.cs      | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/Features/LanguageServer/Protocol/Handler/Breakpoints/ValidateBreakableRangeHandler.cs b/src/Features/LanguageServer/Protocol/Handler/Breakpoints/ValidateBreakableRangeHandler.cs
index 3a5719dc9887e..e64452fd281ac 100644
--- a/src/Features/LanguageServer/Protocol/Handler/Breakpoints/ValidateBreakableRangeHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/Breakpoints/ValidateBreakableRangeHandler.cs
@@ -14,7 +14,7 @@
 
 namespace Microsoft.CodeAnalysis.LanguageServer.Handler
 {
-    [ExportRoslynLanguagesLspRequestHandlerProvider, Shared]
+    [ExportRoslynLanguagesLspRequestHandlerProvider(typeof(ValidateBreakableRangeHandler)), Shared]
     [Method(LSP.VSInternalMethods.TextDocumentValidateBreakableRangeName)]
     internal sealed class ValidateBreakableRangeHandler : AbstractStatelessRequestHandler<LSP.VSInternalValidateBreakableRangeParams, LSP.Range?>
     {
diff --git a/src/Features/LanguageServer/ProtocolUnitTests/ValidateBreakableRange/ValidateBreakableRangeTests.cs b/src/Features/LanguageServer/ProtocolUnitTests/ValidateBreakableRange/ValidateBreakableRangeTests.cs
index 67735af6f2669..26cdadf438e63 100644
--- a/src/Features/LanguageServer/ProtocolUnitTests/ValidateBreakableRange/ValidateBreakableRangeTests.cs
+++ b/src/Features/LanguageServer/ProtocolUnitTests/ValidateBreakableRange/ValidateBreakableRangeTests.cs
@@ -94,7 +94,8 @@ void M()
                 {
                     TextDocument = new LSP.TextDocumentIdentifier { Uri = caret.Uri },
                     Range = caret.Range
-                }, new LSP.ClientCapabilities(), null, CancellationToken.None);
+                }, 
+                CancellationToken.None);
         }
     }
 }

From 0ed3e00c5d1abb9296c43793b4d23ade43f317d8 Mon Sep 17 00:00:00 2001
From: tmat <tomas.matousek@microsoft.com>
Date: Thu, 24 Feb 2022 15:34:20 -0800
Subject: [PATCH 5/5] Fix

---
 .../ValidateBreakableRange/ValidateBreakableRangeTests.cs       | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Features/LanguageServer/ProtocolUnitTests/ValidateBreakableRange/ValidateBreakableRangeTests.cs b/src/Features/LanguageServer/ProtocolUnitTests/ValidateBreakableRange/ValidateBreakableRangeTests.cs
index 26cdadf438e63..3c9f21ff26ea9 100644
--- a/src/Features/LanguageServer/ProtocolUnitTests/ValidateBreakableRange/ValidateBreakableRangeTests.cs
+++ b/src/Features/LanguageServer/ProtocolUnitTests/ValidateBreakableRange/ValidateBreakableRangeTests.cs
@@ -94,7 +94,7 @@ void M()
                 {
                     TextDocument = new LSP.TextDocumentIdentifier { Uri = caret.Uri },
                     Range = caret.Range
-                }, 
+                },
                 CancellationToken.None);
         }
     }