Add documentation comment creation to the FormatAfterKeystrokeService

IDocumentationCommentSnippetService was recently moved down to the Features layer, which means omnisharp can now take advantage of it and generate documentation comment snippets on typing. There are a couple of caveats:

1. LSP's "/onTypingFormat" endpoint has no support for setting the cursor location after format, which means that the cursor ends up after the inserted block. This is fine for newlines inside doc comments, but awkward for the initial expansion. However, unless we want to add special support with a custom endpoint, we can't get around this (the custom endpoint is how Roslyn does it).
2. The service itself is still internal, so I had to add a few new reflection points.

Server-side of dotnet/vscode-csharp#8. It also needs a vscode change, but it's a one-line change I'll submit later after we get this merged and I can write some integration tests.

src/OmniSharp.Roslyn.CSharp/DocumentationComments/DocumentationCommentSnippetService.cs

@@ -0,0 +1,110 @@
+#nullable enable
+
+using System;
+using System.Reflection;
+using System.Threading;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Completion;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Text;
+
+namespace OmniSharp.Roslyn.DocumentationComments
+{
+    /// <summary>
+    /// Proxy service for Microsoft.CodeAnalysis.DocumentationComments.IDocumentationCommentSnippetService.
+    /// Implementation was based on the service as of this commit: 2834b74995bb66a7cb19cb09069c17812819afdc
+    /// See: https://github.com/dotnet/roslyn/blob/2834b74995bb66a7cb19cb09069c17812819afdc/src/Features/Core/Portable/DocumentationComments/IDocumentationCommentSnippetService.cs
+    /// </summary>
+    public struct DocumentationCommentSnippetService
+    {
+        /// <summary>
+        /// IDocumentationCommentService HostLanguageServices.GetRequiredService<IDocumentationCommentService>()
+        /// </summary>
+        private static MethodInfo s_getRequiredService;
+        /// <summary>
+        /// DocumentationCommentSnippet IDocumentationCommentService.GetDocumentationCommentSnippetOnCharacterTyped(SyntaxTree, SourceText, int, DocumentOptionSet, CancellationToken)
+        /// </summary>
+        private static MethodInfo s_getDocumentationCommentSnippetOnCharacterTyped;
+        /// <summary>
+        /// DocumentationCommentSnippet IDocumentationCommentService.GetDocumentationCommentSnippetOnEnterTyped(SyntaxTree, SourceText, int, DocumentOptionSet, CancellationToken)
+        /// </summary>
+        private static MethodInfo s_getDocumentationCommentSnippetOnEnterTyped;
+        /// <summary>
+        /// TextSpan DocumentationCommentSnippet.SpanToReplace
+        /// </summary>
+        private static PropertyInfo s_spanToReplace;
+        /// <summary>
+        /// string DocumentationCommentSnippet.SnippetText
+        /// </summary>
+        private static PropertyInfo s_snippetText;
+
+        static DocumentationCommentSnippetService()
+        {
+            var iDocumentationCommentSnippetServiceType = typeof(CompletionItem).Assembly.GetType("Microsoft.CodeAnalysis.DocumentationComments.IDocumentationCommentSnippetService");
+            s_getDocumentationCommentSnippetOnCharacterTyped = iDocumentationCommentSnippetServiceType.GetMethod(nameof(GetDocumentationCommentSnippetOnCharacterTyped));
+            s_getDocumentationCommentSnippetOnEnterTyped = iDocumentationCommentSnippetServiceType.GetMethod(nameof(GetDocumentationCommentSnippetOnEnterTyped));
+
+            var documentationCommentSnippet = typeof(CompletionItem).Assembly.GetType("Microsoft.CodeAnalysis.DocumentationComments.DocumentationCommentSnippet");
+            s_spanToReplace = documentationCommentSnippet.GetProperty(nameof(DocumentationCommentSnippet.SpanToReplace));
+            s_snippetText = documentationCommentSnippet.GetProperty(nameof(DocumentationCommentSnippet.SnippetText));
+
+            s_getRequiredService = typeof(HostLanguageServices).GetMethod(nameof(HostLanguageServices.GetRequiredService)).MakeGenericMethod(iDocumentationCommentSnippetServiceType);
+        }
+
+        public static DocumentationCommentSnippetService GetDocumentationCommentSnippetService(Document document)
+        {
+            var service = s_getRequiredService.Invoke(document.Project.LanguageServices, Array.Empty<object>());
+            return new DocumentationCommentSnippetService(service);
+        }
+
+        private object _underlying;
+
+        private DocumentationCommentSnippetService(object underlying)
+        {
+            _underlying = underlying;
+        }
+
+        public DocumentationCommentSnippet? GetDocumentationCommentSnippetOnCharacterTyped(SyntaxTree syntaxTree, SourceText text, int position, DocumentOptionSet options, CancellationToken cancellationToken)
+        {
+            var originalSnippet = s_getDocumentationCommentSnippetOnCharacterTyped.Invoke(_underlying, new object[] { syntaxTree, text, position, options, cancellationToken });
+            return ConvertSnippet(originalSnippet);
+        }
+
+        public DocumentationCommentSnippet? GetDocumentationCommentSnippetOnEnterTyped(SyntaxTree syntaxTree, SourceText text, int position, DocumentOptionSet options, CancellationToken cancellationToken)
+        {
+            var originalSnippet = s_getDocumentationCommentSnippetOnEnterTyped.Invoke(_underlying, new object[] { syntaxTree, text, position, options, cancellationToken });
+            return ConvertSnippet(originalSnippet);
+        }
+
+        private static DocumentationCommentSnippet? ConvertSnippet(object? originalSnippet)
+        {
+            if (originalSnippet == null)
+            {
+                return null;
+            }
+            else
+            {
+                return new DocumentationCommentSnippet((TextSpan)s_spanToReplace.GetValue(originalSnippet), (string)s_snippetText.GetValue(originalSnippet));
+            }
+        }
+    }
+
+    public struct DocumentationCommentSnippet
+    {
+        public TextSpan SpanToReplace { get; }
+        public string SnippetText { get; }
+
+        public DocumentationCommentSnippet(TextSpan spanToReplace, string snippetText)
+        {
+            SpanToReplace = spanToReplace;
+            SnippetText = snippetText;
+        }
+    }
+
+    public static class WorkspaceExtensions
+    {
+        public static DocumentationCommentSnippetService GetDocumentationCommentSnippetService(this Document document)
+            => DocumentationCommentSnippetService.GetDocumentationCommentSnippetService(document);
+    }
+}

src/OmniSharp.Roslyn.CSharp/Workers/Formatting/FormattingWorker.cs

@@ -1,13 +1,19 @@
+#nullable enable
+
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.Extensions.Logging;
+using OmniSharp.Extensions;
 using OmniSharp.Models;
 using OmniSharp.Options;
+using OmniSharp.Roslyn.DocumentationComments;
 using OmniSharp.Roslyn.Utilities;
 
 namespace OmniSharp.Roslyn.CSharp.Workers.Formatting
@@ -16,13 +22,19 @@ public static class FormattingWorker
     {
         public static async Task<IEnumerable<LinePositionSpanTextChange>> GetFormattingChangesAfterKeystroke(Document document, int position, char character, OmniSharpOptions omnisharpOptions, ILoggerFactory loggerFactory)
         {
+            if (await GetDocumentationCommentChanges(document, position, character, omnisharpOptions) is LinePositionSpanTextChange change)
+            {
+                return new[] { change };
+            }
+
             if (character == '\n')
             {
                 // format previous line on new line
                 var text = await document.GetTextAsync();
                 var lines = text.Lines;
                 var targetLine = lines[lines.GetLineFromPosition(position).LineNumber - 1];
-                if (!string.IsNullOrWhiteSpace(targetLine.Text.ToString(targetLine.Span)))
+                Debug.Assert(targetLine.Text != null);
+                if (!string.IsNullOrWhiteSpace(targetLine.Text!.ToString(targetLine.Span)))
                 {
                     return await GetFormattingChanges(document, targetLine.Start, targetLine.End, omnisharpOptions, loggerFactory);
                 }
@@ -31,7 +43,8 @@ public static async Task<IEnumerable<LinePositionSpanTextChange>> GetFormattingC
             {
                 // format after ; and }
                 var root = await document.GetSyntaxRootAsync();
-                var node = FindFormatTarget(root, position);
+                Debug.Assert(root != null);
+                var node = FindFormatTarget(root!, position);
                 if (node != null)
                 {
                     return await GetFormattingChanges(document, node.FullSpan.Start, node.FullSpan.End, omnisharpOptions, loggerFactory);
@@ -41,7 +54,7 @@ public static async Task<IEnumerable<LinePositionSpanTextChange>> GetFormattingC
             return Enumerable.Empty<LinePositionSpanTextChange>();
         }
 
-        public static SyntaxNode FindFormatTarget(SyntaxNode root, int position)
+        public static SyntaxNode? FindFormatTarget(SyntaxNode root, int position)
         {
             // todo@jo - refine this
             var token = root.FindToken(position);
@@ -112,5 +125,40 @@ private static async Task<Document> FormatDocument(Document document, OmniSharpO
 
             return newDocument;
         }
+
+        private static async Task<LinePositionSpanTextChange?> GetDocumentationCommentChanges(Document document, int position, char character, OmniSharpOptions omnisharpOptions)
+        {
+            if (character != '\n' && character != '/')
+            {
+                return null;
+            }
+
+            var text = await document.GetTextAsync();
+            var syntaxTree = await document.GetSyntaxTreeAsync();
+
+            var optionSet = await document.GetOptionsAsync();
+
+            var documentationService = document.GetDocumentationCommentSnippetService();
+            var snippet = character == '\n' ?
+                documentationService.GetDocumentationCommentSnippetOnEnterTyped(syntaxTree!, text, position, optionSet, CancellationToken.None) :
+                documentationService.GetDocumentationCommentSnippetOnCharacterTyped(syntaxTree!, text, position, optionSet, CancellationToken.None);
+
+            if (snippet == null)
+            {
+                return null;
+            }
+            else
+            {
+                var range = text.GetRangeFromSpan(snippet.Value.SpanToReplace);
+                return new LinePositionSpanTextChange
+                {
+                    NewText = snippet.Value.SnippetText,
+                    StartLine = range.Start.Line,
+                    StartColumn = range.Start.Column,
+                    EndLine = range.End.Line,
+                    EndColumn = range.End.Column
+                };
+            }
+        }
     }
 }