Move CSharpLanguageServer.FormatUtil -> CSharpLanguageServer.Roslyn.Document

Author: razzmatazz

src/CSharpLanguageServer/CSharpLanguageServer.fsproj

@@ -24,11 +24,11 @@
     <Compile Include="Logging.fs" />
     <Compile Include="Util.fs" />
     <Compile Include="Types.fs" />
-    <Compile Include="FormatUtil.fs" />
     <Compile Include="ProgressReporter.fs" />
     <Compile Include="Roslyn/Conversions.fs" />
     <Compile Include="Roslyn/WorkspaceServices.fs" />
     <Compile Include="Roslyn/Solution.fs" />
+    <Compile Include="Roslyn/Document.fs" />
     <Compile Include="Roslyn/Symbol.fs" />
     <Compile Include="DocumentationUtil.fs" />
     <Compile Include="Diagnostics.fs" />

src/CSharpLanguageServer/FormatUtil.fs

@@ -4,21 +4,27 @@ open Microsoft.CodeAnalysis.Formatting
 open Ionide.LanguageServerProtocol.Types
 open Ionide.LanguageServerProtocol.JsonRpc
 
-open CSharpLanguageServer
 open CSharpLanguageServer.State
+open CSharpLanguageServer.Roslyn.Document
 
 [<RequireQualifiedAccess>]
 module DocumentFormatting =
     let provider (clientCapabilities: ClientCapabilities) : U2<bool, DocumentFormattingOptions> option =
         Some(U2.C1 true)
 
     let handle (context: ServerRequestContext) (p: DocumentFormattingParams) : AsyncLspResult<TextEdit[] option> = async {
+        let lspFormattingOptions =
+            if context.State.Settings.ApplyFormattingOptions then
+                Some p.Options
+            else
+                None
+
         match context.GetUserDocument p.TextDocument.Uri with
         | None -> return None |> LspResult.success
         | Some doc ->
             let! ct = Async.CancellationToken
-            let! options = FormatUtil.getFormattingOptions context.State.Settings doc p.Options
+            let! options = getDocumentFormattingOptionSet doc lspFormattingOptions
             let! newDoc = Formatter.FormatAsync(doc, options, cancellationToken = ct) |> Async.AwaitTask
-            let! textEdits = FormatUtil.getChanges newDoc doc
+            let! textEdits = getDocumentDiffAsLspTextEdits newDoc doc
             return textEdits |> Some |> LspResult.success
     }

src/CSharpLanguageServer/Handlers/DocumentFormatting.fs

@@ -7,9 +7,9 @@ open Microsoft.CodeAnalysis.Formatting
 open Ionide.LanguageServerProtocol.Types
 open Ionide.LanguageServerProtocol.JsonRpc
 
-open CSharpLanguageServer
 open CSharpLanguageServer.State
 open CSharpLanguageServer.Roslyn.Conversions
+open CSharpLanguageServer.Roslyn.Document
 
 [<RequireQualifiedAccess>]
 module DocumentOnTypeFormatting =
@@ -42,10 +42,16 @@ module DocumentOnTypeFormatting =
             | _ -> None
 
     let handle (context: ServerRequestContext) (p: DocumentOnTypeFormattingParams) : AsyncLspResult<TextEdit[] option> = async {
+        let lspFormattingOptions =
+            if context.State.Settings.ApplyFormattingOptions then
+                Some p.Options
+            else
+                None
+
         match context.GetUserDocument p.TextDocument.Uri with
         | None -> return None |> LspResult.success
         | Some doc ->
-            let! options = FormatUtil.getFormattingOptions context.State.Settings doc p.Options
+            let! options = getDocumentFormattingOptionSet doc lspFormattingOptions
             let! ct = Async.CancellationToken
             let! sourceText = doc.GetTextAsync(ct) |> Async.AwaitTask
             let pos = Position.toRoslynPosition sourceText.Lines p.Position
@@ -69,7 +75,7 @@ module DocumentOnTypeFormatting =
                         )
                         |> Async.AwaitTask
 
-                    let! textEdits = FormatUtil.getChanges newDoc doc
+                    let! textEdits = getDocumentDiffAsLspTextEdits newDoc doc
                     return textEdits |> Some |> LspResult.success
             | _ -> return None |> LspResult.success
     }

src/CSharpLanguageServer/Handlers/DocumentOnTypeFormatting.fs

@@ -5,20 +5,27 @@ open Microsoft.CodeAnalysis.Text
 open Ionide.LanguageServerProtocol.Types
 open Ionide.LanguageServerProtocol.JsonRpc
 
-open CSharpLanguageServer
 open CSharpLanguageServer.State
 open CSharpLanguageServer.Roslyn.Conversions
+open CSharpLanguageServer.Roslyn.Document
 
 [<RequireQualifiedAccess>]
 module DocumentRangeFormatting =
-    let provider (_: ClientCapabilities) : U2<bool, DocumentRangeFormattingOptions> option = Some(U2.C1 true)
+    let provider (_cc: ClientCapabilities) : U2<bool, DocumentRangeFormattingOptions> option = Some(U2.C1 true)
 
     let handle (context: ServerRequestContext) (p: DocumentRangeFormattingParams) : AsyncLspResult<TextEdit[] option> = async {
+        let lspFormattingOptions =
+            if context.State.Settings.ApplyFormattingOptions then
+                Some p.Options
+            else
+                None
+
         match context.GetUserDocument p.TextDocument.Uri with
         | None -> return None |> LspResult.success
         | Some doc ->
             let! ct = Async.CancellationToken
-            let! options = FormatUtil.getFormattingOptions context.State.Settings doc p.Options
+
+            let! options = getDocumentFormattingOptionSet doc lspFormattingOptions
             let! sourceText = doc.GetTextAsync(ct) |> Async.AwaitTask
             let startPos = Position.toRoslynPosition sourceText.Lines p.Range.Start
             let endPos = Position.toRoslynPosition sourceText.Lines p.Range.End
@@ -29,6 +36,6 @@ module DocumentRangeFormatting =
                 Formatter.FormatAsync(doc, TextSpan.FromBounds(tokenStart, endPos), options, cancellationToken = ct)
                 |> Async.AwaitTask
 
-            let! textEdits = FormatUtil.getChanges newDoc doc
+            let! textEdits = getDocumentDiffAsLspTextEdits newDoc doc
             return textEdits |> Some |> LspResult.success
     }

src/CSharpLanguageServer/Handlers/DocumentRangeFormatting.fs

@@ -0,0 +1,105 @@
+module CSharpLanguageServer.Roslyn.Document
+
+open Microsoft.CodeAnalysis
+open Microsoft.CodeAnalysis.CSharp.Formatting
+open Microsoft.CodeAnalysis.Options
+open Microsoft.CodeAnalysis.Text
+open Microsoft.CodeAnalysis.Formatting
+open Ionide.LanguageServerProtocol.Types
+
+open CSharpLanguageServer.Types
+
+let private processChange (oldText: SourceText) (change: TextChange) : TextEdit =
+    let mapToTextEdit (linePosition: LinePositionSpan, newText: string) : TextEdit =
+        { NewText = newText
+          Range =
+            { Start =
+                { Line = uint32 linePosition.Start.Line
+                  Character = uint32 linePosition.Start.Character }
+              End =
+                { Line = uint32 linePosition.End.Line
+                  Character = uint32 linePosition.End.Character } } }
+
+    let defaultTextEdit (oldText: SourceText, change: TextChange) : TextEdit =
+        let linePosition = oldText.Lines.GetLinePositionSpan change.Span
+        mapToTextEdit (linePosition, change.NewText)
+
+    let padLeft (span: TextSpan) : TextSpan =
+        TextSpan.FromBounds(span.Start - 1, span.End)
+
+    let padRight (span: TextSpan) : TextSpan =
+        TextSpan.FromBounds(span.Start, span.End + 1)
+
+    let rec checkSpanLineEndings (newText: string, oldText: SourceText, span: TextSpan, prefix: string) : TextEdit =
+        if span.Start > 0 && newText[0].Equals '\n' && oldText[span.Start - 1].Equals '\r' then
+            checkSpanLineEndings (newText, oldText, padLeft span, "\r") |> ignore
+
+        if
+            span.End < oldText.Length - 1
+            && newText[newText.Length - 1].Equals '\r'
+            && oldText[span.End].Equals '\n'
+        then
+            let linePosition = oldText.Lines.GetLinePositionSpan(padRight span)
+            mapToTextEdit (linePosition, prefix + newText.ToString() + "\n")
+        else
+            let linePosition = oldText.Lines.GetLinePositionSpan span
+            mapToTextEdit (linePosition, newText.ToString())
+
+    let newText = change.NewText
+
+    if newText.Length > 0 then
+        checkSpanLineEndings (newText, oldText, change.Span, "")
+    else
+        defaultTextEdit (oldText, change)
+
+
+let private convert (oldText: SourceText) (changes: TextChange[]) : TextEdit[] =
+    //why doesnt it pick up that TextSpan implements IComparable<T>?
+    //one of life's many mysteries
+    let comparer (lhs: TextChange) (rhs: TextChange) : int = lhs.Span.CompareTo rhs.Span
+
+    changes
+    |> Seq.sortWith comparer
+    |> Seq.map (fun x -> processChange oldText x)
+    |> Seq.toArray
+
+
+let getDocumentDiffAsLspTextEdits (doc: Document) (oldDoc: Document) : Async<TextEdit[]> = async {
+    let! ct = Async.CancellationToken
+    let! changes = doc.GetTextChangesAsync(oldDoc, ct) |> Async.AwaitTask
+    let! oldText = oldDoc.GetTextAsync ct |> Async.AwaitTask
+    return convert oldText (changes |> Seq.toArray)
+}
+
+
+let getDocumentFormattingOptionSet
+    (doc: Document)
+    (lspFormattingOptions: FormattingOptions option)
+    : Async<OptionSet> =
+    async {
+        let! docOptions = doc.GetOptionsAsync() |> Async.AwaitTask
+
+        return
+            match lspFormattingOptions with
+            | None -> docOptions
+            | Some lspFormattingOptions ->
+                docOptions
+                |> _.WithChangedOption(
+                    FormattingOptions.IndentationSize,
+                    LanguageNames.CSharp,
+                    int lspFormattingOptions.TabSize
+                )
+                |> _.WithChangedOption(
+                    FormattingOptions.UseTabs,
+                    LanguageNames.CSharp,
+                    not lspFormattingOptions.InsertSpaces
+                )
+                |> match lspFormattingOptions.InsertFinalNewline with
+                   | Some insertFinalNewline ->
+                       _.WithChangedOption(CSharpFormattingOptions.NewLineForFinally, insertFinalNewline)
+                   | None -> id
+                |> match lspFormattingOptions.TrimFinalNewlines with
+                   | Some trimFinalNewlines ->
+                       _.WithChangedOption(CSharpFormattingOptions.NewLineForFinally, not trimFinalNewlines)
+                   | None -> id
+    }

src/CSharpLanguageServer/Roslyn/Document.fs

@@ -29,7 +29,7 @@ let testEditorConfigFormatting () =
     | Some tes ->
         let expectedClassContents =
             File
-                .ReadAllText(Path.Combine(client.ProjectDir, "Project", "ExpectedFormatting.cs.txt"))
+                .ReadAllText(Path.Combine(client.ProjectDir, "Project", "Class.cs.formatted.txt"))
                 .ReplaceLineEndings("\n")
 
         let actualClassContents =