Enable LSP features in razor (.cshtml) files (I) (#274)

razzmatazz · web-flow · commit f51cd9dec8b1 · 2025-10-01T10:00:22.000+03:00
* tests/CSharpLanguageServer.Tests: re-enable testReferenceWorksToAspNetRazorPageReferencedValue

* Use Seq.choose

* Update how $/progress is logged in Tooling.fs

* Add razorCsharpDocumentFilter in src/CSharpLanguageServer/Types.fs

* src/CSharpLanguageServer/RoslynHelpers.fs: extract getProjectForPathOnSolution fn

* ServerRequestContext: update FindSymbol' to return Project and optional Document

'Document' may not be available when operating on a razor document

* src/CSharpLanguageServer/Conversions.fs: update fromRoslynDiagnostic to return a mapped line span + mapped uri

* src/CSharpLanguageServer/Conversions.fs: drop module Path
diff --git a/src/CSharpLanguageServer/Conversions.fs b/src/CSharpLanguageServer/Conversions.fs
@@ -33,14 +33,6 @@ module Uri =
           Name = Uri.UnescapeDataString(Uri(unescape uri).Segments |> Array.last) }
 
 
-module Path =
-    let toUri = Uri.fromPath
-
-    let fromUri = Uri.toPath
-
-    let toWorkspaceFolder = toUri >> Uri.toWorkspaceFolder
-
-
 module Position =
     let fromLinePosition (pos: LinePosition) : Position =
         { Line = uint32 pos.Line
@@ -74,7 +66,7 @@ module Range =
 module Location =
     let fromRoslynLocation (loc: Microsoft.CodeAnalysis.Location) : option<Location> =
         let toLspLocation (path: string) span : Location =
-            { Uri = path |> Path.toUri
+            { Uri = path |> Uri.fromPath
               Range = span |> Range.fromLinePositionSpan }
 
         match loc.Kind with
@@ -237,9 +229,7 @@ module SymbolInformation =
               Tags = None }
 
         symbol.Locations
-        |> Seq.map Location.fromRoslynLocation
-        |> Seq.filter _.IsSome
-        |> Seq.map _.Value
+        |> Seq.choose Location.fromRoslynLocation
         |> Seq.map toSymbolInformation
         |> Seq.toList
 
@@ -254,19 +244,24 @@ module DiagnosticSeverity =
 
 
 module Diagnostic =
-    let fromRoslynDiagnostic (diagnostic: Microsoft.CodeAnalysis.Diagnostic) : Diagnostic =
+    let fromRoslynDiagnostic (diagnostic: Microsoft.CodeAnalysis.Diagnostic) : Diagnostic * string =
         let diagnosticCodeUrl = diagnostic.Descriptor.HelpLinkUri |> Option.ofObj
 
-        { Range = diagnostic.Location.GetLineSpan().Span |> Range.fromLinePositionSpan
-          Severity = Some(diagnostic.Severity |> DiagnosticSeverity.fromRoslynDiagnosticSeverity)
-          Code = Some(U2.C2 diagnostic.Id)
-          CodeDescription = diagnosticCodeUrl |> Option.map (fun x -> { Href = x |> URI })
-          Source = Some "lsp"
-          Message = diagnostic.GetMessage()
-          RelatedInformation = None
-          // TODO: Convert diagnostic.Descriptor.CustomTags to Tags
-          Tags = None
-          Data = None }
+        let mappedLineSpan = diagnostic.Location.GetMappedLineSpan()
+
+        let diagnostic =
+            { Range = mappedLineSpan.Span |> Range.fromLinePositionSpan
+              Severity = Some(diagnostic.Severity |> DiagnosticSeverity.fromRoslynDiagnosticSeverity)
+              Code = Some(U2.C2 diagnostic.Id)
+              CodeDescription = diagnosticCodeUrl |> Option.map (fun x -> { Href = x |> URI })
+              Source = Some "lsp"
+              Message = diagnostic.GetMessage()
+              RelatedInformation = None
+              // TODO: Convert diagnostic.Descriptor.CustomTags to Tags
+              Tags = None
+              Data = None }
+
+        (diagnostic, mappedLineSpan.Path |> Uri.fromPath)
 
 
 module CompletionContext =
diff --git a/src/CSharpLanguageServer/Handlers/CallHierarchy.fs b/src/CSharpLanguageServer/Handlers/CallHierarchy.fs
@@ -47,9 +47,7 @@ module CallHierarchy =
                     |> Seq.toArray
 
                 info.CallingSymbol.Locations
-                |> Seq.map Location.fromRoslynLocation
-                |> Seq.filter _.IsSome
-                |> Seq.map _.Value
+                |> Seq.choose Location.fromRoslynLocation
                 |> Seq.map (fun loc ->
                     { From = CallHierarchyItem.fromSymbolAndLocation (info.CallingSymbol) loc
                       FromRanges = fromRanges })
diff --git a/src/CSharpLanguageServer/Handlers/CodeAction.fs b/src/CSharpLanguageServer/Handlers/CodeAction.fs
@@ -226,8 +226,8 @@ module CodeAction =
                 match newDocFilePathMaybe with
                 | Some newDocFilePath ->
                     let textEditDocument =
-                        { Uri = newDocFilePath |> Path.toUri
-                          Version = newDocFilePath |> Path.toUri |> tryGetDocVersionByUri }
+                        { Uri = Uri.fromPath newDocFilePath
+                          Version = newDocFilePath |> Uri.fromPath |> tryGetDocVersionByUri }
 
                     docTextEdits.Add(
                         { TextDocument = textEditDocument
@@ -255,8 +255,8 @@ module CodeAction =
                         |> Array.ofSeq
 
                     let textEditDocument =
-                        { Uri = originalDoc.FilePath |> Path.toUri
-                          Version = originalDoc.FilePath |> Path.toUri |> tryGetDocVersionByUri }
+                        { Uri = originalDoc.FilePath |> Uri.fromPath
+                          Version = originalDoc.FilePath |> Uri.fromPath |> tryGetDocVersionByUri }
 
                     docTextEdits.Add(
                         { TextDocument = textEditDocument
diff --git a/src/CSharpLanguageServer/Handlers/Definition.fs b/src/CSharpLanguageServer/Handlers/Definition.fs
@@ -7,7 +7,7 @@ open CSharpLanguageServer.State
 
 [<RequireQualifiedAccess>]
 module Definition =
-    let provider (clientCapabilities: ClientCapabilities) : U2<bool, DefinitionOptions> option = Some(U2.C1 true)
+    let provider (_cc: ClientCapabilities) : U2<bool, DefinitionOptions> option = Some(U2.C1 true)
 
     let handle
         (context: ServerRequestContext)
@@ -16,7 +16,7 @@ module Definition =
         async {
             match! context.FindSymbol' p.TextDocument.Uri p.Position with
             | None -> return None |> LspResult.success
-            | Some(symbol, doc) ->
-                let! locations = context.ResolveSymbolLocations symbol (Some doc.Project)
+            | Some(symbol, project, _) ->
+                let! locations = context.ResolveSymbolLocations symbol (Some project)
                 return locations |> Array.ofList |> Definition.C2 |> U2.C1 |> Some |> LspResult.success
         }
diff --git a/src/CSharpLanguageServer/Handlers/Diagnostic.fs b/src/CSharpLanguageServer/Handlers/Diagnostic.fs
@@ -47,6 +47,7 @@ module Diagnostic =
                     let diagnostics =
                         semanticModel.GetDiagnostics()
                         |> Seq.map Diagnostic.fromRoslynDiagnostic
+                        |> Seq.map fst
                         |> Array.ofSeq
 
                     return { emptyReport with Items = diagnostics } |> U2.C1 |> LspResult.success
@@ -70,7 +71,7 @@ module Diagnostic =
                         d.Location.SourceTree
                         |> Option.ofObj
                         |> Option.map _.FilePath
-                        |> Option.map Path.toUri
+                        |> Option.map Uri.fromPath
 
                     let diagnosticsByDocument =
                         compilation.GetDiagnostics(ct)
@@ -79,11 +80,17 @@ module Diagnostic =
                         |> Seq.map (fun (uri, ds) -> (uri.Value, ds))
 
                     for (uri, docDiagnostics) in diagnosticsByDocument do
+                        let items =
+                            docDiagnostics
+                            |> Seq.map Diagnostic.fromRoslynDiagnostic
+                            |> Seq.map fst
+                            |> Array.ofSeq
+
                         let fullDocumentReport: WorkspaceFullDocumentDiagnosticReport =
                             { Kind = "full"
                               ResultId = None
                               Uri = uri
-                              Items = docDiagnostics |> Seq.map Diagnostic.fromRoslynDiagnostic |> Array.ofSeq
+                              Items = items
                               Version = None }
 
                         let documentReport: WorkspaceDocumentDiagnosticReport = U2.C1 fullDocumentReport
diff --git a/src/CSharpLanguageServer/Handlers/DocumentHighlight.fs b/src/CSharpLanguageServer/Handlers/DocumentHighlight.fs
@@ -49,20 +49,19 @@ module DocumentHighlight =
 
                 return
                     locations
-                    |> Seq.map Location.fromRoslynLocation
-                    |> Seq.filter _.IsSome
-                    |> Seq.map _.Value
+                    |> Seq.choose Location.fromRoslynLocation
                     |> Seq.map (fun l ->
                         { Range = l.Range
                           Kind = Some DocumentHighlightKind.Read })
             }
 
             match! context.FindSymbol' p.TextDocument.Uri p.Position with
-            | None -> return None |> LspResult.success
-            | Some(symbol, doc) ->
+            | Some(symbol, _, Some doc) ->
                 if shouldHighlight symbol then
                     let! highlights = getHighlights symbol doc
                     return highlights |> Seq.toArray |> Some |> LspResult.success
                 else
                     return None |> LspResult.success
+
+            | _ -> return None |> LspResult.success
         }
diff --git a/src/CSharpLanguageServer/Handlers/Hover.fs b/src/CSharpLanguageServer/Handlers/Hover.fs
@@ -13,7 +13,7 @@ module Hover =
     let handle (context: ServerRequestContext) (p: HoverParams) : AsyncLspResult<Hover option> = async {
         match! context.FindSymbol' p.TextDocument.Uri p.Position with
         | None -> return None |> LspResult.success
-        | Some(symbol, _) ->
+        | Some(symbol, _, _) ->
             let content = DocumentationUtil.markdownDocForSymbolWithSignature symbol
 
             let hover =
diff --git a/src/CSharpLanguageServer/Handlers/InlayHint.fs b/src/CSharpLanguageServer/Handlers/InlayHint.fs
@@ -250,9 +250,7 @@ module InlayHint =
 
             let inlayHints =
                 root.DescendantNodes(textSpan, fun node -> node.Span.IntersectsWith(textSpan))
-                |> Seq.map (toInlayHint semanticModel sourceText.Lines)
-                |> Seq.filter Option.isSome
-                |> Seq.map Option.get
+                |> Seq.choose (toInlayHint semanticModel sourceText.Lines)
 
             return inlayHints |> Seq.toArray |> Some |> LspResult.success
     }
diff --git a/src/CSharpLanguageServer/Handlers/References.fs b/src/CSharpLanguageServer/Handlers/References.fs
@@ -18,9 +18,7 @@ module References =
 
             return
                 locations
-                |> Seq.map Location.fromRoslynLocation
-                |> Seq.filter _.IsSome
-                |> Seq.map _.Value
+                |> Seq.choose Location.fromRoslynLocation
                 |> Seq.distinct
                 |> Seq.toArray
                 |> Some
diff --git a/src/CSharpLanguageServer/Handlers/Rename.fs b/src/CSharpLanguageServer/Handlers/Rename.fs
@@ -52,7 +52,7 @@ module Rename =
                     |> Seq.map U2.C1
                     |> Array.ofSeq
 
-                let uri = originalDoc.FilePath |> Path.toUri
+                let uri = originalDoc.FilePath |> Uri.fromPath
 
                 let textEditDocument =
                     { Uri = uri
@@ -144,13 +144,13 @@ module Rename =
     let handle (context: ServerRequestContext) (p: RenameParams) : AsyncLspResult<WorkspaceEdit option> = async {
         match! context.FindSymbol' p.TextDocument.Uri p.Position with
         | None -> return None |> LspResult.success
-        | Some(symbol, doc) ->
+        | Some(symbol, project, _) ->
             let! ct = Async.CancellationToken
-            let originalSolution = doc.Project.Solution
+            let originalSolution = project.Solution
 
             let! updatedSolution =
                 Renamer.RenameSymbolAsync(
-                    doc.Project.Solution,
+                    project.Solution,
                     symbol,
                     SymbolRenameOptions(RenameOverloads = true, RenameFile = true),
                     p.NewName,
diff --git a/src/CSharpLanguageServer/Handlers/TypeDefinition.fs b/src/CSharpLanguageServer/Handlers/TypeDefinition.fs
@@ -19,7 +19,7 @@ module TypeDefinition =
         async {
             match! context.FindSymbol' p.TextDocument.Uri p.Position with
             | None -> return None |> LspResult.success
-            | Some(symbol, doc) ->
+            | Some(symbol, project, _) ->
                 let typeSymbol =
                     match symbol with
                     | :? ILocalSymbol as localSymbol -> [ localSymbol.Type ]
@@ -30,7 +30,7 @@ module TypeDefinition =
 
                 let! locations =
                     typeSymbol
-                    |> Seq.map (flip context.ResolveSymbolLocations (Some doc.Project))
+                    |> Seq.map (flip context.ResolveSymbolLocations (Some project))
                     |> Async.Parallel
                     |> Async.map (Seq.collect id >> Seq.toArray)
 
diff --git a/src/CSharpLanguageServer/RoslynHelpers.fs b/src/CSharpLanguageServer/RoslynHelpers.fs
@@ -750,32 +750,32 @@ let getFullReflectionName (containingType: INamedTypeSymbol) =
 
     String.Join(".", stack)
 
+let getProjectForPathOnSolution (solution: Solution) (filePath: string) : Project option =
+    let docDir = Path.GetDirectoryName filePath
+
+    let fileOnProjectDir (p: Project) =
+        let projectDir = Path.GetDirectoryName p.FilePath
+        let projectDirWithDirSepChar = projectDir + string Path.DirectorySeparatorChar
+
+        docDir = projectDir || docDir.StartsWith projectDirWithDirSepChar
+
+    solution.Projects |> Seq.filter fileOnProjectDir |> Seq.tryHead
+
 let tryAddDocument
     (logger: ILogger)
     (docFilePath: string)
     (text: string)
     (solution: Solution)
     : Async<Document option> =
     async {
-        let docDir = Path.GetDirectoryName docFilePath
-        //logMessage (sprintf "TextDocumentDidOpen: docFilename=%s docDir=%s" docFilename docDir)
-
-        let fileOnProjectDir (p: Project) =
-            let projectDir = Path.GetDirectoryName p.FilePath
-            let projectDirWithDirSepChar = projectDir + string Path.DirectorySeparatorChar
-
-            docDir = projectDir || docDir.StartsWith projectDirWithDirSepChar
-
-        let projectOnPath = solution.Projects |> Seq.filter fileOnProjectDir |> Seq.tryHead
+        let projectOnPath = getProjectForPathOnSolution solution docFilePath
 
         let! newDocumentMaybe =
             match projectOnPath with
             | Some proj ->
                 let projectBaseDir = Path.GetDirectoryName proj.FilePath
                 let docName = docFilePath.Substring(projectBaseDir.Length + 1)
 
-                //logMessage (sprintf "Adding \"%s\" (\"%s\") to project %s" docName docFilePath proj.FilePath)
-
                 let newDoc =
                     proj.AddDocument(
                         name = docName,
diff --git a/src/CSharpLanguageServer/State/ServerRequestContext.fs b/src/CSharpLanguageServer/State/ServerRequestContext.fs
@@ -3,16 +3,20 @@ namespace CSharpLanguageServer.State
 open Microsoft.CodeAnalysis
 open Microsoft.CodeAnalysis.FindSymbols
 open Ionide.LanguageServerProtocol.Types
+open Microsoft.Extensions.Logging
 
 open CSharpLanguageServer.State.ServerState
 open CSharpLanguageServer.Types
 open CSharpLanguageServer.RoslynHelpers
 open CSharpLanguageServer.Conversions
 open CSharpLanguageServer.Util
+open CSharpLanguageServer.Logging
 
 type ServerRequestContext(requestId: int, state: ServerState, emitServerEvent) =
     let mutable solutionMaybe = state.Solution
 
+    let logger = Logging.getLoggerByName "ServerRequestContext"
+
     member _.RequestId = requestId
     member _.State = state
     member _.ClientCapabilities = state.ClientCapabilities
@@ -130,19 +134,19 @@ type ServerRequestContext(requestId: int, state: ServerState, emitServerEvent) =
             return aggregatedLspLocations
         }
 
-    member this.FindSymbol' (uri: DocumentUri) (pos: Position) : Async<(ISymbol * Document) option> = async {
+    member this.FindSymbol' (uri: DocumentUri) (pos: Position) : Async<(ISymbol * Project * Document option) option> = async {
         match this.GetDocument uri with
         | None -> return None
         | Some doc ->
             let! ct = Async.CancellationToken
             let! sourceText = doc.GetTextAsync(ct) |> Async.AwaitTask
             let position = Position.toRoslynPosition sourceText.Lines pos
             let! symbol = SymbolFinder.FindSymbolAtPositionAsync(doc, position, ct) |> Async.AwaitTask
-            return symbol |> Option.ofObj |> Option.map (fun sym -> sym, doc)
+            return symbol |> Option.ofObj |> Option.map (fun sym -> sym, doc.Project, Some doc)
     }
 
     member this.FindSymbol (uri: DocumentUri) (pos: Position) : Async<ISymbol option> =
-        this.FindSymbol' uri pos |> Async.map (Option.map fst)
+        this.FindSymbol' uri pos |> Async.map (Option.map (fun (sym, _, _) -> sym))
 
     member private __._FindDerivedClasses (symbol: INamedTypeSymbol) (transitive: bool) : Async<INamedTypeSymbol seq> = async {
         match state.Solution with
@@ -267,7 +271,7 @@ type ServerRequestContext(requestId: int, state: ServerState, emitServerEvent) =
             let! ct = Async.CancellationToken
 
             let locationsFromReferencedSym (r: ReferencedSymbol) =
-                let locations = r.Locations |> Seq.map (fun rl -> rl.Location)
+                let locations = r.Locations |> Seq.map _.Location
 
                 match withDefinition with
                 | true -> locations |> Seq.append r.Definition.Locations
diff --git a/src/CSharpLanguageServer/State/ServerState.fs b/src/CSharpLanguageServer/State/ServerState.fs
@@ -502,6 +502,7 @@ let processServerEvent (logger: ILogger) state postSelf msg : Async<ServerState>
                             let diagnostics =
                                 semanticModel.GetDiagnostics()
                                 |> Seq.map Diagnostic.fromRoslynDiagnostic
+                                |> Seq.map fst
                                 |> Array.ofSeq
 
                             Ok(docUri, None, diagnostics)
diff --git a/src/CSharpLanguageServer/Types.fs b/src/CSharpLanguageServer/Types.fs
@@ -40,13 +40,17 @@ type ICSharpLspClient =
     // But ClientCapabilities is a complex type, write it again will be a huge work.
     abstract member Capabilities: ClientCapabilities option with get, set
 
-let defaultDocumentFilter: TextDocumentFilter =
-    { Language = None
+let csharpDocumentFilter: TextDocumentFilter =
+    { Language = Some "csharp"
       Scheme = Some "file"
       Pattern = Some "**/*.cs" }
 
-// Type abbreviations cannot have augmentations, extensions
-let defaultDocumentSelector: DocumentSelector = [| defaultDocumentFilter |> U2.C1 |]
+let razorCsharpDocumentFilter: TextDocumentFilter =
+    { Language = Some "razor-csharp"
+      Scheme = Some "file"
+      Pattern = Some "**/*.cshtml" }
+
+let defaultDocumentSelector: DocumentSelector = [| csharpDocumentFilter |> U2.C1 |]
 
 let emptyClientCapabilities: ClientCapabilities =
     { Workspace = None
diff --git a/tests/CSharpLanguageServer.Tests/InitializationTests.fs b/tests/CSharpLanguageServer.Tests/InitializationTests.fs
@@ -73,7 +73,7 @@ let testServerRegistersCapabilitiesWithTheClient () =
         { DocumentSelector =
             Some
                 [| U2.C1
-                       { Language = None
+                       { Language = Some "csharp"
                          Scheme = Some "file"
                          Pattern = Some "**/*.cs" } |]
           WorkDoneProgress = None
diff --git a/tests/CSharpLanguageServer.Tests/ReferenceTests.fs b/tests/CSharpLanguageServer.Tests/ReferenceTests.fs
diff --git a/tests/CSharpLanguageServer.Tests/Tooling.fs b/tests/CSharpLanguageServer.Tests/Tooling.fs

Original file line number	Diff line number	Diff line change
`@@ -250,9 +250,7 @@ module InlayHint =`
`250`	`250`
`251`	`251`	`let inlayHints =`
`252`	`252`	`root.DescendantNodes(textSpan, fun node -> node.Span.IntersectsWith(textSpan))`
`253`		`- \|> Seq.map (toInlayHint semanticModel sourceText.Lines)`
`254`		`- \|> Seq.filter Option.isSome`
`255`		`- \|> Seq.map Option.get`
	`253`	`+ \|> Seq.choose (toInlayHint semanticModel sourceText.Lines)`
`256`	`254`
`257`	`255`	`return inlayHints \|> Seq.toArray \|> Some \|> LspResult.success`
`258`	`256`	`}`