pax_global_header00006660000000000000000000000064150261730110014506gustar00rootroot0000000000000052 comment=de91e884069a4e5df1cd9fd4274ae91191ae81f7 csharp-language-server-0.18.0/000077500000000000000000000000001502617301100161415ustar00rootroot00000000000000csharp-language-server-0.18.0/.editorconfig000066400000000000000000000003401502617301100206130ustar00rootroot00000000000000root = true [*] indent_style = space max_line_length = 120 end_of_line = lf charset = utf-8 trim_trailing_whitespace = true insert_final_newline = true [*.fs] fsharp_newline_before_multiline_computation_expression = false csharp-language-server-0.18.0/.github/000077500000000000000000000000001502617301100175015ustar00rootroot00000000000000csharp-language-server-0.18.0/.github/workflows/000077500000000000000000000000001502617301100215365ustar00rootroot00000000000000csharp-language-server-0.18.0/.github/workflows/build.yaml000066400000000000000000000014271502617301100235250ustar00rootroot00000000000000name: Build on: workflow_dispatch: inputs: {} jobs: build: strategy: matrix: os: [ubuntu-24.04] dotnet: [9.0.x] runs-on: ${{ matrix.os }} steps: - name: Checkout uses: actions/checkout@v4 - name: Setup .NET uses: actions/setup-dotnet@v4 with: dotnet-version: ${{ matrix.dotnet }} - name: Restore tools run: dotnet tool restore - name: Run Build run: dotnet build - name: Run publish run: dotnet pack -c Release -o release working-directory: src/CSharpLanguageServer - name: Upload NuGet packages as artifacts uses: actions/upload-artifact@v4 with: name: packages path: src/CSharpLanguageServer/release/ csharp-language-server-0.18.0/.github/workflows/test.yaml000066400000000000000000000011231502617301100233760ustar00rootroot00000000000000name: Tests on: push: branches: [main] pull_request: jobs: build: strategy: matrix: os: [windows-latest, ubuntu-24.04] dotnet: [9.0.x] fail-fast: false runs-on: ${{ matrix.os }} steps: - name: Checkout uses: actions/checkout@v4 - name: Setup .NET uses: actions/setup-dotnet@v4 with: dotnet-version: ${{ matrix.dotnet }} - name: Restore tools run: dotnet tool restore - name: Run Build run: dotnet build - name: Run Tests run: dotnet test --no-build csharp-language-server-0.18.0/.gitignore000066400000000000000000000000501502617301100201240ustar00rootroot00000000000000bin obj .ionide/ .idea/ .config/ nupkg/ csharp-language-server-0.18.0/CHANGELOG.md000066400000000000000000000511201502617301100177510ustar00rootroot00000000000000# Changelog All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/). ## [0.18.0] - 2025-06-23 / Pabradė * Upgrade Roslyn to 4.14.0 * Use diagnostic url from Roslyn - By @CoolCoderSuper https://github.com/razzmatazz/csharp-language-server/pull/227 * Support loading slnx files - By @CoolCoderSuper https://github.com/razzmatazz/csharp-language-server/pull/226 * Fix how doc strings are rendered - https://github.com/razzmatazz/csharp-language-server/pull/228 * Implement (experimental) support for loading multi-tfm solutions - https://github.com/razzmatazz/csharp-language-server/pull/205 * Implement workspace diagnostics - https://github.com/razzmatazz/csharp-language-server/pull/235 ## [0.17.0] - 2025-04-30 / Krokšlys * Upgrade Roslyn to 4.13.0 - https://github.com/razzmatazz/csharp-language-server/pull/220 * csharp-ls will now use and require .NET 9 runtime/SDK - PR by @lapponiandevil in https://github.com/razzmatazz/csharp-language-server/pull/222 * Upgrade Ionide.LanguageServerProtocol to 0.7.0: - https://github.com/razzmatazz/csharp-language-server/pull/221 * Reduce startup notifications by using "window/logMessage" - By @nikolightsaber in https://github.com/razzmatazz/csharp-language-server/pull/217 * Make sure `.editorconfig` settings are respected, add `csharp.applyFormattingOptions` override (defaults to false): - By @DmitryHudrich in https://github.com/razzmatazz/csharp-language-server/pull/204 **Full Changelog**: https://github.com/razzmatazz/csharp-language-server/compare/0.16.0...0.17.0 ## [0.16.0] - 2024-12-24 / Nemunaitis * Upgrade Roslyn to 4.12.0 * Fix an issue where server breaks when inspecting class/properties involved in source-generated code: - By @granitrocky in https://github.com/razzmatazz/csharp-language-server/pull/189 * Make sure textDocument/findReferences respects Context.IncludeDeclaration - https://github.com/razzmatazz/csharp-language-server/pull/199 * Fix an issue where server would file on projects using code generators (like Asp.Net razor) on some of the endpoints: - https://github.com/razzmatazz/csharp-language-server/pull/190 **Full Changelog**: https://github.com/razzmatazz/csharp-language-server/compare/0.15.0...0.16.0 ## [0.15.0] - 2024-08-15 / Šventoji * Upgrade Roslyn to 4.10.0: - https://github.com/razzmatazz/csharp-language-server/pull/182 * Implement pull diagnostics for better performance; - https://github.com/razzmatazz/csharp-language-server/pull/174 **Full Changelog**: https://github.com/razzmatazz/csharp-language-server/compare/0.14.0...0.15.0 ## [0.14.0] - 2024-06-23 / Palanga * Speed up completion by not showing name suggestions or items from unimported namespaces - https://github.com/razzmatazz/csharp-language-server/pull/168 * Bump Ionide.LanguageServerProtocol to 0.6.0, fix some of the types used for dynamic registration * Reduce noise when loading >10 project files, include currently loading project in progress bar. - By @BrianCArnold in https://github.com/razzmatazz/csharp-language-server/pull/162 * Register TextDocumentSync lazily - By Adam Tao @tcx4c70 * Support completionItem/resolve method to speed up completion; - By Adam Tao @tcx4c70 * Do not rename symbol in strings or comments, restore file rename - As reported by @Myrslaver in https://github.com/razzmatazz/csharp-language-server/issues/157 * Stop collecting symbols in method body - By Adam Tao @tcx4c70 * Fix TypeHierarchy registration - By Adam Tao @tcx4c70 * Fix wrong references number - By Adam Tao @tcx4c70 * Add progress reporting when loading a solution/project - By Adam Tao @tcx4c70 * More refactoring and fixes from rework branch: - By Adam Tao @tcx4c70, from https://github.com/tcx4c70/csharp-language-server/commits/rework/ **Full Changelog**: https://github.com/razzmatazz/csharp-language-server/compare/0.13.0...0.14.0 ## [0.13.0] - 2024-05-08 / Baltoji Vokė * Bump Ionide.LanguageServerProtocol dependency to v0.5.0 * Fix performance issue in completion handler introduced in 0.12.0 - Reported by @DanielViberg in https://github.com/razzmatazz/csharp-language-server/issues/151, bisected by @DmitryHudrich * Fix "Extract interface.." code action - Reported by @JorgeHerreraU in https://github.com/razzmatazz/csharp-language-server/issues/152 * Bump MSBuild, Argu and ICSharpCode.Decompiler dependency versions **Full Changelog**: https://github.com/razzmatazz/csharp-language-server/compare/0.12.0...0.13.0 ## [0.12.0] - 2024-04-22 / Valkininkai * Update Roslyn 4.7.0->4.9.2 to support C# 12 - PR by @arussellk: https://github.com/razzmatazz/csharp-language-server/pull/141 * Register server capabilities with the client lazily to improve startup performance - PR by @tcx4c70: https://github.com/razzmatazz/csharp-language-server/pull/102 * Rework logging to be based on Serilog - PR by @tcx4c70: https://github.com/razzmatazz/csharp-language-server/pull/134 * More refactoring by @tcx4c70 - PR by @tcx4c70: https://github.com/razzmatazz/csharp-language-server/pull/102 * Change package management to CPM - PR by @tcx4c70: https://github.com/razzmatazz/csharp-language-server/pull/132 ### More about Valkininkai, Lithuania - [Valkininkai on WP](https://en.wikipedia.org/wiki/Valkininkai) - [Google Images on Valkininkai](https://www.google.com/search?tbm=isch&q=valkininkai+lithuania) ## [0.11.0] - 2024-01-21 / Jieznas * Update Ionide.LanguageServerProtocol dependency to v0.4.22 * refactoring by @tcx4c70 - PR by @tcx4c70 in https://github.com/razzmatazz/csharp-language-server/pull/102 * csharp-ls will now use and require .NET 8 runtime/SDK - PR by @BeauCranston in https://github.com/razzmatazz/csharp-language-server/pull/122 * Add support for textDocument/typeDefinition - PR by @rudiejd in https://github.com/razzmatazz/csharp-language-server/pull/123 ## [0.10.0] - 2023-11-04 / Seirijai * Upgrade dependencies: Roslyn, ICSharpCode.Decompiler, Microsoft.Build; * Fix for a crash in serverEventLoop - By @kstatz12 in https://github.com/razzmatazz/csharp-language-server/issues/113 * Possible fixes to https://github.com/razzmatazz/csharp-language-server/issues/62 and https://github.com/razzmatazz/csharp-language-server/issues/57 - By Adam Tao @tcx4c70 in https://github.com/razzmatazz/csharp-language-server/pull/112 * Fix issues with code actions and other functionality that was broken after upgrade to recent roslyn version. - Fixed by Adam Tao @tcx4c70 in https://github.com/razzmatazz/csharp-language-server/pull/111 ## [0.9.0] - 2023-08-12 / Rūdninkai * Make --solution cmd line param take effect even when the editor provides us with `csharp.` settings; - By @vytautassurvila in https://github.com/razzmatazz/csharp-language-server/pull/105 * Upgrade dependencies: Roslyn, ICSharpCode.Decompiler, Microsoft.Build; * Support formatting options - By @weirongxu in https://github.com/razzmatazz/csharp-language-server/pull/94 ### More about Rūdninkai, Lithuania - [Rūdninkai on WP](https://lt.wikipedia.org/wiki/R%C5%ABdninkai) - [Google Images on Rūdninkai](https://www.google.com/search?tbm=isch&q=rudninkai+lithuania) ## [0.8.0] - 2023-05-06 / Varėna * Add more symbols to documentSymbols & codeLens - By Adam Tao @tcx4c70 in https://github.com/razzmatazz/csharp-language-server/pull/87 * Support type and call hierarchy - By Adam Tao @tcx4c70 in https://github.com/razzmatazz/csharp-language-server/pull/74 * Semantic token types fix - By Adam Tao @tcx4c70 in https://github.com/razzmatazz/csharp-language-server/pull/84 * Fix crash if there is no newline at the end of the last line - By Adam Tao @tcx4c70 in https://github.com/razzmatazz/csharp-language-server/pull/83 ### More about Varėna, Lithuania - [Varėna on WP](https://en.wikipedia.org/wiki/Var%C4%97na) - [Google Images on Varėna](https://www.google.com/search?tbm=isch&q=varena+lithuania) ## [0.7.1] - 2023-04-08 / Igliauka * Avoid a crash when client does not signal textDocument/publishDiagnostics cap - Reported and fixed by @sharpSteff in https://github.com/razzmatazz/csharp-language-server/pull/77 ### More about Igliauka, Lithuania - [Google Images on Igliauka](https://www.google.com/search?tbm=isch&q=igliauka) ## [0.7.0] - 2023-03-25 / Simnas * Update Roslyn libs to 4.6.0-1.final, Microsoft.Build* to 17.5.0 * Finish initialization early and load solution/project in background - Previous behaviour was causing problems in eglot (emacs) where client has a timeout set for server initialization * Add support for server configuration via LSP: - `csharp.solution` - solution file to load * Semantic token improvements - By Adam Tao @tcx4c70 in https://github.com/razzmatazz/csharp-language-server/pull/70 * Inlay hint support - By Adam Tao @tcx4c70 in https://github.com/razzmatazz/csharp-language-server/pull/71 and https://github.com/razzmatazz/csharp-language-server/pull/73 * Remove timeout on handler for `codelens/resolve` -- that wasn't a good idea to begin with ### More about Simnas, Lithuania - [Simnas on WP](https://en.wikipedia.org/wiki/Simnas) - [Google Images on Simnas](https://www.google.com/search?tbm=isch&q=simnas) ## [0.6.1] - 2023-02-26 / Marcinkonys * Fixes for Windows where file:// URIs were not parsed/built properly from native filenames before; - Reported by @blasco and @gorsheninmv in https://github.com/razzmatazz/csharp-language-server/issues/57 * Upgrade Roslyn to 4.5.0-2.final (from 4.4.0); * Semantic token support - By Adam Tao @tcx4c70 in https://github.com/razzmatazz/csharp-language-server/pull/68 * Fix an issue where some of initial LSP requests deadlock. ### More about Marcinkonys, Lithuania - [Google Images on Marcinkonys](https://www.google.com/search?tbm=isch&q=marcinkonys) - [Čepkeliai Marsh](https://en.wikipedia.org/wiki/%C4%8Cepkeliai_Marsh) ## [0.6.0] - 2022-12-30 / Alytus * Improve scheduling of background diagnostics processing; * Support for the .NET SDK 7.0; - Note that there was an issue with .NET SDK 7 previews breaking SDK, you may need to do some cleanup, see: - https://github.com/dotnet/sdk/issues/28947 * csharp-ls will now require .NET 7 SDK - Thanks to @Decodetalkers in https://github.com/razzmatazz/csharp-language-server/pull/56 * Fixes for the `textDocument/prepareRename` request; * Upgrade Microsoft.Build + Roslyn libs. ### More about Alytus, Lithuania - [Google Images on Alytus](https://www.google.com/search?tbm=isch&q=alytus+lithuania) - [Alytus on WP](https://en.wikipedia.org/wiki/Alytus) ## [0.5.7] - 2022-10-09 / Marijampolė * Add support for `textDocument/prepareRename` request; * Upgrade Microsoft.Build + Roslyn libs; * Update `textDocument/documentSymbol` handler: - emit hierarchical symbol tree, where client supports it; - emit `DocumentSymbol[]` instead of `SymbolInformation[]`, the former of which has more info. ### More about Marijampolė, Lithuania - [Google Images on Marijampolė](https://www.google.com/search?tbm=isch&q=marijampole+lithuania) - [Marijampolė on WP](https://en.wikipedia.org/wiki/Marijampol%C4%97) ## [0.5.6] - 2022-09-05 / Birštonas * Fix an issue where we would fail to generate code action list if one of code action providers would raise an exception; -- log the message to the log instead and continue with the next provider to be more resilent; * Upgrade Microsoft.Build libs; * Inject required roslyn WorkspaceServices so more refactorings work now: - pull member; - move static members to another class; - generate overrides; - others; * Fix an issue where a new file was added to wrong project. ### More about Birštonas, Lithuania - [Google Images on Birštonas](https://www.google.com/search?tbm=isch&q=birstonas+lithuania) - [Birštonas on WP](https://en.wikipedia.org/wiki/Bir%C5%A1tonas) ## [0.5.5] - 2022-08-23 / Prienai * Fix intermittent server crashes after upgrading to latest Ionide.LanguageServerProtocol: - https://github.com/razzmatazz/csharp-language-server/issues/44 ### More about Prienai, Lithuania - [Google Images on Prienai](https://www.google.com/search?tbm=isch&q=prienai+lithuania) - [Prienai on WP](https://en.wikipedia.org/wiki/Prienai) ## [0.5.4] - 2022-08-20 / Šilavotas * Upgrade roslyn libs to 4.4.0-1.final; * Properly format + "localize" symbol names in `textDocument/documentSymbol` response; - Reported by @joefbsjr in https://github.com/razzmatazz/csharp-language-server/issues/42 * Properly format ITypeSymbol (structs/enums/classes) when displaying type info on `workspace/symbol` and other LSP requests; - Reported by @joefbsjr in https://github.com/razzmatazz/csharp-language-server/issues/41 * Load solution-in-sync when initializing. This will help "server initializing" notification work better for clients that depend on `initialize` request not to complete until the server/solution is properly loaded initialized. - Reported by @joefbsjr in https://github.com/razzmatazz/csharp-language-server/issues/40 ### More about Šilavotas, Lithuania - [Kitoks kaimas Prienų rajone](https://www.lrytas.lt/kultura/istorija/2021/08/07/news/kitoks-kaimas-prienu-rajone-kurio-neisdraske-net-sovietu-valdzia-bendruomenes-nariais-tampa-ir-kaunieciai-20347142) ## [0.5.3] - 2022-07-29 / Daugai https://www.google.com/search?tbm=isch&q=daugai+lithuania * Fix (hopefully) how timeout on "textDocument/codeLens" works -- an empty result is returned now, and not as a request cancellation; * Fix how request cancellation is signalled to down the pipes to StreamJsonRpc/Ionide.LSP -- we will unwrap AggregateException to expose TaskCanceledException: - see https://github.com/razzmatazz/csharp-language-server/issues/32 reported by @vytautassurvila; * Add a fix for some editor where special urls on file path, like '#' were not handled properly: - PR https://github.com/razzmatazz/csharp-language-server/pull/38 by @tcx4c70 ### More about Daugai, Lithuania - [Google Images on Daugai](https://www.google.com/search?tbm=isch&q=daugai+lithuania) ## [0.5.2] - 2022-07-02 / Luksnėnai * Update Roslyn, MSBuild and ICSharpCode.Decompiler; * Fix how "unnecesary using directive" is exposed, hopefully: - fixes https://github.com/razzmatazz/csharp-language-server/issues/35 by @Decodetalkers; * Expose actual csharp compiler diagnostics ids (e.g. CS0117) for nicer diagnostics messages. ## [0.5.1] - 2022-05-19 / Straigiškė - Fix another long-standing bug with incremental document synchronisation; - very visible on nvim but affects all editors/clients; - reported by @Decodetalkers https://github.com/razzmatazz/csharp-language-server/issues/31; - Improve textDocument/completion: - provide `CompletionItem.FilterText` and `CompletionItem.SortText`; ## [0.5.0-Lazdijai] - Implement textDocument/signatureHelp; - https://github.com/razzmatazz/csharp-language-server/issues/30 ## [0.4.3-Meteliai] - change `CodeAnalysis.AddImport` kind to `quickfix` - this will show add missing imports in vscode's quick fix panel; - don't run pending read/only requests until previous r/w one is processed; - this should fix https://github.com/razzmatazz/csharp-language-server/issues/28 reported by @vytautassurvila ## [0.4.2-Randamonys] - Don't register capabilities when initialized, but after "initialized" has been received from the client; - this makes us more LSP-spec compatible; - noted by @vytautassurvila in https://github.com/razzmatazz/csharp-language-server/issues/26 ## [0.4.1-Liškiava] - Revert Roslyn update, broke some of the stuff with now gain; - Fix an issue where some of the assemblies cannot be inspected with go-to-definition from metadata; - https://github.com/razzmatazz/csharp-language-server/issues/22 - Try harder to match method by arity when doing "go-to-definition" on metadata; - e.g. `Console.WriteLine()` should now open the correct definition as it is single matching method `WriteLine` on `Console` with arity of 0; ## [0.4.0-Druskininkai] - Update Roslyn and ICSharpCode libs; - Observe and update solution when unopen files are changed/added/removed; - this should reduce the need to restart lsp workspace often after adding/removing files or after git branch switches; - Reload solution on .sln or .csproj change; - Change how diagnostics are calculated (again) so we sent it for all the documents that we know are open, once a random file has been modified, in the descending order that they were touched. ## [0.3.0] - Run diagnostics resolution outside the main state actor so we don't lock up other processing; - Add timeout for codelens requests to avoid excessive CPU usage as that is prone to run for a long time; - Really fix write-request serialization; - Revert the emacs-29 fix, didn't do much. ## [0.2.1] - Carefully observe incoming requests from StreamJsonRpc to actually serialize write-access to solution state; - Should fix sync issues (another attempt..) - Attempt to fix an issue with emacs-29 by setting `bufferSize` in `Console.OpenStandardInput` call. ## [0.2.0] - Support for document formatting, courtesy of @kstatz12; - Fix `textDocument/didOpen` handler: - we will now refresh roslyn solution with file contents as reported by the editor, as our state could have been outdated since; - Fix sync issues by serializing writes to server state; - Implement incremental file change sync to improve performance for large files; - Handle $/cancellationRequest's to handle cancellation requests properly. ## [0.1.9] - Refactor server state tracking to (hopefully) fix some issues with document sync/versioning; - Fix, hopefully in the final form, how symbols are formatted by using roslyn To*DisplayString() methods; - Don't show symbol attributes on textDocument/documentSymbol response; ## [0.1.8] - Implementation for code lens that shows number of references; - Needs client implementation of `workspace/executeCommand`: `csharp.showReferences`; - Nicer on-hover markdown that should match the context better; - Expose properties & events on textDocument/documentSymbol; - Pull `add using import` code action to the top of action list, mark it prefered and with `Kind`, [csharp-language-server#9](https://github.com/razzmatazz/csharp-language-server/issues/9). ## [0.1.7] - Bump roslyn libs to a newer version; - Add support for `textDocument/implementation`; - Expose more bits from xmldoc properly on tip on hover; - Drop local LanguageServerProtocol clone from FSAC and use [Ionide.LanguageServerProtocol](https://github.com/ionide/LanguageServerProtocol) instead; - Fix file creation via code actions (e.g. when extracting an interface or inner class to another file); - List params and exceptions in the same order as they appear on docxml on the symbol (instead of random order) -- [csharp-language-server#6](https://github.com/razzmatazz/csharp-language-server/issues/6); - Disable incorrectly implemented `textDocument/implementation` provider [csharp-language-server#4](https://github.com/razzmatazz/csharp-language-server/issues/4); ## [0.1.6] - Update roslyn+msbuild libs to support for `net6.0` projects; - Use .NET 6.0 for runtime; - Fix `workspace/symbol` to return correct locations; - Implement `textDocument/implementation` (alias to `textDocument/definition` actually); - Support for `codeAction/resolve` so we have faster code action resolution/less overhead when working on large solutions. ## [0.1.5] - Enable code actions that are nested, like "generate field/property/ro-field/ro-property"; - Update how tooltip on hover is formatted; should be much nicer; - Fix how adding new file works -- don't write unnecesary `` when a new file is added and trigger diagnostics update immediately. ## [0.1.4] - Don't reference NuGet.* packages as those bind to particular(?) sdk -- things work better now, as it was not working for me with updated SDK dependencies; - Update roslyn dependencies; - Adding new file works (i.e. no need to restart workspace anymore); - There is an issue that Roslyn adds (unnecessary) `` to the project; - Don't highlight namespace symbols as those can cover all the symbols on the source file and that is not useful; - Add -l/--loglevel param; - Expose C# docxml as markdown for more proper on-hover experience (still needs more love, FsAutoComplete does it beautifully); - Don't publish diagnostics for C# documents generated from metadata. ## [0.1.3] - Support `--help` and `--version` command line params. - Support for `-s/--solution` param to load specific solution file. ## [0.1.2] - No -alpha version number suffix so you don't need --version to install with `dotnet tool install`; - Don't return from `initialize` until we actually load the solution; - Report csharp-ls version number to the client. ## [0.1.1-alpha] Initial version: - Most of basic LSP features work: rename/go-to-def/find references, etc; - Support for textDocument/documentHighlight; - Go-to-metadata (needs integration from your LSP client;) - Published as `dotnet tool csharp-ls` csharp-language-server-0.18.0/Directory.Build.props000066400000000000000000000007031502617301100222300ustar00rootroot00000000000000 csharp-ls csharp-ls MIT $(MSBuildThisFileDirectory)CHANGELOG.md csharp-language-server-0.18.0/Directory.Build.targets000066400000000000000000000010651502617301100225400ustar00rootroot00000000000000 csharp-language-server-0.18.0/Directory.Packages.props000066400000000000000000000050611502617301100227110ustar00rootroot00000000000000 true true 17.14.8 4.14.0 1.9.1 csharp-language-server-0.18.0/LICENSE000066400000000000000000000021311502617301100171430ustar00rootroot00000000000000The MIT License (MIT) Copyright (c) 2020-2021 Saulius Menkevičius All rights reserved. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. csharp-language-server-0.18.0/README.md000066400000000000000000000067051502617301100174300ustar00rootroot00000000000000# Description This is a hacky Roslyn-based LSP server for C#, as an alternative to [omnisharp-roslyn](https://github.com/OmniSharp/omnisharp-roslyn). `csharp-ls` requires .NET 8 SDK to be installed. However it has been reported to work with projects using older versions of dotnet SDK, including .NET Core 3, .NET Framework 4.8 and possibly older ones too as it uses the standard Roslyn/MSBuild libs that Visual Studio & omnisharp does. See [CHANGELOG.md](CHANGELOG.md) for the list of recent improvements/fixes. # Acknowledgements - csharp-ls is not affiliated with Microsoft Corp; - csharp-ls uses LSP interface from [Ionide.LanguageServerProtocol](https://github.com/ionide/LanguageServerProtocol); - csharp-ls uses [Roslyn](https://github.com/dotnet/roslyn) to parse and update code; Roslyn maps really nicely to LSP w/relatively little impedance mismatch; - csharp-ls uses [ILSpy/ICSharpCode.Decompiler](https://github.com/icsharpcode/ILSpy) to decompile types in assemblies to C# source. # Installation `dotnet tool install --global csharp-ls` See [csharp-ls nuget page](https://www.nuget.org/packages/csharp-ls/) # Settings - `csharp.solution` - solution to load, optional - `csharp.applyFormattingOptions` - use formatting options as supplied by the client (may override `.editorconfig` values), defaults to `false` # Clients `csharp-ls` implements the standard LSP protocol to interact with your editor. However there are some features that need a non-standard implementation and this is where editor-specific plugins can be helpful. ## Emacs ### emacs/lsp-mode Supports automatic installation, go-to-metatada (can view code from nuget/compiled dlls) and some additional features. See [emacs/lsp-mode](https://github.com/emacs-lsp/lsp-mode). ## Visual Studio Code ### vytautassurvila/vscode-csharp-ls - Supports code decompilation from metadata See [csharp-ls](https://marketplace.visualstudio.com/items?itemName=vytautassurvila.csharp-ls) and [vscode-csharp-ls @ github](https://github.com/vytautassurvila/vscode-csharp-ls). ### statiolake/vscode-csharp-ls See [vscode-csharp-ls](https://marketplace.visualstudio.com/items?itemName=statiolake.vscode-csharp-ls). # Building ## On Linux/macOS ``` $ dotnet build ``` # FAQ ## decompile for your editor , with the example of neovim ### api The api is "csharp/metadata", in neovim ,you can request it like ```lua local result, err = client.request_sync("csharp/metadata", params, 10000) ``` #### sender You need to send a uri, it is like **csharp:/metadata/projects/trainning2/assemblies/System.Console/symbols/System.Console.cs** In neovim, it will be result(s) from vim.lsp.handles["textDocument/definition"] and the key of uri is the key, The key to send is like ```lua local params = { timeout = 5000, textDocument = { uri = uri, } } ``` The key of textDocument is needed. And timeout is just for neovim. It is the same if is expressed by json. ### receiver The object received is like ```lua { projectName = "csharp-test", assemblyName = "System.Runtime", symbolName = "System.String", source = "using System.Buffers;\n ...." } ``` And In neovim, You receive the "result" above, you can get the decompile source from ```lua local result, err = client.request_sync("csharp/metadata", params, 10000) local source if not err then source = result.result.source end ``` And there is a plugin of neovim for you to decompile it. [csharpls-extended-lsp.nvim](https://github.com/chen244/csharpls-extended-lsp.nvim) csharp-language-server-0.18.0/csharp-language-server.sln000066400000000000000000000065421502617301100232330ustar00rootroot00000000000000 Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio Version 16 VisualStudioVersion = 16.0.30114.105 MinimumVisualStudioVersion = 10.0.40219.1 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{3ADA171B-D93F-4D34-97EA-5BB06662678B}" EndProject Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "CSharpLanguageServer", "src\CSharpLanguageServer\CSharpLanguageServer.fsproj", "{228A59AD-2E4C-4DF4-AC5E-1F126A4FFF02}" EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{35DF1A49-B49A-42CB-B43B-8E8120AD9B0E}" EndProject Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "CSharpLanguageServer.Tests", "tests\CSharpLanguageServer.Tests\CSharpLanguageServer.Tests.fsproj", "{754F8FCE-6DC2-43E2-832D-00A8B830D192}" EndProject Global GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU Debug|x64 = Debug|x64 Debug|x86 = Debug|x86 Release|Any CPU = Release|Any CPU Release|x64 = Release|x64 Release|x86 = Release|x86 EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {228A59AD-2E4C-4DF4-AC5E-1F126A4FFF02}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {228A59AD-2E4C-4DF4-AC5E-1F126A4FFF02}.Debug|Any CPU.Build.0 = Debug|Any CPU {228A59AD-2E4C-4DF4-AC5E-1F126A4FFF02}.Debug|x64.ActiveCfg = Debug|Any CPU {228A59AD-2E4C-4DF4-AC5E-1F126A4FFF02}.Debug|x64.Build.0 = Debug|Any CPU {228A59AD-2E4C-4DF4-AC5E-1F126A4FFF02}.Debug|x86.ActiveCfg = Debug|Any CPU {228A59AD-2E4C-4DF4-AC5E-1F126A4FFF02}.Debug|x86.Build.0 = Debug|Any CPU {228A59AD-2E4C-4DF4-AC5E-1F126A4FFF02}.Release|Any CPU.ActiveCfg = Release|Any CPU {228A59AD-2E4C-4DF4-AC5E-1F126A4FFF02}.Release|Any CPU.Build.0 = Release|Any CPU {228A59AD-2E4C-4DF4-AC5E-1F126A4FFF02}.Release|x64.ActiveCfg = Release|Any CPU {228A59AD-2E4C-4DF4-AC5E-1F126A4FFF02}.Release|x64.Build.0 = Release|Any CPU {228A59AD-2E4C-4DF4-AC5E-1F126A4FFF02}.Release|x86.ActiveCfg = Release|Any CPU {228A59AD-2E4C-4DF4-AC5E-1F126A4FFF02}.Release|x86.Build.0 = Release|Any CPU {754F8FCE-6DC2-43E2-832D-00A8B830D192}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {754F8FCE-6DC2-43E2-832D-00A8B830D192}.Debug|Any CPU.Build.0 = Debug|Any CPU {754F8FCE-6DC2-43E2-832D-00A8B830D192}.Debug|x64.ActiveCfg = Debug|Any CPU {754F8FCE-6DC2-43E2-832D-00A8B830D192}.Debug|x64.Build.0 = Debug|Any CPU {754F8FCE-6DC2-43E2-832D-00A8B830D192}.Debug|x86.ActiveCfg = Debug|Any CPU {754F8FCE-6DC2-43E2-832D-00A8B830D192}.Debug|x86.Build.0 = Debug|Any CPU {754F8FCE-6DC2-43E2-832D-00A8B830D192}.Release|Any CPU.ActiveCfg = Release|Any CPU {754F8FCE-6DC2-43E2-832D-00A8B830D192}.Release|Any CPU.Build.0 = Release|Any CPU {754F8FCE-6DC2-43E2-832D-00A8B830D192}.Release|x64.ActiveCfg = Release|Any CPU {754F8FCE-6DC2-43E2-832D-00A8B830D192}.Release|x64.Build.0 = Release|Any CPU {754F8FCE-6DC2-43E2-832D-00A8B830D192}.Release|x86.ActiveCfg = Release|Any CPU {754F8FCE-6DC2-43E2-832D-00A8B830D192}.Release|x86.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(NestedProjects) = preSolution {228A59AD-2E4C-4DF4-AC5E-1F126A4FFF02} = {3ADA171B-D93F-4D34-97EA-5BB06662678B} {754F8FCE-6DC2-43E2-832D-00A8B830D192} = {35DF1A49-B49A-42CB-B43B-8E8120AD9B0E} EndGlobalSection EndGlobal csharp-language-server-0.18.0/global.json000066400000000000000000000001061502617301100202710ustar00rootroot00000000000000{ "sdk": { "version": "9.0.1", "rollForward": "minor" } } csharp-language-server-0.18.0/src/000077500000000000000000000000001502617301100167305ustar00rootroot00000000000000csharp-language-server-0.18.0/src/CSharpLanguageServer/000077500000000000000000000000001502617301100227435ustar00rootroot00000000000000csharp-language-server-0.18.0/src/CSharpLanguageServer/CHANGELOG.md000077700000000000000000000000001502617301100270062../../CHANGELOG.mdustar00rootroot00000000000000csharp-language-server-0.18.0/src/CSharpLanguageServer/CSharpLanguageServer.fsproj000066400000000000000000000111401502617301100302000ustar00rootroot00000000000000 Exe net9.0 C# LSP language server true csharp-ls Saulius Menkevičius ./nupkg csharp-ls MIT csharp;lsp;roslyn https://github.com/razzmatazz/csharp-language-server true README.md CHANGELOG.md NU1604 NU1701 NU1604 NU1701 csharp-language-server-0.18.0/src/CSharpLanguageServer/Conversions.fs000066400000000000000000000272011502617301100256070ustar00rootroot00000000000000namespace CSharpLanguageServer.Conversions open System open System.IO open Microsoft.CodeAnalysis open Microsoft.CodeAnalysis.Completion open Microsoft.CodeAnalysis.Text open Ionide.LanguageServerProtocol.Types open CSharpLanguageServer.Util module Uri = // Unescape some necessary char before passing string to Uri. // Can't use Uri.UnescapeDataString here. For example, if uri is "file:///z%3a/src/c%23/ProjDir" ("%3a" is // ":" and "%23" is "#"), Uri.UnescapeDataString will unescape both "%3a" and "%23". Then Uri will think /// "#/ProjDir" is Fragment instead of part of LocalPath. let unescape (uri: string) = uri.Replace("%3a", ":", true, null) let toPath (uri: string) = Uri.UnescapeDataString(Uri(unescape(uri)).LocalPath) let fromPath (path: string) = let metadataPrefix = "$metadata$/" if path.StartsWith(metadataPrefix) then "csharp:/metadata/" + path.Substring(metadataPrefix.Length) else Uri(path).ToString() let toWorkspaceFolder(uri: string): WorkspaceFolder = { Uri = 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 ; Character = uint32 pos.Character } let toLinePosition (lines: TextLineCollection) (pos: Position): LinePosition = if (int pos.Line) >= lines.Count then LinePosition(lines.Count - 1, lines[lines.Count - 1].EndIncludingLineBreak - lines[lines.Count - 1].Start) else LinePosition(int pos.Line, int pos.Character) let toRoslynPosition (lines: TextLineCollection) = toLinePosition lines >> lines.GetPosition module Range = let toLinePositionSpan (lines: TextLineCollection) (range: Range): LinePositionSpan = LinePositionSpan( Position.toLinePosition lines range.Start, Position.toLinePosition lines range.End) let fromLinePositionSpan (pos: LinePositionSpan): Range = { Start = Position.fromLinePosition pos.Start End = Position.fromLinePosition pos.End } let toTextSpan (lines: TextLineCollection) = toLinePositionSpan lines >> lines.GetTextSpan let fromTextSpan (lines: TextLineCollection) = lines.GetLinePositionSpan >> fromLinePositionSpan module Location = let fromRoslynLocation (loc: Microsoft.CodeAnalysis.Location): option = let toLspLocation (path: string) span: Location = { Uri = path |> Path.toUri Range = span |> Range.fromLinePositionSpan } match loc.Kind with | LocationKind.SourceFile -> let mappedLoc = loc.GetMappedLineSpan() if mappedLoc.IsValid && File.Exists(mappedLoc.Path) then toLspLocation mappedLoc.Path mappedLoc.Span |> Some elif File.Exists(loc.SourceTree.FilePath) then toLspLocation loc.SourceTree.FilePath (loc.GetLineSpan().Span) |> Some else None | _ -> None module TextEdit = let fromTextChange (lines: TextLineCollection) (changes: TextChange): TextEdit = { Range = changes.Span |> Range.fromTextSpan lines NewText = changes.NewText } module SymbolKind = let fromSymbol (symbol: ISymbol): SymbolKind = match symbol with | :? ILocalSymbol -> SymbolKind.Variable | :? IFieldSymbol as fs -> if not(isNull fs.ContainingType) && fs.ContainingType.TypeKind = TypeKind.Enum && fs.HasConstantValue then SymbolKind.EnumMember else SymbolKind.Field | :? IPropertySymbol -> SymbolKind.Property | :? IMethodSymbol as ms -> match ms.MethodKind with | MethodKind.Constructor -> SymbolKind.Constructor | MethodKind.StaticConstructor -> SymbolKind.Constructor | MethodKind.BuiltinOperator -> SymbolKind.Operator | MethodKind.UserDefinedOperator -> SymbolKind.Operator | MethodKind.Conversion -> SymbolKind.Operator | _ -> SymbolKind.Method | :? ITypeSymbol as ts -> match ts.TypeKind with | TypeKind.Class -> SymbolKind.Class | TypeKind.Enum -> SymbolKind.Enum | TypeKind.Struct -> SymbolKind.Struct | TypeKind.Interface -> SymbolKind.Interface | TypeKind.Delegate -> SymbolKind.Class | TypeKind.Array -> SymbolKind.Array | TypeKind.TypeParameter -> SymbolKind.TypeParameter | _ -> SymbolKind.Class | :? IEventSymbol -> SymbolKind.Event | :? INamespaceSymbol -> SymbolKind.Namespace | _ -> SymbolKind.File module SymbolName = let fromSymbol (format: SymbolDisplayFormat) (symbol: ISymbol): string = symbol.ToDisplayString(format) module CallHierarchyItem = let private displayStyle = SymbolDisplayFormat( typeQualificationStyle = SymbolDisplayTypeQualificationStyle.NameOnly, genericsOptions = SymbolDisplayGenericsOptions.IncludeTypeParameters, memberOptions = (SymbolDisplayMemberOptions.IncludeParameters ||| SymbolDisplayMemberOptions.IncludeExplicitInterface), parameterOptions = (SymbolDisplayParameterOptions.IncludeParamsRefOut ||| SymbolDisplayParameterOptions.IncludeExtensionThis ||| SymbolDisplayParameterOptions.IncludeType), miscellaneousOptions = SymbolDisplayMiscellaneousOptions.UseSpecialTypes ) let fromSymbolAndLocation (symbol: ISymbol) (location: Location): CallHierarchyItem = let kind = SymbolKind.fromSymbol symbol let containingType = (symbol.ContainingType :> ISymbol) |> Option.ofObj let containingNamespace = (symbol.ContainingNamespace :> ISymbol) |> Option.ofObj { Name = symbol.ToDisplayString(displayStyle) Kind = kind Tags = None Detail = containingType |> Option.orElse containingNamespace |> Option.map (fun sym -> sym.ToDisplayString()) Uri = location.Uri Range = location.Range SelectionRange = location.Range Data = None } let fromSymbol (wmResolveSymbolLocations: ISymbol -> Project option -> Async>) (symbol: ISymbol): Async = wmResolveSymbolLocations symbol None |> Async.map (List.map (fromSymbolAndLocation symbol)) module TypeHierarchyItem = let private displayStyle = SymbolDisplayFormat( typeQualificationStyle = SymbolDisplayTypeQualificationStyle.NameOnly, genericsOptions = SymbolDisplayGenericsOptions.IncludeTypeParameters, memberOptions = (SymbolDisplayMemberOptions.IncludeParameters ||| SymbolDisplayMemberOptions.IncludeExplicitInterface), parameterOptions = (SymbolDisplayParameterOptions.IncludeParamsRefOut ||| SymbolDisplayParameterOptions.IncludeExtensionThis ||| SymbolDisplayParameterOptions.IncludeType), miscellaneousOptions = SymbolDisplayMiscellaneousOptions.UseSpecialTypes ) let fromSymbolAndLocation (symbol: ISymbol) (location: Location): TypeHierarchyItem = let kind = SymbolKind.fromSymbol symbol let containingType = (symbol.ContainingType :> ISymbol) |> Option.ofObj let containingNamespace = (symbol.ContainingNamespace :> ISymbol) |> Option.ofObj { Name = symbol.ToDisplayString(displayStyle) Kind = kind Tags = None Detail = containingType |> Option.orElse containingNamespace |> Option.map (fun sym -> sym.ToDisplayString()) Uri = location.Uri Range = location.Range SelectionRange = location.Range Data = None } let fromSymbol (wmResolveSymbolLocations: ISymbol -> Project option -> Async>) (symbol: ISymbol): Async = wmResolveSymbolLocations symbol None |> Async.map (List.map (fromSymbolAndLocation symbol)) module SymbolInformation = let fromSymbol (format: SymbolDisplayFormat) (symbol: ISymbol): SymbolInformation list = let toSymbolInformation loc = { Name = SymbolName.fromSymbol format symbol Kind = SymbolKind.fromSymbol symbol Location = loc ContainerName = None Deprecated = None Tags = None } symbol.Locations |> Seq.map Location.fromRoslynLocation |> Seq.filter _.IsSome |> Seq.map _.Value |> Seq.map toSymbolInformation |> Seq.toList module DiagnosticSeverity = let fromRoslynDiagnosticSeverity (sev: Microsoft.CodeAnalysis.DiagnosticSeverity): DiagnosticSeverity = match sev with | Microsoft.CodeAnalysis.DiagnosticSeverity.Info -> DiagnosticSeverity.Information | Microsoft.CodeAnalysis.DiagnosticSeverity.Warning -> DiagnosticSeverity.Warning | Microsoft.CodeAnalysis.DiagnosticSeverity.Error -> DiagnosticSeverity.Error | _ -> DiagnosticSeverity.Warning module Diagnostic = let fromRoslynDiagnostic (diagnostic: Microsoft.CodeAnalysis.Diagnostic): Diagnostic = 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 } module CompletionContext = let toCompletionTrigger (context: CompletionContext option): Completion.CompletionTrigger = context |> Option.bind (fun ctx -> match ctx.TriggerKind with | CompletionTriggerKind.Invoked | CompletionTriggerKind.TriggerForIncompleteCompletions -> Some Completion.CompletionTrigger.Invoke | CompletionTriggerKind.TriggerCharacter -> ctx.TriggerCharacter |> Option.map Seq.head |> Option.map Completion.CompletionTrigger.CreateInsertionTrigger | _ -> None) |> Option.defaultValue (Completion.CompletionTrigger.Invoke) module CompletionDescription = let toMarkdownString (description: CompletionDescription) : string = description.TaggedParts |> Seq.map (fun taggedText -> // WTF, if the developers of Roslyn don't want users to use TaggedText, why they set TaggedText to public? // If they indeed want users to use it, why they set lots of imported fields to internal? match taggedText.Tag with // TODO: Support code block? | "CodeBlockStart" -> "`` " + taggedText.Text | "CodeBlockEnd" -> " ``" + taggedText.Text | TextTags.LineBreak -> "\n\n" | _ -> taggedText.Text) |> String.concat "" let toDocumentation (description: CompletionDescription) : MarkupContent = { Kind = MarkupKind.Markdown; Value = toMarkdownString description } module Documentation = let fromCompletionDescription = CompletionDescription.toDocumentation csharp-language-server-0.18.0/src/CSharpLanguageServer/DocumentationUtil.fs000066400000000000000000000153741502617301100267560ustar00rootroot00000000000000namespace CSharpLanguageServer open System open System.Xml.Linq open Microsoft.CodeAnalysis open CSharpLanguageServer.Conversions module DocumentationUtil = type TripleSlashComment = { Summary: XElement list Params: (string * XElement) list Exceptions: (string * XElement) list Returns: XElement list Types: (string * XElement) list Remarks: XElement list OtherLines: XElement list } static member Default = { Summary = [] Params = [] Exceptions = [] Returns = [] Types = [] Remarks = [] OtherLines = [] } let parseCref (cref: string) = let parts = cref.Split(':') match parts.Length with | 1 -> cref | _ -> String.Join(":", parts |> Seq.skip 1) let normalizeWhitespace (s: string) = let mutable modified = s let mutable prevModified = "" while modified <> prevModified do prevModified <- modified modified <- modified.Replace(" ", " ").Replace("\r\n", " ").Replace("\n", " ") modified let formatTextElement (n: XElement) = let formatSeeElement (e: XElement) = let crefMaybe = e.Attribute(XName.Get("cref")) |> Option.ofObj |> Option.map (fun x -> x.Value) |> Option.map parseCref |> Option.map (fun s -> sprintf "``%s``" s) |> Option.toList let langWordMaybe = e.Attribute(XName.Get("langword")) |> Option.ofObj |> Option.map (fun x -> sprintf "``%s``" x.Value) |> Option.toList crefMaybe |> Seq.append langWordMaybe |> List.ofSeq let rec formatTextNode (subnode: XNode) = match subnode with | :? XElement as e -> match e.Name.LocalName with | "c" -> [ sprintf "``%s``" e.Value ] | "see" -> formatSeeElement e | "paramref" -> e.Attribute(XName.Get("name")) |> Option.ofObj |> Option.map (fun x -> sprintf "``%s``" x.Value) |> Option.toList | "para" -> e.Nodes() |> Seq.collect formatTextNode |> Seq.append [ "\n\n" ] |> List.ofSeq | _ -> [ e.Value ] | :? XText as t -> [ t.Value |> normalizeWhitespace ] | _ -> [] n.Nodes() |> Seq.collect formatTextNode |> (fun ss -> String.Join("", ss)) let extendCommentWithElement comment (n: XElement) = match n.Name.LocalName with | "summary" -> let newSummary = comment.Summary |> List.append [ n ] { comment with Summary = newSummary } | "remarks" -> let newRemarks = comment.Remarks |> List.append [ n ] { comment with Remarks = newRemarks } | "param" -> let name = n.Attribute(XName.Get("name")).Value { comment with Params = comment.Params |> List.append [ (name, n) ] } | "returns" -> { comment with Returns = comment.Returns |> List.append [ n ] } | "exception" -> let name = n.Attribute(XName.Get("cref")).Value |> parseCref { comment with Exceptions = comment.Exceptions |> List.append [ (name, n) ] } | "typeparam" -> let name = n.Attribute(XName.Get("name")).Value { comment with Types = comment.Types |> List.append [ (name, n) ] } | _ -> { comment with OtherLines = comment.OtherLines |> List.append [ n ] } let parseComment xmlDocumentation: TripleSlashComment = let doc = XDocument.Parse("" + xmlDocumentation + "") let unwrapDocRoot (root: XElement) = let elementNames (el: XElement) = el.Elements() |> Seq.map (fun e -> e.Name.LocalName) |> List.ofSeq match elementNames root with | [ "member" ] -> root.Element(XName.Get("member")) | _ -> root doc.Root |> unwrapDocRoot |> fun r -> r.Elements() |> Seq.fold extendCommentWithElement TripleSlashComment.Default let formatComment model : string list = let appendNamed name (kvs: (string * XElement) seq) markdownLines = match Seq.isEmpty kvs with | true -> markdownLines | false -> let formatItem (key, value) = sprintf "- ``%s``: %s" key (formatTextElement value) markdownLines |> List.append [ name + ":"; "" ] |> List.append (kvs |> Seq.map formatItem |> List.ofSeq) let appendFormatted name elms markdownLines = let formattedLines = elms |> List.map formatTextElement |> List.filter (not << String.IsNullOrWhiteSpace) match Seq.isEmpty formattedLines with | true -> markdownLines | false -> markdownLines |> List.append [ "" ] |> List.append (formattedLines |> List.map (fun s -> name + ": " + s)) [] |> List.append (model.Summary |> List.map formatTextElement) |> appendNamed "Parameters" model.Params |> appendFormatted "Returns" model.Returns |> appendNamed "Exceptions" model.Exceptions |> appendNamed "Types" model.Types |> appendFormatted "Remarks" model.Remarks |> List.append (model.OtherLines |> List.map string) |> List.rev |> List.map (fun s -> s.Trim()) let formatDocXml xmlDocumentation = String.Join("\n", xmlDocumentation |> parseComment |> formatComment) let markdownDocForSymbol (sym: ISymbol) = let comment = parseComment (sym.GetDocumentationCommentXml()) let formattedDocLines = formatComment comment formattedDocLines |> (fun ss -> String.Join("\n", ss)) let markdownDocForSymbolWithSignature (sym: ISymbol) = let symbolName = SymbolName.fromSymbol SymbolDisplayFormat.MinimallyQualifiedFormat sym let symbolInfoLines = match symbolName with | "" -> [] | typeName -> [ sprintf "```csharp\n%s\n```" typeName ] let comment = parseComment (sym.GetDocumentationCommentXml()) let formattedDocLines = formatComment comment formattedDocLines |> Seq.append ( if symbolInfoLines.Length > 0 && formattedDocLines.Length > 0 then [ "" ] else [] ) |> Seq.append symbolInfoLines |> (fun ss -> String.Join("\n", ss)) csharp-language-server-0.18.0/src/CSharpLanguageServer/FormatUtil.fs000066400000000000000000000123011502617301100253600ustar00rootroot00000000000000namespace CSharpLanguageServer open Microsoft.CodeAnalysis open Microsoft.CodeAnalysis.CSharp open Microsoft.CodeAnalysis.CSharp.Formatting open Microsoft.CodeAnalysis.Options open Microsoft.CodeAnalysis.Text open Microsoft.CodeAnalysis.Formatting open Ionide.LanguageServerProtocol.Types open CSharpLanguageServer.Types module internal FormatUtil = let 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 convert (oldText: SourceText) (changes: TextChange[]) : TextEdit[] = //why doesnt it pick up that TextSpan implements IComparable? //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 getChanges (doc: Document) (oldDoc: Document) : Async = 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 getFormattingOptions (settings: ServerSettings) (doc: Document) (formattingOptions: FormattingOptions) : Async = async { let! docOptions = doc.GetOptionsAsync() |> Async.AwaitTask return match settings.ApplyFormattingOptions with | false -> docOptions | true -> docOptions |> _.WithChangedOption(FormattingOptions.IndentationSize, LanguageNames.CSharp, int formattingOptions.TabSize) |> _.WithChangedOption(FormattingOptions.UseTabs, LanguageNames.CSharp, not formattingOptions.InsertSpaces) |> match formattingOptions.InsertFinalNewline with | Some insertFinalNewline -> _.WithChangedOption(CSharpFormattingOptions.NewLineForFinally, insertFinalNewline) | None -> id |> match formattingOptions.TrimFinalNewlines with | Some trimFinalNewlines -> _.WithChangedOption(CSharpFormattingOptions.NewLineForFinally, not trimFinalNewlines) | None -> id } let rec getSyntaxNode (token: SyntaxToken) : SyntaxNode option = if token.IsKind(SyntaxKind.EndOfFileToken) then getSyntaxNode (token.GetPreviousToken()) else match token.Kind() with | SyntaxKind.SemicolonToken -> token.Parent |> Some | SyntaxKind.CloseBraceToken -> let parent = token.Parent match parent.Kind() with | SyntaxKind.Block -> parent.Parent |> Some | _ -> parent |> Some | SyntaxKind.CloseParenToken -> if token.GetPreviousToken().IsKind(SyntaxKind.SemicolonToken) && token.Parent.IsKind(SyntaxKind.ForStatement) then token.Parent |> Some else None | _ -> None let findFormatTarget (root: SyntaxNode) (position: int) : SyntaxNode option = let token = root.FindToken position getSyntaxNode token csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/000077500000000000000000000000001502617301100245035ustar00rootroot00000000000000csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/CSharpMetadata.fs000066400000000000000000000011771502617301100276640ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer.Types open CSharpLanguageServer.State [] module CSharpMetadata = let handle (context: ServerRequestContext) (metadataParams: CSharpMetadataParams): AsyncLspResult = async { let uri = metadataParams.TextDocument.Uri let metadataMaybe = context.DecompiledMetadata |> Map.tryFind uri |> Option.map (fun x -> x.Metadata) return metadataMaybe |> LspResult.success } csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/CallHierarchy.fs000066400000000000000000000104701502617301100275510ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open System open Microsoft.CodeAnalysis open Microsoft.CodeAnalysis.FindSymbols open Ionide.LanguageServerProtocol.Server open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer.Types open CSharpLanguageServer.State open CSharpLanguageServer.Conversions [] module CallHierarchy = let private isCallableSymbol (symbol: ISymbol): bool = if isNull symbol then false else List.contains symbol.Kind [ Microsoft.CodeAnalysis.SymbolKind.Method Microsoft.CodeAnalysis.SymbolKind.Field Microsoft.CodeAnalysis.SymbolKind.Event Microsoft.CodeAnalysis.SymbolKind.Property ] let private dynamicRegistration (clientCapabilities: ClientCapabilities) = clientCapabilities.TextDocument |> Option.bind (fun x -> x.CallHierarchy) |> Option.bind (fun x -> x.DynamicRegistration) |> Option.defaultValue false let provider (clientCapabilities: ClientCapabilities) : U3 option = match dynamicRegistration clientCapabilities with | true -> None | false -> Some (U3.C1 true) let registration (clientCapabilities: ClientCapabilities) : Registration option = match dynamicRegistration clientCapabilities with | false -> None | true -> let registerOptions: CallHierarchyRegistrationOptions = { DocumentSelector = Some defaultDocumentSelector Id = None WorkDoneProgress = None } Some { Id = Guid.NewGuid().ToString() Method = "textDocument/prepareCallHierarchy" RegisterOptions = registerOptions |> serialize |> Some } let prepare (context: ServerRequestContext) (p: CallHierarchyPrepareParams) : AsyncLspResult = async { match! context.FindSymbol p.TextDocument.Uri p.Position with | Some symbol when isCallableSymbol symbol -> let! itemList = CallHierarchyItem.fromSymbol context.ResolveSymbolLocations symbol return itemList |> List.toArray |> Some |> LspResult.success | _ -> return None |> LspResult.success } let incomingCalls (context: ServerRequestContext) (p: CallHierarchyIncomingCallsParams) : AsyncLspResult = async { let toCallHierarchyIncomingCalls (info: SymbolCallerInfo) : CallHierarchyIncomingCall seq = let fromRanges = info.Locations |> Seq.map (fun l -> l.GetLineSpan().Span |> Range.fromLinePositionSpan) |> Seq.toArray info.CallingSymbol.Locations |> Seq.map Location.fromRoslynLocation |> Seq.filter _.IsSome |> Seq.map _.Value |> Seq.map (fun loc -> { From = CallHierarchyItem.fromSymbolAndLocation (info.CallingSymbol) loc FromRanges = fromRanges }) match! context.FindSymbol p.Item.Uri p.Item.Range.Start with | None -> return None |> LspResult.success | Some symbol -> let! callers = context.FindCallers symbol // TODO: If we remove info.IsDirect, then we will get lots of false positive. But if we keep it, // we will miss many callers. Maybe it should have some change in LSP protocol. return callers |> Seq.filter (fun info -> info.IsDirect && isCallableSymbol info.CallingSymbol) |> Seq.collect toCallHierarchyIncomingCalls |> Seq.distinct |> Seq.toArray |> Some |> LspResult.success } let outgoingCalls (_context: ServerRequestContext) (_: CallHierarchyOutgoingCallsParams) : AsyncLspResult = async { // TODO: There is no memthod of SymbolFinder which can find all outgoing calls of a specific symbol. // Then how can we implement it? Parsing AST manually? return None |> LspResult.success } csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/CodeAction.fs000066400000000000000000000425421502617301100270540ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open System open System.Collections.Generic open System.Collections.Immutable open System.IO open System.Reflection open System.Threading open Microsoft.CodeAnalysis open Microsoft.CodeAnalysis.CodeActions open Microsoft.CodeAnalysis.CodeRefactorings open Microsoft.CodeAnalysis.CodeFixes open Microsoft.CodeAnalysis.Text open Ionide.LanguageServerProtocol.Server open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer.Logging open CSharpLanguageServer.Conversions open CSharpLanguageServer.Types open CSharpLanguageServer.State type CSharpCodeActionResolutionData = { TextDocumentUri: string Range: Range } [] module CodeAction = let private logger = LogProvider.getLoggerByName "CodeAction" let private instantiateRoslynProviders<'ProviderType> (isValidProvider: Type -> bool) = let assemblies = [ "Microsoft.CodeAnalysis.Features" "Microsoft.CodeAnalysis.CSharp.Features" "Microsoft.CodeAnalysis.Workspaces" ] |> Seq.map Assembly.Load |> Array.ofSeq let validType (t: Type) = (not (t.GetTypeInfo().IsInterface)) && (not (t.GetTypeInfo().IsAbstract)) && (not (t.GetTypeInfo().ContainsGenericParameters)) let types = assemblies |> Seq.collect (fun a -> a.GetTypes()) |> Seq.filter validType |> Seq.toArray let isProviderType (t: Type) = t.IsAssignableTo(typeof<'ProviderType>) let hasParameterlessConstructor (t: Type) = t.GetConstructor(Array.empty) |> isNull |> not types |> Seq.filter isProviderType |> Seq.filter hasParameterlessConstructor |> Seq.filter isValidProvider |> Seq.map Activator.CreateInstance |> Seq.filter (fun i -> i <> null) |> Seq.map (fun i -> i :?> 'ProviderType) |> Seq.toArray let private refactoringProviderInstances = instantiateRoslynProviders (fun t -> ((string t) <> "Microsoft.CodeAnalysis.ChangeSignature.ChangeSignatureCodeRefactoringProvider")) let private codeFixProviderInstances = instantiateRoslynProviders (fun _ -> true) // TODO: refactor it. I think a long function in functional language is hard to read :) let private getRoslynCodeActions (doc: Document) (textSpan: TextSpan) (ct: CancellationToken) : Async = async { let roslynCodeActions = List() let addCodeAction = Action(roslynCodeActions.Add) let codeActionContext = CodeRefactoringContext(doc, textSpan, addCodeAction, ct) for refactoringProvider in refactoringProviderInstances do try do! refactoringProvider.ComputeRefactoringsAsync(codeActionContext) |> Async.AwaitTask with ex -> logger.error ( Log.setMessage "cannot compute refactorings for {provider}" >> Log.addContext "provider" (string refactoringProvider) >> Log.addException ex ) // register code fixes let! semanticModel = doc.GetSemanticModelAsync(ct) |> Async.AwaitTask let isDiagnosticsOnTextSpan (diag: Microsoft.CodeAnalysis.Diagnostic) = diag.Location.SourceSpan.IntersectsWith(textSpan) let relatedDiagnostics = semanticModel.GetDiagnostics(cancellationToken=ct) |> Seq.filter isDiagnosticsOnTextSpan |> List.ofSeq let diagnosticsBySpan = relatedDiagnostics |> Seq.groupBy (fun d -> d.Location.SourceSpan) for diagnosticSpan, diagnosticsWithSameSpan in diagnosticsBySpan do let addCodeFix = Action>( fun ca _ -> roslynCodeActions.Add(ca)) for codeFixProvider in codeFixProviderInstances do let refactoringProviderOK (diag: Microsoft.CodeAnalysis.Diagnostic) = let translatedDiagId diagId = match diagId with | "CS8019" -> "RemoveUnnecessaryImportsFixable" | _ -> "" codeFixProvider.FixableDiagnosticIds.Contains(diag.Id) || codeFixProvider.FixableDiagnosticIds.Contains(translatedDiagId diag.Id) let fixableDiagnostics = diagnosticsWithSameSpan |> Seq.filter refactoringProviderOK if not (Seq.isEmpty fixableDiagnostics) then let codeFixContext = CodeFixContext(doc, diagnosticSpan, fixableDiagnostics.ToImmutableArray(), addCodeFix, ct) try do! codeFixProvider.RegisterCodeFixesAsync(codeFixContext) |> Async.AwaitTask with ex -> logger.error ( Log.setMessage "error in RegisterCodeFixesAsync()" >> Log.addException ex ) let unwrapRoslynCodeAction (ca: Microsoft.CodeAnalysis.CodeActions.CodeAction) = let nestedCAProp = ca.GetType().GetProperty("NestedCodeActions", BindingFlags.Instance|||BindingFlags.NonPublic) if not (isNull nestedCAProp) then let nestedCAs = nestedCAProp.GetValue(ca, null) :?> ImmutableArray match nestedCAs.Length with | 0 -> [ca].ToImmutableArray() | _ -> nestedCAs else [ca].ToImmutableArray() return roslynCodeActions |> Seq.collect unwrapRoslynCodeAction |> List.ofSeq } let asyncMaybeOnException op = async { try let! value = op () return Some value with ex -> logger.warn ( Log.setMessage "Error in asyncMaybeOnException" >> Log.addException ex ) return None } let lspCodeActionDetailsFromRoslynCA ca = let typeName = ca.GetType() |> string if typeName.Contains("CodeAnalysis.AddImport") then Some CodeActionKind.QuickFix, Some true else None, None let roslynCodeActionToUnresolvedLspCodeAction (ca: CodeActions.CodeAction): CodeAction = let caKind, caIsPreferred = lspCodeActionDetailsFromRoslynCA ca { Title = ca.Title Kind = caKind Diagnostics = None Edit = None Command = None Data = None IsPreferred = caIsPreferred Disabled = None } let lspDocChangesFromSolutionDiff originalSolution (updatedSolution: Solution) (tryGetDocVersionByUri: string -> int option) (originatingDoc: Document) (ct: CancellationToken) : Async = async { // make a list of changes let solutionProjectChanges = updatedSolution.GetChanges(originalSolution).GetProjectChanges() let docTextEdits = List() let addedDocs = solutionProjectChanges |> Seq.collect (fun pc -> pc.GetAddedDocuments()) for docId in addedDocs do let newDoc = updatedSolution.GetDocument(docId) let! newDocText = newDoc.GetTextAsync(ct) |> Async.AwaitTask let edit: TextEdit = { Range = { Start = { Line=0u; Character=0u }; End = { Line=0u; Character=0u } } NewText = newDocText.ToString() } let newDocFilePathMaybe = if String.IsNullOrWhiteSpace(newDoc.FilePath) || (not <| Path.IsPathRooted(newDoc.FilePath)) then if String.IsNullOrWhiteSpace(originatingDoc.FilePath) then None else let directory = Path.GetDirectoryName(originatingDoc.FilePath) Path.Combine(directory, newDoc.Name) |> Some else Some newDoc.FilePath match newDocFilePathMaybe with | Some newDocFilePath -> let textEditDocument = { Uri = newDocFilePath |> Path.toUri Version = newDocFilePath |> Path.toUri |> tryGetDocVersionByUri } docTextEdits.Add({ TextDocument = textEditDocument; Edits = [| U2.C1 edit |] }) | None -> () let changedDocs = solutionProjectChanges |> Seq.collect (fun pc -> pc.GetChangedDocuments()) for docId in changedDocs do let originalDoc = originalSolution.GetDocument(docId) let! originalDocText = originalDoc.GetTextAsync(ct) |> Async.AwaitTask let updatedDoc = updatedSolution.GetDocument(docId) let! docChanges = updatedDoc.GetTextChangesAsync(originalDoc, ct) |> Async.AwaitTask let diffEdits: U2 array = docChanges |> Seq.sortBy (fun c -> c.Span.Start) |> Seq.map (TextEdit.fromTextChange originalDocText.Lines) |> Seq.map U2.C1 |> Array.ofSeq let textEditDocument = { Uri = originalDoc.FilePath |> Path.toUri Version = originalDoc.FilePath |> Path.toUri |> tryGetDocVersionByUri } docTextEdits.Add({ TextDocument = textEditDocument; Edits = diffEdits }) return docTextEdits |> List.ofSeq } let roslynCodeActionToResolvedLspCodeAction originalSolution tryGetDocVersionByUri (originatingDoc: Document) (ct: CancellationToken) (ca: CodeActions.CodeAction) : Async = async { let! maybeOps = asyncMaybeOnException (fun () -> ca.GetOperationsAsync(ct) |> Async.AwaitTask) match maybeOps with | None -> return None | Some ops -> let op = ops |> Seq.map (fun o -> o :?> ApplyChangesOperation) |> Seq.head let! docTextEdit = lspDocChangesFromSolutionDiff originalSolution op.ChangedSolution tryGetDocVersionByUri originatingDoc ct let edit: WorkspaceEdit = { Changes = None DocumentChanges = docTextEdit |> Seq.map U4.C1 |> Array.ofSeq |> Some ChangeAnnotations = None } let caKind, caIsPreferred = lspCodeActionDetailsFromRoslynCA ca return Some { Title = ca.Title Kind = caKind Diagnostics = None Edit = Some edit Command = None Data = None IsPreferred = caIsPreferred Disabled = None } } let private dynamicRegistration (clientCapabilities: ClientCapabilities) = clientCapabilities.TextDocument |> Option.bind (fun x -> x.CodeAction) |> Option.bind (fun x -> x.DynamicRegistration) |> Option.defaultValue false let private literalSupport (clientCapabilities: ClientCapabilities) = clientCapabilities.TextDocument |> Option.bind (fun x -> x.CodeAction) |> Option.bind (fun x -> x.CodeActionLiteralSupport) let provider (clientCapabilities: ClientCapabilities) : U2 option = match dynamicRegistration clientCapabilities, literalSupport clientCapabilities with | true, _ -> None | false, _ -> // TODO: Server can only return CodeActionOptions if literalSupport is not None { CodeActionKinds = None ResolveProvider = Some true WorkDoneProgress = None } |> U2.C2 |> Some let registration (clientCapabilities: ClientCapabilities) : Registration option = match dynamicRegistration clientCapabilities with | false -> None | true -> let registerOptions: CodeActionRegistrationOptions = { CodeActionKinds = None ResolveProvider = Some true WorkDoneProgress = None DocumentSelector = Some defaultDocumentSelector } Some { Id = Guid.NewGuid().ToString() Method = "textDocument/codeAction" RegisterOptions = registerOptions |> serialize |> Some } let handle (context: ServerRequestContext) (p: CodeActionParams) : AsyncLspResult = async { match context.GetDocument p.TextDocument.Uri with | None -> return None |> LspResult.success | Some doc -> let! ct = Async.CancellationToken let! docText = doc.GetTextAsync(ct) |> Async.AwaitTask let textSpan = Range.toTextSpan docText.Lines p.Range let! roslynCodeActions = getRoslynCodeActions doc textSpan ct let clientSupportsCodeActionEditResolveWithEditAndData = context.ClientCapabilities.TextDocument |> Option.bind (fun x -> x.CodeAction) |> Option.bind (fun x -> x.ResolveSupport) |> Option.map (fun resolveSupport -> resolveSupport.Properties |> Array.contains "edit") |> Option.defaultValue false let! lspCodeActions = match clientSupportsCodeActionEditResolveWithEditAndData with | true -> async { let toUnresolvedLspCodeAction (ca: Microsoft.CodeAnalysis.CodeActions.CodeAction) = let resolutionData: CSharpCodeActionResolutionData = { TextDocumentUri = p.TextDocument.Uri Range = p.Range } (* logger.trace ( Log.setMessage "codeaction data: {data}" >> Log.addContextDestructured "data" resolutionData ) *) let lspCa = roslynCodeActionToUnresolvedLspCodeAction ca { lspCa with Data = resolutionData |> serialize |> Some } return roslynCodeActions |> Seq.map toUnresolvedLspCodeAction |> Array.ofSeq } | false -> async { let results = List() for ca in roslynCodeActions do let! maybeLspCa = roslynCodeActionToResolvedLspCodeAction doc.Project.Solution context.GetDocumentVersion doc ct ca if maybeLspCa.IsSome then results.Add(maybeLspCa.Value) return results |> Array.ofSeq } return lspCodeActions |> Seq.sortByDescending (fun ca -> ca.IsPreferred) |> Seq.map U2.C2 |> Array.ofSeq |> Some |> LspResult.success } let resolve (context: ServerRequestContext) (p: CodeAction) : AsyncLspResult = async { let resolutionData = p.Data |> Option.map deserialize match context.GetDocument resolutionData.Value.TextDocumentUri with | None -> return raise (Exception(sprintf "no document for uri %s" resolutionData.Value.TextDocumentUri)) | Some doc -> let! ct = Async.CancellationToken let! docText = doc.GetTextAsync(ct) |> Async.AwaitTask let textSpan = Range.toTextSpan docText.Lines resolutionData.Value.Range let! roslynCodeActions = getRoslynCodeActions doc textSpan ct let selectedCodeAction = roslynCodeActions |> Seq.tryFind (fun ca -> ca.Title = p.Title) let toResolvedLspCodeAction = roslynCodeActionToResolvedLspCodeAction doc.Project.Solution context.GetDocumentVersion doc ct let! lspCodeAction = match selectedCodeAction with | Some ca -> async { let! resolvedCA = toResolvedLspCodeAction ca if resolvedCA.IsNone then logger.error ( Log.setMessage "handleCodeActionResolve: could not resolve {action} - null" >> Log.addContext "action" (string ca) ) return resolvedCA.Value } | None -> raise (Exception("no CodeAction resolved")) return lspCodeAction |> LspResult.success } csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/CodeLens.fs000066400000000000000000000156261502617301100265430ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open System open Microsoft.CodeAnalysis open Microsoft.CodeAnalysis.CSharp open Microsoft.CodeAnalysis.CSharp.Syntax open Microsoft.CodeAnalysis.Text open Ionide.LanguageServerProtocol.Server open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer.State open CSharpLanguageServer.Conversions open CSharpLanguageServer.Types type private DocumentSymbolCollectorForCodeLens(semanticModel: SemanticModel) = inherit CSharpSyntaxWalker(SyntaxWalkerDepth.Token) let mutable collectedSymbols = [] let collect (node: SyntaxNode) (nameSpan: TextSpan) = let symbol = semanticModel.GetDeclaredSymbol(node) collectedSymbols <- (symbol, nameSpan) :: collectedSymbols member __.GetSymbols() = collectedSymbols |> List.rev |> Array.ofList override __.VisitEnumDeclaration(node) = collect node node.Identifier.Span base.VisitEnumDeclaration(node) override __.VisitEnumMemberDeclaration(node) = collect node node.Identifier.Span override __.VisitClassDeclaration(node) = collect node node.Identifier.Span base.VisitClassDeclaration(node) override __.VisitRecordDeclaration(node) = collect node node.Identifier.Span base.VisitRecordDeclaration(node) override __.VisitStructDeclaration(node) = collect node node.Identifier.Span base.VisitStructDeclaration(node) override __.VisitInterfaceDeclaration(node) = collect node node.Identifier.Span base.VisitInterfaceDeclaration(node) override __.VisitDelegateDeclaration(node) = collect node node.Identifier.Span override __.VisitConstructorDeclaration(node) = collect node node.Identifier.Span override __.VisitDestructorDeclaration(node) = collect node node.Identifier.Span override __.VisitOperatorDeclaration(node) = collect node node.OperatorToken.Span override __.VisitIndexerDeclaration(node) = collect node node.ThisKeyword.Span override __.VisitConversionOperatorDeclaration(node) = collect node node.Type.Span override __.VisitMethodDeclaration(node) = collect node node.Identifier.Span override __.VisitPropertyDeclaration(node) = collect node node.Identifier.Span override __.VisitVariableDeclarator(node) = let grandparent = node.Parent |> Option.ofObj |> Option.bind (fun node -> node.Parent |> Option.ofObj) // Only show field variables and ignore local variables if grandparent.IsSome && grandparent.Value :? FieldDeclarationSyntax then collect node node.Identifier.Span override __.VisitEventDeclaration(node) = collect node node.Identifier.Span [] module CodeLens = type CodeLensData = { DocumentUri: string Position: Position } static member Default = { DocumentUri = "" Position = { Line = 0u; Character = 0u } } let private dynamicRegistration (clientCapabilities: ClientCapabilities) = clientCapabilities.TextDocument |> Option.bind (fun x -> x.CodeLens) |> Option.bind (fun x -> x.DynamicRegistration) |> Option.defaultValue false let provider (clientCapabilities: ClientCapabilities) : CodeLensOptions option = match dynamicRegistration clientCapabilities with | true -> None | false -> Some { ResolveProvider = Some true WorkDoneProgress = None } let registration (clientCapabilities: ClientCapabilities) : Registration option = match dynamicRegistration clientCapabilities with | false -> None | true -> let registerOptions: CodeLensRegistrationOptions = { ResolveProvider = Some true WorkDoneProgress = None DocumentSelector = Some defaultDocumentSelector } Some { Id = Guid.NewGuid().ToString() Method = "textDocument/codeLens" RegisterOptions = registerOptions |> serialize |> Some } let handle (context: ServerRequestContext) (p: CodeLensParams): AsyncLspResult = async { let docMaybe = context.GetDocument p.TextDocument.Uri match docMaybe with | None -> return None |> LspResult.success | Some doc -> let! ct = Async.CancellationToken let! semanticModel = doc.GetSemanticModelAsync(ct) |> Async.AwaitTask let! syntaxTree = doc.GetSyntaxTreeAsync(ct) |> Async.AwaitTask let! docText = doc.GetTextAsync(ct) |> Async.AwaitTask let collector = DocumentSymbolCollectorForCodeLens(semanticModel) let! root = syntaxTree.GetRootAsync(ct) |> Async.AwaitTask collector.Visit(root) let makeCodeLens (_symbol: ISymbol, nameSpan: TextSpan) : CodeLens = let start = nameSpan.Start |> docText.Lines.GetLinePosition let lensData: CodeLensData = { DocumentUri = p.TextDocument.Uri Position = start |> Position.fromLinePosition } { Range = nameSpan |> Range.fromTextSpan docText.Lines Command = None Data = lensData |> serialize |> Some } let codeLens = collector.GetSymbols() |> Seq.map makeCodeLens return codeLens |> Array.ofSeq |> Some |> LspResult.success } let resolve (context: ServerRequestContext) (p: CodeLens) : AsyncLspResult = async { let lensData = p.Data |> Option.map (fun t -> t.ToObject()) |> Option.defaultValue CodeLensData.Default match! context.FindSymbol lensData.DocumentUri lensData.Position with | None -> return p |> LspResult.success | Some symbol -> let! locations = context.FindReferences symbol false // FIXME: refNum is wrong. There are lots of false positive even if we distinct locations by // (l.SourceTree.FilePath, l.SourceSpan) let refNum = locations |> Seq.distinctBy (fun l -> (l.GetMappedLineSpan().Path, l.SourceSpan)) |> Seq.length let title = sprintf "%d Reference(s)" refNum let arg: ReferenceParams = { TextDocument = { Uri = lensData.DocumentUri } Position = lensData.Position WorkDoneToken = None PartialResultToken = None Context = { IncludeDeclaration = true } } let command = { Title = title Command = "textDocument/references" Arguments = Some [| arg |> serialize |] } return { p with Command = Some command } |> LspResult.success } csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/Color.fs000066400000000000000000000013301502617301100261100ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer.State [] module Color = let provider (clientCapabilities: ClientCapabilities) = None let registration (clientCapabilities: ClientCapabilities) : Registration option = None let handle (context: ServerRequestContext) (p: DocumentColorParams) : AsyncLspResult = LspResult.notImplemented |> async.Return let present (context: ServerRequestContext) (p: ColorPresentationParams) : AsyncLspResult = LspResult.notImplemented |> async.Return csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/Completion.fs000066400000000000000000000233071502617301100271530ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open System open System.Reflection open Ionide.LanguageServerProtocol.Server open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer open CSharpLanguageServer.State open CSharpLanguageServer.Util open CSharpLanguageServer.Conversions open CSharpLanguageServer.Types open CSharpLanguageServer.Logging [] module Completion = let private _logger = LogProvider.getLoggerByName "Completion" let emptyRoslynOptionSet: Microsoft.CodeAnalysis.Options.OptionSet = let osType = typeof let osEmptyOptionSetField = osType.GetField("Empty", BindingFlags.Static|||BindingFlags.NonPublic) osEmptyOptionSetField.GetValue(null) :?> Microsoft.CodeAnalysis.Options.OptionSet /// the type reflects on internal class Microsoft.CodeAnalysis.Completion.CompletionOptions /// see https://github.com/dotnet/roslyn/blob/main/src/Features/Core/Portable/Completion/CompletionOptions.cs type RoslynCompletionOptions = { Object: obj CompletionOptionsType: Type } with member rco.WithBool(optionName: string, optionValue: bool) = let cloneCompletionOptionsMI = rco.CompletionOptionsType.GetMethod("$") let updatedCompletionOptions = cloneCompletionOptionsMI.Invoke(rco.Object, null) let newCo = rco.CompletionOptionsType.GetProperty(optionName) newCo.SetValue(updatedCompletionOptions, optionValue) { rco with Object = updatedCompletionOptions } static member Default() = let featuresAssembly = Assembly.Load("Microsoft.CodeAnalysis.Features") let coType = featuresAssembly.GetType("Microsoft.CodeAnalysis.Completion.CompletionOptions") let defaultCo: obj = coType.GetField("Default").GetValue() { Object = defaultCo; CompletionOptionsType = coType } type RoslynCompletionServiceWrapper(service: Microsoft.CodeAnalysis.Completion.CompletionService) = member __.GetCompletionsAsync(doc, position, completionOptions, completionTrigger, ct) : Async = let completionServiceType = service.GetType() let getCompletionsAsync7MI = completionServiceType.GetMethods(BindingFlags.Instance|||BindingFlags.NonPublic) |> Seq.filter (fun mi -> mi.Name = "GetCompletionsAsync" && mi.GetParameters().Length = 7) |> Seq.head let parameters: obj array = [| doc; position; completionOptions.Object; emptyRoslynOptionSet; completionTrigger; null; ct |] let result = getCompletionsAsync7MI.Invoke(service, parameters) (result :?> System.Threading.Tasks.Task) |> Async.AwaitTask member __.ShouldTriggerCompletion(sourceText, position, completionTrigger) = service.ShouldTriggerCompletion(sourceText, position, completionTrigger) let private dynamicRegistration (clientCapabilities: ClientCapabilities) = clientCapabilities.TextDocument |> Option.bind (fun x -> x.Completion) |> Option.bind (fun x -> x.DynamicRegistration) |> Option.defaultValue false let provider (clientCapabilities: ClientCapabilities) : CompletionOptions option = match dynamicRegistration clientCapabilities with | true -> None | false -> Some { ResolveProvider = None TriggerCharacters = Some ([| "."; "'"; |]) AllCommitCharacters = None WorkDoneProgress = None CompletionItem = None } let registration (clientCapabilities: ClientCapabilities) : Registration option = match dynamicRegistration clientCapabilities with | false -> None | true -> let registerOptions: CompletionRegistrationOptions = { DocumentSelector = Some defaultDocumentSelector ResolveProvider = Some true TriggerCharacters = Some ([| "."; "'"; |]) AllCommitCharacters = None CompletionItem = None WorkDoneProgress = None } Some { Id = Guid.NewGuid().ToString() Method = "textDocument/completion" RegisterOptions = registerOptions |> serialize |> Some } let private roslynTagToLspCompletion tag = match tag with | "Class" -> CompletionItemKind.Class | "Delegate" -> CompletionItemKind.Function | "Enum" -> CompletionItemKind.Enum | "EnumMember" -> CompletionItemKind.EnumMember | "Interface" -> CompletionItemKind.Interface | "Struct" -> CompletionItemKind.Struct | "Local" -> CompletionItemKind.Variable | "Parameter" -> CompletionItemKind.Variable | "RangeVariable" -> CompletionItemKind.Variable | "Const" -> CompletionItemKind.Constant | "Event" -> CompletionItemKind.Event | "Field" -> CompletionItemKind.Field | "Method" -> CompletionItemKind.Method | "Property" -> CompletionItemKind.Property | "Label" -> CompletionItemKind.Unit | "Keyword" -> CompletionItemKind.Keyword | "Namespace" -> CompletionItemKind.Module | _ -> CompletionItemKind.Property // TODO: Add parameters to label so that we can distinguish override versions? // TODO: Change parameters to snippets like clangd let private makeLspCompletionItem (item: Microsoft.CodeAnalysis.Completion.CompletionItem) (cacheKey: uint64) = { Ionide.LanguageServerProtocol.Types.CompletionItem.Create(item.DisplayText) with Kind = item.Tags |> Seq.tryHead |> Option.map roslynTagToLspCompletion SortText = item.SortText |> Option.ofString FilterText = item.FilterText |> Option.ofString Detail = item.InlineDescription |> Option.ofString TextEditText = item.DisplayTextPrefix |> Option.ofObj InsertTextFormat = Some InsertTextFormat.PlainText Data = cacheKey |> serialize |> Some } let private cache = new LruCache<(Microsoft.CodeAnalysis.Document * Microsoft.CodeAnalysis.Completion.CompletionList)>(5) let handle (context: ServerRequestContext) (p: CompletionParams) : Async option>> = async { match context.GetDocument p.TextDocument.Uri with | None -> return None |> LspResult.success | Some doc -> let! ct = Async.CancellationToken let! sourceText = doc.GetTextAsync(ct) |> Async.AwaitTask let position = Position.toRoslynPosition sourceText.Lines p.Position let completionService = Microsoft.CodeAnalysis.Completion.CompletionService.GetService(doc) |> RoslynCompletionServiceWrapper let completionOptions = RoslynCompletionOptions.Default() |> _.WithBool("ShowItemsFromUnimportedNamespaces", false) |> _.WithBool("ShowNameSuggestions", false) let completionTrigger = CompletionContext.toCompletionTrigger p.Context let shouldTriggerCompletion = p.Context |> Option.exists (fun x -> x.TriggerKind = CompletionTriggerKind.TriggerForIncompleteCompletions) || completionService.ShouldTriggerCompletion(sourceText, position, completionTrigger) let! completions = if shouldTriggerCompletion then completionService.GetCompletionsAsync(doc, position, completionOptions, completionTrigger, ct) |> Async.map Option.ofObj else async.Return None return completions |> Option.map (fun completions -> let key = cache.add((doc, completions)) let items = completions.ItemsList |> Seq.map (flip makeLspCompletionItem key) |> Array.ofSeq { IsIncomplete = true Items = items ItemDefaults = None }) |> Option.map U2.C2 |> LspResult.success } let resolve (_context: ServerRequestContext) (item: CompletionItem) : AsyncLspResult = async { match item.Data |> Option.bind deserialize |> Option.bind cache.get |> Option.bind (fun (doc, cachedItems) -> cachedItems.ItemsList |> Seq.tryFind (fun x -> x.DisplayText = item.Label && (item.SortText.IsNone || x.SortText = item.SortText.Value)) |> Option.map (fun x -> (doc, x))) with | Some (doc, cachedItem) -> let completionService = Microsoft.CodeAnalysis.Completion.CompletionService.GetService(doc) let! ct = Async.CancellationToken let! description = completionService.GetDescriptionAsync(doc, cachedItem, ct) |> Async.AwaitTask |> Async.map Option.ofObj // TODO: make the doc as a markdown string instead of a plain text let itemDocumentation = description |> Option.map Documentation.fromCompletionDescription return { item with Documentation = itemDocumentation |> Option.map U2.C2 } |> LspResult.success | None -> return item |> LspResult.success } csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/Declaration.fs000066400000000000000000000011051502617301100272570ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer.State [] module Declaration = let provider (_cc: ClientCapabilities) : bool option = None let registration (_cc: ClientCapabilities) : Registration option = None let handle (_context: ServerRequestContext) (_p: DeclarationParams) : AsyncLspResult option> = LspResult.notImplemented option> |> async.Return csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/Definition.fs000066400000000000000000000036011502617301100271250ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open System open Ionide.LanguageServerProtocol.Server open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer.State open CSharpLanguageServer.Types [] module Definition = let private dynamicRegistration (clientCapabilities: ClientCapabilities) = clientCapabilities.TextDocument |> Option.bind (fun x -> x.Definition) |> Option.bind (fun x -> x.DynamicRegistration) |> Option.defaultValue false let provider (clientCapabilities: ClientCapabilities) : U2 option = match dynamicRegistration clientCapabilities with | true -> None | false -> Some (U2.C1 true) let registration (clientCapabilities: ClientCapabilities) : Registration option = match dynamicRegistration clientCapabilities with | false -> None | true -> let registerOptions: DefinitionRegistrationOptions = { DocumentSelector = Some defaultDocumentSelector WorkDoneProgress = None } Some { Id = Guid.NewGuid().ToString() Method = "textDocument/definition" RegisterOptions = registerOptions |> serialize |> Some } let handle (context: ServerRequestContext) (p: DefinitionParams) : Async option>> = 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) return locations |> Array.ofList |> Definition.C2 |> U2.C1 |> Some |> LspResult.success } csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/Diagnostic.fs000066400000000000000000000137231502617301100271270ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open System open FSharp.Control open Ionide.LanguageServerProtocol.Server open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer.Conversions open CSharpLanguageServer.State open CSharpLanguageServer.Types open CSharpLanguageServer.Logging [] module Diagnostic = let private logger = LogProvider.getLoggerByName "Diagnostic" let private dynamicRegistration (clientCapabilities: ClientCapabilities) = clientCapabilities.TextDocument |> Option.bind (fun x -> x.Diagnostic) |> Option.bind (fun x -> x.DynamicRegistration) |> Option.defaultValue false let private registrationOptions: DiagnosticRegistrationOptions = { DocumentSelector = Some defaultDocumentSelector WorkDoneProgress = None Identifier = None InterFileDependencies = false WorkspaceDiagnostics = true Id = None } let provider (clientCapabilities: ClientCapabilities): U2 option = match dynamicRegistration clientCapabilities with | true -> None | false -> Some (U2.C2 registrationOptions) let registration (clientCapabilities: ClientCapabilities) : Registration option = match dynamicRegistration clientCapabilities with | false -> None | true -> let registration = { Id = Guid.NewGuid().ToString() Method = "textDocument/diagnostic" RegisterOptions = registrationOptions |> serialize |> Some } Some registration let handle (context: ServerRequestContext) (p: DocumentDiagnosticParams) : AsyncLspResult = async { let emptyReport: RelatedFullDocumentDiagnosticReport = { Kind = "full" ResultId = None Items = [| |] RelatedDocuments = None } match context.GetDocument p.TextDocument.Uri with | None -> return emptyReport |> U2.C1 |> LspResult.success | Some doc -> let! ct = Async.CancellationToken let! semanticModelMaybe = doc.GetSemanticModelAsync(ct) |> Async.AwaitTask match semanticModelMaybe |> Option.ofObj with | Some semanticModel -> let diagnostics = semanticModel.GetDiagnostics() |> Seq.map Diagnostic.fromRoslynDiagnostic |> Array.ofSeq return { emptyReport with Items = diagnostics } |> U2.C1 |> LspResult.success | None -> return emptyReport |> U2.C1 |> LspResult.success } let private getWorkspaceDiagnosticReports (solution: Microsoft.CodeAnalysis.Solution) : AsyncSeq = asyncSeq { for project in solution.Projects do let! compilation = project.GetCompilationAsync() |> Async.AwaitTask match compilation |> Option.ofObj with | None -> () | Some compilation -> let diagnostics = compilation.GetDiagnostics() let diagnosticsByDocument = diagnostics |> Seq.groupBy (fun d -> d.Location.SourceTree.FilePath |> Path.toUri) for (uri, docDiagnostics) in diagnosticsByDocument do let fullDocumentReport: WorkspaceFullDocumentDiagnosticReport = { Kind = "full" ResultId = None Uri = uri Items = docDiagnostics |> Seq.map Diagnostic.fromRoslynDiagnostic |> Array.ofSeq Version = None } let documentReport: WorkspaceDocumentDiagnosticReport = U2.C1 fullDocumentReport yield documentReport } let handleWorkspaceDiagnostic (context: ServerRequestContext) (p: WorkspaceDiagnosticParams) : AsyncLspResult = async { let emptyWorkspaceDiagnosticReport: WorkspaceDiagnosticReport = { Items = Array.empty } match context.State.Solution, p.PartialResultToken with | None, _ -> return emptyWorkspaceDiagnosticReport |> LspResult.success | Some solution, None -> let! diagnosticReports = getWorkspaceDiagnosticReports solution |> AsyncSeq.toArrayAsync let workspaceDiagnosticReport: WorkspaceDiagnosticReport = { Items = diagnosticReports } return workspaceDiagnosticReport |> LspResult.success | Some solution, Some partialResultToken -> let sendWorkspaceDiagnosticReport (documentReport, index) = async { let progressParams = if index = 0 then let report: WorkspaceDiagnosticReport = { Items = [| documentReport |] } { Token = partialResultToken; Value = serialize report } else let reportPartialResult: WorkspaceDiagnosticReportPartialResult = { Items = [| documentReport |] } { Token = partialResultToken; Value = serialize reportPartialResult } let lspClient = context.State.LspClient.Value do! lspClient.Progress(progressParams) } do! AsyncSeq.ofSeq (Seq.initInfinite id) |> AsyncSeq.zip (getWorkspaceDiagnosticReports solution) |> AsyncSeq.iterAsync sendWorkspaceDiagnosticReport return emptyWorkspaceDiagnosticReport |> LspResult.success } csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/DocumentFormatting.fs000066400000000000000000000037741502617301100306610ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open System open Microsoft.CodeAnalysis.Formatting open Ionide.LanguageServerProtocol.Server open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer open CSharpLanguageServer.State open CSharpLanguageServer.Types [] module DocumentFormatting = let private dynamicRegistration (clientCapabilities: ClientCapabilities) = clientCapabilities.TextDocument |> Option.bind (fun x -> x.Formatting) |> Option.bind (fun x -> x.DynamicRegistration) |> Option.defaultValue false let provider (clientCapabilities: ClientCapabilities) : U2 option = match dynamicRegistration clientCapabilities with | true -> None | false -> Some (U2.C1 true) let registration (clientCapabilities: ClientCapabilities) : Registration option = match dynamicRegistration clientCapabilities with | false -> None | true -> let registerOptions: DocumentFormattingRegistrationOptions = { DocumentSelector = Some defaultDocumentSelector WorkDoneProgress = None } Some { Id = Guid.NewGuid().ToString() Method = "textDocument/formatting" RegisterOptions = registerOptions |> serialize |> Some } let handle (context: ServerRequestContext) (p: DocumentFormattingParams) : AsyncLspResult = async { 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! newDoc = Formatter.FormatAsync(doc, options, cancellationToken=ct) |> Async.AwaitTask let! textEdits = FormatUtil.getChanges newDoc doc return textEdits |> Some |> LspResult.success } csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/DocumentHighlight.fs000066400000000000000000000067601502617301100304540ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open System open System.Collections.Immutable open Microsoft.CodeAnalysis open Microsoft.CodeAnalysis.FindSymbols open Ionide.LanguageServerProtocol.Server open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer.Types open CSharpLanguageServer.State open CSharpLanguageServer.Conversions [] module DocumentHighlight = let private dynamicRegistration (clientCapabilities: ClientCapabilities) = clientCapabilities.TextDocument |> Option.bind (fun x -> x.DocumentHighlight) |> Option.bind (fun x -> x.DynamicRegistration) |> Option.defaultValue false let provider (clientCapabilities: ClientCapabilities) : U2 option = match dynamicRegistration clientCapabilities with | true -> None | false -> Some (U2.C1 true) let registration (clientCapabilities: ClientCapabilities) : Registration option = match dynamicRegistration clientCapabilities with | false -> None | true -> let registerOptions: DocumentHighlightRegistrationOptions = { DocumentSelector = Some defaultDocumentSelector WorkDoneProgress = None } Some { Id = Guid.NewGuid().ToString() Method = "textDocument/documentHighlight" RegisterOptions = registerOptions |> serialize |> Some } let private shouldHighlight (symbol: ISymbol) = match symbol with | :? INamespaceSymbol -> false | _ -> true let handle (context: ServerRequestContext) (p: DocumentHighlightParams) : AsyncLspResult = async { let! ct = Async.CancellationToken let filePath = Uri.toPath p.TextDocument.Uri // We only need to find references in the file (not the whole workspace), so we don't use // context.FindSymbol & context.FindReferences here. let getHighlights (symbol: ISymbol) (doc: Document) = async { let docSet = ImmutableHashSet.Create(doc) let! refs = SymbolFinder.FindReferencesAsync(symbol, doc.Project.Solution, docSet, cancellationToken=ct) |> Async.AwaitTask let! def = SymbolFinder.FindSourceDefinitionAsync(symbol, doc.Project.Solution, cancellationToken=ct) |> Async.AwaitTask let locations = refs |> Seq.collect (fun r -> r.Locations) |> Seq.map (fun rl -> rl.Location) |> Seq.filter (fun l -> l.IsInSource && l.GetMappedLineSpan().Path = filePath) |> Seq.append (def |> Option.ofObj |> Option.toList |> Seq.collect (fun sym -> sym.Locations)) return locations |> Seq.map Location.fromRoslynLocation |> Seq.filter _.IsSome |> Seq.map _.Value |> 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) -> match Option.ofObj symbol with | Some symbol when shouldHighlight symbol -> let! highlights = getHighlights symbol doc return highlights |> Seq.toArray |> Some |> LspResult.success | _ -> return None |> LspResult.success } csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/DocumentLink.fs000066400000000000000000000013471502617301100274360ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer.State [] module DocumentLink = let provider (clientCapabilities: ClientCapabilities) : DocumentLinkOptions option = None let registration (clientCapabilities: ClientCapabilities) : Registration option = None let handle (context: ServerRequestContext) (p: DocumentLinkParams) : AsyncLspResult = LspResult.notImplemented |> async.Return let resolve (context: ServerRequestContext) (p: DocumentLink) : AsyncLspResult = LspResult.notImplemented |> async.Return csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/DocumentOnTypeFormatting.fs000066400000000000000000000056741502617301100320210ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open System open Microsoft.CodeAnalysis.Text open Microsoft.CodeAnalysis.Formatting open Ionide.LanguageServerProtocol.Server open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer open CSharpLanguageServer.State open CSharpLanguageServer.Types open CSharpLanguageServer.Conversions [] module DocumentOnTypeFormatting = let private dynamicRegistration (clientCapabilities: ClientCapabilities) = clientCapabilities.TextDocument |> Option.bind (fun x -> x.OnTypeFormatting) |> Option.bind (fun x -> x.DynamicRegistration) |> Option.defaultValue false let provider (clientCapabilities: ClientCapabilities) : DocumentOnTypeFormattingOptions option = match dynamicRegistration clientCapabilities with | true -> None | false -> Some { FirstTriggerCharacter = ";" MoreTriggerCharacter = Some([| "}"; ")" |]) } let registration (clientCapabilities: ClientCapabilities) : Registration option = match dynamicRegistration clientCapabilities with | false -> None | true -> let registerOptions: DocumentOnTypeFormattingRegistrationOptions = { FirstTriggerCharacter = ";" MoreTriggerCharacter = Some([| "}"; ")" |]) DocumentSelector = Some defaultDocumentSelector } Some { Id = Guid.NewGuid().ToString() Method = "textDocument/onTypeFormatting" RegisterOptions = registerOptions |> serialize |> Some } let handle (context: ServerRequestContext) (p: DocumentOnTypeFormattingParams) : AsyncLspResult = async { 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! ct = Async.CancellationToken let! sourceText = doc.GetTextAsync(ct) |> Async.AwaitTask let pos = Position.toRoslynPosition sourceText.Lines p.Position match p.Ch with | ";" | "}" | ")" -> let! root = doc.GetSyntaxRootAsync(ct) |> Async.AwaitTask match FormatUtil.findFormatTarget root pos with | None -> return None |> LspResult.success | Some node -> let! newDoc = Formatter.FormatAsync(doc, TextSpan.FromBounds(node.FullSpan.Start, node.FullSpan.End), options, cancellationToken=ct) |> Async.AwaitTask let! textEdits = FormatUtil.getChanges newDoc doc return textEdits |> Some |> LspResult.success | _ -> return None |> LspResult.success } csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/DocumentRangeFormatting.fs000066400000000000000000000051071502617301100316260ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open System open Microsoft.CodeAnalysis.Formatting open Microsoft.CodeAnalysis.Text open Ionide.LanguageServerProtocol.Server open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer open CSharpLanguageServer.State open CSharpLanguageServer.Conversions open CSharpLanguageServer.Types [] module DocumentRangeFormatting = let private dynamicRegistration (clientCapabilities: ClientCapabilities) = clientCapabilities.TextDocument |> Option.bind (fun x -> x.RangeFormatting) |> Option.bind (fun x -> x.DynamicRegistration) |> Option.defaultValue false let provider (clientCapabilities: ClientCapabilities) : U2 option = match dynamicRegistration clientCapabilities with | true -> None | false -> Some (U2.C1 true) let registration (clientCapabilities: ClientCapabilities) : Registration option = match dynamicRegistration clientCapabilities with | false -> None | true -> let registerOptions: DocumentRangeFormattingRegistrationOptions = { DocumentSelector = Some defaultDocumentSelector WorkDoneProgress = None } Some { Id = Guid.NewGuid().ToString() Method = "textDocument/rangeFormatting" RegisterOptions = registerOptions |> serialize |> Some } let handle (context: ServerRequestContext) (p: DocumentRangeFormattingParams) : AsyncLspResult = async { 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! sourceText = doc.GetTextAsync(ct) |> Async.AwaitTask let startPos = Position.toRoslynPosition sourceText.Lines p.Range.Start let endPos = Position.toRoslynPosition sourceText.Lines p.Range.End let! syntaxTree = doc.GetSyntaxRootAsync(ct) |> Async.AwaitTask let tokenStart = syntaxTree.FindToken(startPos).FullSpan.Start let! newDoc = Formatter.FormatAsync(doc, TextSpan.FromBounds(tokenStart, endPos), options, cancellationToken=ct) |> Async.AwaitTask let! textEdits = FormatUtil.getChanges newDoc doc return textEdits |> Some |> LspResult.success } csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/DocumentSymbol.fs000066400000000000000000000315211502617301100300030ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open System open Microsoft.CodeAnalysis open Microsoft.CodeAnalysis.Text open Microsoft.CodeAnalysis.CSharp open Microsoft.CodeAnalysis.CSharp.Syntax open Ionide.LanguageServerProtocol.Server open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer.State open CSharpLanguageServer.Conversions open CSharpLanguageServer.Types [] module DocumentSymbol = let private formatSymbol (sym: ISymbol) showAttributes (semanticModelMaybe: SemanticModel option) (posMaybe: int option) = match showAttributes, semanticModelMaybe, posMaybe with | true, Some semanticModel, Some pos -> sym.ToMinimalDisplayString(semanticModel, pos) | true, _, _ -> sym.ToDisplayString() | false, _, _ -> sym.Name let private getSymbolNameAndKind (semanticModel: SemanticModel option) (pos: int option) (symbol: ISymbol) = let showAttributes = true match symbol with | :? ILocalSymbol as ls -> (formatSymbol ls showAttributes semanticModel pos, SymbolKind.Variable) | :? IFieldSymbol as fs -> (formatSymbol fs showAttributes semanticModel pos, SymbolKind.Field) | :? IPropertySymbol as ps -> (formatSymbol ps showAttributes semanticModel pos, SymbolKind.Property) | :? IMethodSymbol as ms -> (formatSymbol ms showAttributes semanticModel pos, match ms.MethodKind with | MethodKind.Constructor -> SymbolKind.Constructor | MethodKind.StaticConstructor -> SymbolKind.Constructor | MethodKind.BuiltinOperator -> SymbolKind.Operator | MethodKind.UserDefinedOperator -> SymbolKind.Operator | MethodKind.Conversion -> SymbolKind.Operator | _ -> SymbolKind.Method) | :? ITypeSymbol as ts -> (formatSymbol ts showAttributes semanticModel pos, match ts.TypeKind with | TypeKind.Class -> SymbolKind.Class | TypeKind.Enum -> SymbolKind.Enum | TypeKind.Struct -> SymbolKind.Struct | TypeKind.Interface -> SymbolKind.Interface | TypeKind.Delegate -> SymbolKind.Class | TypeKind.Array -> SymbolKind.Array | TypeKind.TypeParameter -> SymbolKind.TypeParameter | _ -> SymbolKind.Class) | :? IEventSymbol as es -> (formatSymbol es showAttributes semanticModel pos, SymbolKind.Event) | :? INamespaceSymbol as ns -> (formatSymbol ns showAttributes semanticModel pos, SymbolKind.Namespace) | _ -> (symbol.ToString(), SymbolKind.File) let rec private flattenDocumentSymbol (node: DocumentSymbol) = let nodeWithNoChildren = { node with Children = None } let flattenedChildren = match node.Children with | None -> [] | Some xs -> xs |> Seq.map flattenDocumentSymbol |> Seq.concat |> List.ofSeq nodeWithNoChildren :: flattenedChildren type private DocumentSymbolCollector (docText: SourceText, semanticModel: SemanticModel) = inherit CSharpSyntaxWalker(SyntaxWalkerDepth.Token) let mutable symbolStack = [] let push (node: SyntaxNode) (nameSpan: TextSpan) = let symbol = semanticModel.GetDeclaredSymbol(node) let (fullSymbolName, symbolKind) = getSymbolNameAndKind (Some semanticModel) (Some nameSpan.Start) symbol let lspRange = Range.fromTextSpan docText.Lines node.FullSpan let selectionLspRange = Range.fromTextSpan docText.Lines nameSpan let symbolDetail = match symbolKind with | SymbolKind.Class -> None | SymbolKind.Struct -> None | _ -> Some fullSymbolName let displayStyle = SymbolDisplayFormat( typeQualificationStyle = SymbolDisplayTypeQualificationStyle.NameOnly, genericsOptions = SymbolDisplayGenericsOptions.IncludeTypeParameters, memberOptions = (SymbolDisplayMemberOptions.IncludeParameters ||| SymbolDisplayMemberOptions.IncludeExplicitInterface), parameterOptions = (SymbolDisplayParameterOptions.IncludeParamsRefOut ||| SymbolDisplayParameterOptions.IncludeExtensionThis ||| SymbolDisplayParameterOptions.IncludeType ||| SymbolDisplayParameterOptions.IncludeName ||| SymbolDisplayParameterOptions.IncludeDefaultValue), miscellaneousOptions = SymbolDisplayMiscellaneousOptions.UseSpecialTypes) let docSymbol = { Name = SymbolName.fromSymbol displayStyle symbol Detail = symbolDetail Kind = symbolKind Range = lspRange SelectionRange = selectionLspRange Children = None Tags = None Deprecated = None } symbolStack <- docSymbol :: symbolStack let pop (_node: SyntaxNode) = let symbolStack' = match symbolStack with | [] -> failwith "symbolStack is empty" | [_] -> [] | top :: restPastTop -> match restPastTop with | [] -> failwith "restPastTop is empty" | parent :: restPastParent -> let parentWithTopAsChild = let newChildren = parent.Children |> Option.defaultValue Array.empty |> List.ofSeq |> fun xs -> xs @ [top] |> Array.ofSeq { parent with Children = Some newChildren } let poppedSymbolStack = parentWithTopAsChild :: restPastParent poppedSymbolStack symbolStack <- symbolStack' member __.Init(moduleName: string) = let emptyRange = { Start={ Line=0u; Character=0u } End={ Line=0u; Character=0u } } let root: DocumentSymbol = { Name = moduleName Detail = None Kind = SymbolKind.File Range = emptyRange SelectionRange = emptyRange Children = None Tags = None Deprecated = None } symbolStack <- [root] member __.GetDocumentSymbols (clientSupportsDocSymbolHierarchy: bool) = let root = match symbolStack with | [root] -> root | _ -> Exception("symbolStack is not a single node") |> raise if clientSupportsDocSymbolHierarchy then [| root |] else root |> flattenDocumentSymbol |> Array.ofSeq override __.VisitNamespaceDeclaration(node) = push node node.Name.Span base.VisitNamespaceDeclaration(node) pop node override __.VisitFileScopedNamespaceDeclaration(node) = push node node.Name.Span base.VisitFileScopedNamespaceDeclaration(node) pop node override __.VisitEnumDeclaration(node) = push node node.Identifier.Span base.VisitEnumDeclaration(node) pop node override __.VisitEnumMemberDeclaration(node) = push node node.Identifier.Span base.VisitEnumMemberDeclaration(node) pop node override __.VisitClassDeclaration(node) = push node node.Identifier.Span base.VisitClassDeclaration(node) pop node override __.VisitRecordDeclaration(node) = push node node.Identifier.Span base.VisitRecordDeclaration(node) pop node override __.VisitStructDeclaration(node) = push node node.Identifier.Span base.VisitStructDeclaration(node) pop node override __.VisitInterfaceDeclaration(node) = push node node.Identifier.Span base.VisitInterfaceDeclaration(node) pop node override __.VisitDelegateDeclaration(node) = push node node.Identifier.Span base.VisitDelegateDeclaration(node) pop node override __.VisitConstructorDeclaration(node) = push node node.Identifier.Span base.VisitConstructorDeclaration(node) pop node override __.VisitDestructorDeclaration(node) = push node node.Identifier.Span base.VisitDestructorDeclaration(node) pop node override __.VisitOperatorDeclaration(node) = push node node.OperatorToken.Span base.VisitOperatorDeclaration(node) pop node override __.VisitIndexerDeclaration(node) = push node node.ThisKeyword.Span base.VisitIndexerDeclaration(node) pop node override __.VisitConversionOperatorDeclaration(node) = push node node.Type.Span base.VisitConversionOperatorDeclaration(node) pop node override __.VisitMethodDeclaration(node) = push node node.Identifier.Span base.VisitMethodDeclaration(node) pop node override __.VisitPropertyDeclaration(node) = push node node.Identifier.Span base.VisitPropertyDeclaration(node) pop node override __.VisitVariableDeclarator(node) = let grandparent = node.Parent |> Option.ofObj |> Option.bind (fun node -> node.Parent |> Option.ofObj) // Only show field variables and ignore local variables if grandparent.IsSome && grandparent.Value :? FieldDeclarationSyntax then push node node.Identifier.Span base.VisitVariableDeclarator(node) pop node else base.VisitVariableDeclarator(node) override __.VisitEventDeclaration(node) = push node node.Identifier.Span base.VisitEventDeclaration(node) pop node let private dynamicRegistration (clientCapabilities: ClientCapabilities) = clientCapabilities.TextDocument |> Option.bind (fun x -> x.DocumentSymbol) |> Option.bind (fun x -> x.DynamicRegistration) |> Option.defaultValue false let provider (clientCapabilities: ClientCapabilities) : U2 option = match dynamicRegistration clientCapabilities with | true -> None | false -> true |> U2.C1 |> Some let registration (clientCapabilities: ClientCapabilities) : Registration option = match dynamicRegistration clientCapabilities with | false -> None | true -> let registerOptions: DocumentSymbolRegistrationOptions = { Label = None WorkDoneProgress = None DocumentSelector = Some defaultDocumentSelector } Some { Id = Guid.NewGuid().ToString() Method = "textDocument/documentSymbol" RegisterOptions = registerOptions |> serialize |> Some } let handle (context: ServerRequestContext) (p: DocumentSymbolParams) : AsyncLspResult option> = async { let canEmitDocSymbolHierarchy = context.ClientCapabilities.TextDocument |> Option.bind (fun cc -> cc.DocumentSymbol) |> Option.bind (fun cc -> cc.HierarchicalDocumentSymbolSupport) |> Option.defaultValue false match context.GetDocument p.TextDocument.Uri with | None -> return None |> LspResult.success | Some doc -> let! ct = Async.CancellationToken let! semanticModel = doc.GetSemanticModelAsync(ct) |> Async.AwaitTask let! docText = doc.GetTextAsync(ct) |> Async.AwaitTask let! syntaxTree = doc.GetSyntaxTreeAsync(ct) |> Async.AwaitTask let collector = DocumentSymbolCollector(docText, semanticModel) collector.Init(doc.Name) let! root = syntaxTree.GetRootAsync(ct) |> Async.AwaitTask collector.Visit(root) return collector.GetDocumentSymbols(canEmitDocSymbolHierarchy) |> U2.C2 |> Some |> LspResult.success } csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/ExecuteCommand.fs000066400000000000000000000010361502617301100277360ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer.State [] module ExecuteCommand = let provider (_cc: ClientCapabilities) : ExecuteCommandOptions option = None let registration (_cc: ClientCapabilities) : Registration option = None let handle (_context: ServerRequestContext) (_p: ExecuteCommandParams) : AsyncLspResult = LspResult.notImplemented |> async.Return csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/FoldingRange.fs000066400000000000000000000010311502617301100273670ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer.State [] module FoldingRange = let provider (_c: ClientCapabilities) : bool option = None let registration (_c: ClientCapabilities) : Registration option = None let handle (_c: ServerRequestContext) (_p: FoldingRangeParams) : AsyncLspResult = LspResult.notImplemented |> async.Return csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/Hover.fs000066400000000000000000000036431502617301100261260ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open System open Ionide.LanguageServerProtocol.Server open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer open CSharpLanguageServer.Types open CSharpLanguageServer.State [] module Hover = let private dynamicRegistration (clientCapabilities: ClientCapabilities) = clientCapabilities.TextDocument |> Option.bind (fun x -> x.Hover) |> Option.bind (fun x -> x.DynamicRegistration) |> Option.defaultValue false let provider (clientCapabilities: ClientCapabilities) : U2 option = match dynamicRegistration clientCapabilities with | true -> Some (U2.C1 false) | false -> Some (U2.C1 true) let registration (clientCapabilities: ClientCapabilities) : Registration option = match dynamicRegistration clientCapabilities with | false -> None | true -> let registerOptions: HoverRegistrationOptions = { DocumentSelector = Some defaultDocumentSelector WorkDoneProgress = None } Some { Id = Guid.NewGuid().ToString() Method = "textDocument/hover" RegisterOptions = registerOptions |> serialize |> Some } let handle (context: ServerRequestContext) (p: HoverParams) : AsyncLspResult = async { match! context.FindSymbol' p.TextDocument.Uri p.Position with | None -> return None |> LspResult.success | Some (symbol, doc) -> let content = DocumentationUtil.markdownDocForSymbolWithSignature symbol let hover = { Contents = { Kind = MarkupKind.Markdown; Value = content } |> U3.C1 // TODO: Support range Range = None } return hover |> Some |> LspResult.success } csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/Implementation.fs000066400000000000000000000041031502617301100300200ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open System open Ionide.LanguageServerProtocol.Server open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer.Types open CSharpLanguageServer.State open CSharpLanguageServer.Util [] module Implementation = let private dynamicRegistration (clientCapabilities: ClientCapabilities) = clientCapabilities.TextDocument |> Option.bind (fun x -> x.Implementation) |> Option.bind (fun x -> x.DynamicRegistration) |> Option.defaultValue false let provider (clientCapabilities: ClientCapabilities) : U3 option = match dynamicRegistration clientCapabilities with | true -> None | false -> Some (U3.C1 true) let registration (clientCapabilities: ClientCapabilities) : Registration option = match dynamicRegistration clientCapabilities with | false -> None | true -> let registerOptions: ImplementationRegistrationOptions = { DocumentSelector = Some defaultDocumentSelector Id = None WorkDoneProgress = None } Some { Id = Guid.NewGuid().ToString() Method = "textDocument/implementation" RegisterOptions = registerOptions |> serialize |> Some } let handle (context: ServerRequestContext) (p: ImplementationParams) : Async option>> = async { match! context.FindSymbol p.TextDocument.Uri p.Position with | None -> return None |> LspResult.success | Some symbol -> let! impls = context.FindImplementations symbol let! locations = impls |> Seq.map (flip context.ResolveSymbolLocations None) |> Async.Parallel return locations |> Array.collect List.toArray |> Declaration.C2 |> U2.C1 |> Some |> LspResult.success } csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/Initialization.fs000066400000000000000000000166631502617301100300400ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open System open System.IO open System.Reflection open Microsoft.Build.Locator open Ionide.LanguageServerProtocol open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.Server open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer.State open CSharpLanguageServer.State.ServerState open CSharpLanguageServer.Types open CSharpLanguageServer.Logging [] module Initialization = let private logger = LogProvider.getLoggerByName "Initialization" let handleInitialize (lspClient: ILspClient) (setupTimer: unit -> unit) (serverCapabilities: ServerCapabilities) (context: ServerRequestContext) (p: InitializeParams) : Async> = async { // context.State.LspClient has not been initialized yet thus context.WindowShowMessage will not work let windowShowMessage m = lspClient.WindowLogMessage({ Type = MessageType.Info; Message = m }) context.Emit(ClientChange (Some lspClient)) let serverName = "csharp-ls" let serverVersion = Assembly.GetExecutingAssembly().GetName().Version |> string logger.info ( Log.setMessage "initializing, {name} version {version}" >> Log.addContext "name" serverName >> Log.addContext "version" serverVersion ) do! windowShowMessage( sprintf "csharp-ls: initializing, version %s" serverVersion) logger.info ( Log.setMessage "{name} is released under MIT license and is not affiliated with Microsoft Corp.; see https://github.com/razzmatazz/csharp-language-server" >> Log.addContext "name" serverName ) do! windowShowMessage( sprintf "csharp-ls: %s is released under MIT license and is not affiliated with Microsoft Corp.; see https://github.com/razzmatazz/csharp-language-server" serverName) let vsInstanceQueryOpt = VisualStudioInstanceQueryOptions.Default let vsInstanceList = MSBuildLocator.QueryVisualStudioInstances(vsInstanceQueryOpt) if Seq.isEmpty vsInstanceList then raise (InvalidOperationException("No instances of MSBuild could be detected." + Environment.NewLine + "Try calling RegisterInstance or RegisterMSBuildPath to manually register one.")) // do! infoMessage "MSBuildLocator instances found:" // // for vsInstance in vsInstanceList do // do! infoMessage (sprintf "- SDK=\"%s\", Version=%s, MSBuildPath=\"%s\", DiscoveryType=%s" // vsInstance.Name // (string vsInstance.Version) // vsInstance.MSBuildPath // (string vsInstance.DiscoveryType)) let vsInstance = vsInstanceList |> Seq.head logger.info( Log.setMessage "MSBuildLocator: will register \"{vsInstanceName}\", Version={vsInstanceVersion} as default instance" >> Log.addContext "vsInstanceName" vsInstance.Name >> Log.addContext "vsInstanceVersion" (string vsInstance.Version) ) MSBuildLocator.RegisterInstance(vsInstance) (* logger.trace ( Log.setMessage "handleInitialize: p.Capabilities={caps}" >> Log.addContext "caps" (serialize p.Capabilities) ) *) context.Emit(ClientCapabilityChange p.Capabilities) // TODO use p.RootUri let rootPath = Directory.GetCurrentDirectory() context.Emit(RootPathChange rootPath) // setup timer so actors get period ticks setupTimer() let initializeResult = { InitializeResult.Default with Capabilities = serverCapabilities ServerInfo = Some { Name = "csharp-ls" Version = Some (Assembly.GetExecutingAssembly().GetName().Version.ToString()) }} return initializeResult |> LspResult.success } let handleInitialized (lspClient: ILspClient) (stateActor: MailboxProcessor) (getRegistrations: ClientCapabilities -> Registration list) (context: ServerRequestContext) (_p: unit) : Async> = async { logger.trace ( Log.setMessage "handleInitialized: \"initialized\" notification received from client" ) let registrationParams = { Registrations = getRegistrations context.ClientCapabilities |> List.toArray } // TODO: Retry on error? try match! lspClient.ClientRegisterCapability registrationParams with | Ok _ -> () | Error error -> logger.warn( Log.setMessage "handleInitialized: didChangeWatchedFiles registration has failed with {error}" >> Log.addContext "error" (string error) ) with | ex -> logger.warn( Log.setMessage "handleInitialized: didChangeWatchedFiles registration has failed with {error}" >> Log.addContext "error" (string ex) ) // // retrieve csharp settings // try let! workspaceCSharpConfig = lspClient.WorkspaceConfiguration( { Items=[| { Section=Some "csharp"; ScopeUri=None } |] }) let csharpConfigTokensMaybe = match workspaceCSharpConfig with | Ok ts -> Some ts | _ -> None let newSettingsMaybe = match csharpConfigTokensMaybe with | Some [| t |] -> let csharpSettingsMaybe = t |> deserialize match csharpSettingsMaybe with | Some csharpSettings -> match csharpSettings.solution with | Some solutionPath-> Some { context.State.Settings with SolutionPath = Some solutionPath } | _ -> None | _ -> None | _ -> None // do! logMessage (sprintf "handleInitialized: newSettingsMaybe=%s" (string newSettingsMaybe)) match newSettingsMaybe with | Some newSettings -> context.Emit(SettingsChange newSettings) | _ -> () with | ex -> logger.warn( Log.setMessage "handleInitialized: could not retrieve `csharp` workspace configuration section: {error}" >> Log.addContext "error" (ex |> string) ) // // start loading the solution // stateActor.Post(SolutionReloadRequest (TimeSpan.FromMilliseconds(100))) logger.trace( Log.setMessage "handleInitialized: OK") return Ok() } let handleShutdown (context: ServerRequestContext) (_: unit) : Async> = async { context.Emit(ClientCapabilityChange emptyClientCapabilities) context.Emit(ClientChange None) return Ok() } csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/InlayHint.fs000066400000000000000000000306041502617301100267370ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open System open System.Collections.Immutable open Microsoft.CodeAnalysis open Microsoft.CodeAnalysis.CSharp open Microsoft.CodeAnalysis.CSharp.Syntax open Microsoft.CodeAnalysis.Text open Ionide.LanguageServerProtocol.Server open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer.State open CSharpLanguageServer.Conversions open CSharpLanguageServer.Types [] module InlayHint = // TODO: Do we keep it now or refactor it to use reflection? let private getBestOrAllSymbols (info: SymbolInfo) = let best = if isNull info.Symbol then None else Some ([| info.Symbol |]) let all = if info.CandidateSymbols.IsEmpty then None else Some (info.CandidateSymbols |> Array.ofSeq) best |> Option.orElse all |> Option.defaultValue Array.empty // rewrite of https://github.com/dotnet/roslyn/blob/main/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/ArgumentSyntaxExtensions.cs let private getParameterForArgumentSyntax (semanticModel: SemanticModel) (argument: ArgumentSyntax) : IParameterSymbol option = match argument.Parent with | :? BaseArgumentListSyntax as argumentList when not (isNull argumentList.Parent) -> let symbols = semanticModel.GetSymbolInfo(argumentList.Parent) |> getBestOrAllSymbols match symbols with | [| symbol |] -> let parameters = match symbol with | :? IMethodSymbol as m -> m.Parameters | :? IPropertySymbol as nt -> nt.Parameters | _ -> ImmutableArray.Empty let namedParameter = if isNull argument.NameColon || argument.NameColon.IsMissing then None else parameters |> Seq.tryFind (fun p -> p.Name = argument.NameColon.Name.Identifier.ValueText) let positionalParameter = match argumentList.Arguments.IndexOf(argument) with | index when 0 <= index && index < parameters.Length -> let parameter = parameters[index] if argument.RefOrOutKeyword.Kind() = SyntaxKind.OutKeyword && parameter.RefKind <> RefKind.Out || argument.RefOrOutKeyword.Kind() = SyntaxKind.RefKeyword && parameter.RefKind <> RefKind.Ref then None else Some parameter | _ -> None namedParameter |> Option.orElse positionalParameter | _ -> None | _ -> None // rewrite of https://github.com/dotnet/roslyn/blob/main/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Extensions/AttributeArgumentSyntaxExtensions.cs let private getParameterForAttributeArgumentSyntax (semanticModel: SemanticModel) (argument: AttributeArgumentSyntax) : IParameterSymbol option = match argument.Parent with | :? AttributeArgumentListSyntax as argumentList when not (isNull argument.NameEquals) -> match argumentList.Parent with | :? AttributeSyntax as invocable -> let symbols = semanticModel.GetSymbolInfo(invocable) |> getBestOrAllSymbols match symbols with | [| symbol |] -> let parameters = match symbol with | :? IMethodSymbol as m -> m.Parameters | :? IPropertySymbol as nt -> nt.Parameters | _ -> ImmutableArray.Empty let namedParameter = if isNull argument.NameColon || argument.NameColon.IsMissing then None else parameters |> Seq.tryFind (fun p -> p.Name = argument.NameColon.Name.Identifier.ValueText) let positionalParameter = match argumentList.Arguments.IndexOf(argument) with | index when 0 <= index && index < parameters.Length -> Some parameters[index] | _ -> None namedParameter |> Option.orElse positionalParameter | _ -> None | _ -> None | _ -> None let private toInlayHint (semanticModel: SemanticModel) (lines: TextLineCollection) (node: SyntaxNode): InlayHint option = let validateType (ty: ITypeSymbol) = if isNull ty || ty :? IErrorTypeSymbol || ty.Name = "var" then None else Some ty let typeDisplayStyle = SymbolDisplayFormat( genericsOptions = SymbolDisplayGenericsOptions.IncludeTypeParameters, miscellaneousOptions = (SymbolDisplayMiscellaneousOptions.AllowDefaultLiteral ||| SymbolDisplayMiscellaneousOptions.IncludeNullableReferenceTypeModifier ||| SymbolDisplayMiscellaneousOptions.UseSpecialTypes)) let toTypeInlayHint (pos: int) (ty: ITypeSymbol): InlayHint = { Position = pos |> lines.GetLinePosition |> Position.fromLinePosition Label = U2.C1 (": " + SymbolName.fromSymbol typeDisplayStyle ty) Kind = Some InlayHintKind.Type TextEdits = None Tooltip = None PaddingLeft = Some false PaddingRight = Some false Data = None } let validateParameter (arg: SyntaxNode) (par: IParameterSymbol) = match arg.Parent with // Don't show hint for indexer | :? BracketedArgumentListSyntax -> None // Don't show hint if parameter name is empty | _ when String.IsNullOrEmpty(par.Name) -> None // Don't show hint if argument matches parameter name | _ when String.Equals(arg.GetText().ToString(), par.Name, StringComparison.CurrentCultureIgnoreCase) -> None | _ -> Some par let toParameterInlayHint (pos: int) (par: IParameterSymbol): InlayHint = { Position = pos |> lines.GetLinePosition |> Position.fromLinePosition Label = U2.C1 (par.Name + ":") Kind = Some InlayHintKind.Parameter TextEdits = None Tooltip = None PaddingLeft = Some false PaddingRight = Some true Data = None } // It's a rewrite of https://github.com/dotnet/roslyn/blob/main/src/Features/CSharp/Portable/InlineHints/CSharpInlineTypeHintsService.cs & // https://github.com/dotnet/roslyn/blob/main/src/Features/CSharp/Portable/InlineHints/CSharpInlineParameterNameHintsService.cs. // If Roslyn exposes the classes, then we can just do a type convert. // TODO: Support the configuration whether or not to show some kinds of inlay hints. match node with | :? VariableDeclarationSyntax as var when var.Type.IsVar && var.Variables.Count = 1 && not var.Variables[0].Identifier.IsMissing -> semanticModel.GetTypeInfo(var.Type).Type |> validateType |> Option.map (toTypeInlayHint var.Variables[0].Identifier.Span.End) // We handle individual variables of ParenthesizedVariableDesignationSyntax separately. // For example, in `var (x, y) = (0, "")`, we should `int` for `x` and `string` for `y`. // It's redundant to show `(int, string)` for `var` | :? DeclarationExpressionSyntax as dec when dec.Type.IsVar && not (dec.Designation :? ParenthesizedVariableDesignationSyntax) -> semanticModel.GetTypeInfo(dec.Type).Type |> validateType |> Option.map (toTypeInlayHint dec.Designation.Span.End) | :? SingleVariableDesignationSyntax as var when not (var.Parent :? DeclarationPatternSyntax) && not (var.Parent :? DeclarationExpressionSyntax) -> semanticModel.GetDeclaredSymbol(var) |> fun sym -> match sym with | :? ILocalSymbol as local -> Some local | _ -> None |> Option.map (fun local -> local.Type) |> Option.bind validateType |> Option.map (toTypeInlayHint var.Identifier.Span.End) | :? ForEachStatementSyntax as forEach when forEach.Type.IsVar -> semanticModel.GetForEachStatementInfo(forEach).ElementType |> validateType |> Option.map (toTypeInlayHint forEach.Identifier.Span.End) | :? ParameterSyntax as parameterNode when isNull parameterNode.Type -> let parameter = semanticModel.GetDeclaredSymbol(parameterNode) parameter |> fun parameter -> match parameter.ContainingSymbol with | :? IMethodSymbol as methSym when methSym.MethodKind = MethodKind.AnonymousFunction -> Some parameter | _ -> None |> Option.map (fun parameter -> parameter.Type) |> Option.bind validateType |> Option.map (toTypeInlayHint parameterNode.Identifier.Span.End) | :? ImplicitObjectCreationExpressionSyntax as implicitNew -> semanticModel.GetTypeInfo(implicitNew).Type |> validateType |> Option.map (toTypeInlayHint implicitNew.NewKeyword.Span.End) | :? ArgumentSyntax as argument when isNull argument.NameColon -> argument |> getParameterForArgumentSyntax semanticModel |> Option.bind (validateParameter node) |> Option.map (toParameterInlayHint argument.Span.Start) | :? AttributeArgumentSyntax as argument when isNull argument.NameEquals && isNull argument.NameColon -> argument |> getParameterForAttributeArgumentSyntax semanticModel |> Option.bind (validateParameter node) |> Option.map (toParameterInlayHint argument.Span.Start) | _ -> None let private dynamicRegistration (clientCapabilities: ClientCapabilities) = clientCapabilities.TextDocument |> Option.bind (fun x -> x.InlayHint) |> Option.bind (fun x -> x.DynamicRegistration) |> Option.defaultValue false let provider (clientCapabilities: ClientCapabilities) : U3 option = match dynamicRegistration clientCapabilities with | true -> None | false -> let inlayHintOptions: InlayHintOptions = { ResolveProvider = Some false WorkDoneProgress = None } Some (U3.C2 inlayHintOptions) let registration (clientCapabilities: ClientCapabilities) : Registration option = match dynamicRegistration clientCapabilities with | false -> None | true -> let registerOptions: InlayHintRegistrationOptions = { ResolveProvider = Some false DocumentSelector = Some defaultDocumentSelector Id = None WorkDoneProgress = None } Some { Id = Guid.NewGuid().ToString() Method = "textDocument/inlayHint" RegisterOptions = registerOptions |> serialize |> Some } let handle (context: ServerRequestContext) (p: InlayHintParams): AsyncLspResult = async { match context.GetUserDocument p.TextDocument.Uri with | None -> return None |> LspResult.success | Some doc -> let! ct = Async.CancellationToken let! semanticModel = doc.GetSemanticModelAsync(ct) |> Async.AwaitTask let! root = doc.GetSyntaxRootAsync(ct) |> Async.AwaitTask let! sourceText = doc.GetTextAsync(ct) |> Async.AwaitTask let textSpan = Range.toTextSpan sourceText.Lines p.Range 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 return inlayHints |> Seq.toArray |> Some |> LspResult.success } let resolve (_context: ServerRequestContext) (_p: InlayHint) : AsyncLspResult = LspResult.notImplemented |> async.Return csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/InlineValue.fs000066400000000000000000000010771502617301100272550ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer.State [] module InlineValue = let provider (clientCapabilities: ClientCapabilities) : InlineValueOptions option = None let registration (clientCapabilities: ClientCapabilities) : Registration option = None let handle (context: ServerRequestContext) (p: InlineValueParams) : AsyncLspResult = LspResult.notImplemented |> async.Return csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/LinkedEditingRange.fs000066400000000000000000000010771502617301100305310ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer.State [] module LinkedEditingRange = let provider (clientCapabilities: ClientCapabilities) = None let registration (clientCapabilities: ClientCapabilities) : Registration option = None let handle (context: ServerRequestContext) (def: LinkedEditingRangeParams) : AsyncLspResult = LspResult.notImplemented |> async.Return csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/Moniker.fs000066400000000000000000000007771502617301100264540ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer.State [] module Moniker = let provider (_cc: ClientCapabilities) = None let registration (_cc: ClientCapabilities) : Registration option = None let handle (_context: ServerRequestContext) (_p: MonikerParams) : AsyncLspResult = LspResult.notImplemented |> async.Return csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/References.fs000066400000000000000000000040041502617301100271140ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open System open Ionide.LanguageServerProtocol.Server open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer.State open CSharpLanguageServer.Conversions open CSharpLanguageServer.Types [] module References = let private dynamicRegistration (clientCapabilities: ClientCapabilities) = clientCapabilities.TextDocument |> Option.bind (fun x -> x.References) |> Option.bind (fun x -> x.DynamicRegistration) |> Option.defaultValue false let provider (clientCapabilities: ClientCapabilities) : U2 option = match dynamicRegistration clientCapabilities with | true -> None | false -> Some (U2.C1 true) let registration (clientCapabilities: ClientCapabilities) : Registration option = match dynamicRegistration clientCapabilities with | false -> None | true -> let registerOptions: ReferenceRegistrationOptions = { DocumentSelector = Some defaultDocumentSelector WorkDoneProgress = None } Some { Id = Guid.NewGuid().ToString() Method = "textDocument/references" RegisterOptions = registerOptions |> serialize |> Some } let handle (context: ServerRequestContext) (p: ReferenceParams) : AsyncLspResult = async { match! context.FindSymbol p.TextDocument.Uri p.Position with | None -> return None |> LspResult.success | Some symbol -> let! locations = context.FindReferences symbol p.Context.IncludeDeclaration return locations |> Seq.map Location.fromRoslynLocation |> Seq.filter _.IsSome |> Seq.map _.Value |> Seq.distinct |> Seq.toArray |> Some |> LspResult.success } csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/Rename.fs000066400000000000000000000176471502617301100262630ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open System open System.Threading open Microsoft.CodeAnalysis open Microsoft.CodeAnalysis.CSharp.Syntax open Microsoft.CodeAnalysis.FindSymbols open Microsoft.CodeAnalysis.Rename open Ionide.LanguageServerProtocol.Server open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer.State open CSharpLanguageServer.Logging open CSharpLanguageServer.Conversions open CSharpLanguageServer.Types open CSharpLanguageServer.Util [] module Rename = let private logger = LogProvider.getLoggerByName "Rename" let private lspDocChangesFromSolutionDiff (ct: CancellationToken) (originalSolution: Solution) (updatedSolution: Solution) (tryGetDocVersionByUri: string -> int option) : Async = let getEdits (originalSolution: Solution) (updatedSolution: Solution) (docId: DocumentId) : Async = async { let originalDoc = originalSolution.GetDocument(docId) let! originalDocText = originalDoc.GetTextAsync(ct) |> Async.AwaitTask let updatedDoc = updatedSolution.GetDocument(docId) let! docChanges = updatedDoc.GetTextChangesAsync(originalDoc, ct) |> Async.AwaitTask let diffEdits: U2 array = docChanges |> Seq.sortBy (fun c -> c.Span.Start) |> Seq.map (TextEdit.fromTextChange originalDocText.Lines) |> Seq.map U2.C1 |> Array.ofSeq let uri = originalDoc.FilePath |> Path.toUri let textEditDocument = { Uri = uri Version = tryGetDocVersionByUri uri } return { TextDocument = textEditDocument Edits = diffEdits } } updatedSolution.GetChanges(originalSolution).GetProjectChanges() |> Seq.collect (fun projectChange -> projectChange.GetChangedDocuments()) |> Seq.map (getEdits originalSolution updatedSolution) |> Async.Parallel |> Async.map (Seq.distinct >> Array.ofSeq) let private dynamicRegistration (clientCapabilities: ClientCapabilities) = clientCapabilities.TextDocument |> Option.bind (fun x -> x.Rename) |> Option.bind (fun x -> x.DynamicRegistration) |> Option.defaultValue false let private prepareSupport (clientCapabilities: ClientCapabilities) = clientCapabilities.TextDocument |> Option.bind (fun x -> x.Rename) |> Option.bind (fun x -> x.PrepareSupport) |> Option.defaultValue false let provider (clientCapabilities: ClientCapabilities): U2 option = match dynamicRegistration clientCapabilities, prepareSupport clientCapabilities with | true, _ -> None | false, true -> Some (U2.C2 { PrepareProvider = Some true; WorkDoneProgress = None }) | false, false -> Some (U2.C1 true) let registration (clientCapabilities: ClientCapabilities) : Registration option = match dynamicRegistration clientCapabilities with | false -> None | true -> let registerOptions: RenameRegistrationOptions = { PrepareProvider = Some (prepareSupport clientCapabilities) DocumentSelector = Some defaultDocumentSelector WorkDoneProgress = None } Some { Id = Guid.NewGuid().ToString() Method = "textDocument/rename" RegisterOptions = registerOptions |> serialize |> Some } let prepare (context: ServerRequestContext) (p: PrepareRenameParams) : AsyncLspResult = async { match context.GetUserDocument p.TextDocument.Uri with | None -> return None |> LspResult.success | Some doc -> let! ct = Async.CancellationToken let! docSyntaxTree = doc.GetSyntaxTreeAsync(ct) |> Async.AwaitTask let! docText = doc.GetTextAsync(ct) |> Async.AwaitTask let position = Position.toRoslynPosition docText.Lines p.Position let! symbolMaybe = SymbolFinder.FindSymbolAtPositionAsync(doc, position, ct) |> Async.AwaitTask let symbolIsFromMetadata = symbolMaybe |> Option.ofObj |> Option.map (fun s -> s.MetadataToken <> 0) |> Option.defaultValue false let linePositionSpan = Range.toLinePositionSpan docText.Lines { Start = p.Position; End = p.Position } let textSpan = docText.Lines.GetTextSpan(linePositionSpan) let! rootNode = docSyntaxTree.GetRootAsync(ct) |> Async.AwaitTask let nodeOnPos = rootNode.FindNode(textSpan, findInsideTrivia = false, getInnermostNodeForTie = true) let spanMaybe = match nodeOnPos with | :? PropertyDeclarationSyntax as propDec -> propDec.Identifier.Span |> Some | :? MethodDeclarationSyntax as methodDec -> methodDec.Identifier.Span |> Some | :? BaseTypeDeclarationSyntax as typeDec -> typeDec.Identifier.Span |> Some | :? VariableDeclaratorSyntax as varDec -> varDec.Identifier.Span |> Some | :? EnumMemberDeclarationSyntax as enumMemDec -> enumMemDec.Identifier.Span |> Some | :? ParameterSyntax as paramSyn -> paramSyn.Identifier.Span |> Some | :? NameSyntax as nameSyn -> nameSyn.Span |> Some | :? SingleVariableDesignationSyntax as designationSyn -> designationSyn.Identifier.Span |> Some | :? ForEachStatementSyntax as forEachSyn -> forEachSyn.Identifier.Span |> Some | :? LocalFunctionStatementSyntax as localFunStSyn -> localFunStSyn.Identifier.Span |> Some | node -> logger.debug ( Log.setMessage "textDocument/prepareRename: unhandled Type={type}" >> Log.addContext "type" (node.GetType().Name) ) None let rangeWithPlaceholderMaybe: PrepareRenameResult option = match spanMaybe, symbolIsFromMetadata with | Some span, false -> let range = Range.fromTextSpan docText.Lines span let text = docText.ToString(span) { Range = range; Placeholder = text } |> U3.C2 |> Some | _, _ -> None return rangeWithPlaceholderMaybe |> LspResult.success } let handle (context: ServerRequestContext) (p: RenameParams) : AsyncLspResult = async { match! context.FindSymbol' p.TextDocument.Uri p.Position with | None -> return None |> LspResult.success | Some (symbol, doc) -> let! ct = Async.CancellationToken let originalSolution = doc.Project.Solution let! updatedSolution = Renamer.RenameSymbolAsync( doc.Project.Solution, symbol, SymbolRenameOptions(RenameOverloads = true, RenameFile = true), p.NewName, ct ) |> Async.AwaitTask let! docTextEdit = lspDocChangesFromSolutionDiff ct originalSolution updatedSolution (fun uri -> context.OpenDocs.TryFind uri |> Option.map _.Version) return WorkspaceEdit.Create(docTextEdit, context.ClientCapabilities) |> Some |> LspResult.success } csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/SelectionRange.fs000066400000000000000000000010451502617301100277370ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer.State [] module SelectionRange = let provider (_cc: ClientCapabilities) : bool option = None let registration (_cc: ClientCapabilities) : Registration option = None let handle (_ctx: ServerRequestContext) (_p: SelectionRangeParams) : AsyncLspResult = LspResult.notImplemented |> async.Return csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/SemanticTokens.fs000066400000000000000000000216201502617301100277650ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open System open System.Collections.Generic open Ionide.LanguageServerProtocol.Server open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open Microsoft.CodeAnalysis.Classification open Microsoft.CodeAnalysis.Text open CSharpLanguageServer.State open CSharpLanguageServer.Util open CSharpLanguageServer.Conversions open CSharpLanguageServer.Types [] module SemanticTokens = let private classificationTypeMap = Map [ (ClassificationTypeNames.ClassName, "class"); (ClassificationTypeNames.Comment, "comment"); (ClassificationTypeNames.ConstantName, "property"); (ClassificationTypeNames.ControlKeyword, "keyword"); (ClassificationTypeNames.DelegateName, "class"); (ClassificationTypeNames.EnumMemberName, "enumMember"); (ClassificationTypeNames.EnumName, "enum"); (ClassificationTypeNames.EventName, "event"); (ClassificationTypeNames.ExtensionMethodName, "method"); (ClassificationTypeNames.FieldName, "property"); (ClassificationTypeNames.Identifier, "variable"); (ClassificationTypeNames.InterfaceName, "interface"); (ClassificationTypeNames.LabelName, "variable"); (ClassificationTypeNames.LocalName, "variable"); (ClassificationTypeNames.Keyword, "keyword"); (ClassificationTypeNames.MethodName, "method"); (ClassificationTypeNames.NamespaceName, "namespace"); (ClassificationTypeNames.NumericLiteral, "number"); (ClassificationTypeNames.Operator, "operator"); (ClassificationTypeNames.OperatorOverloaded, "operator"); (ClassificationTypeNames.ParameterName, "parameter"); (ClassificationTypeNames.PropertyName, "property"); (ClassificationTypeNames.RecordClassName, "class"); (ClassificationTypeNames.RecordStructName, "struct"); (ClassificationTypeNames.RegexText, "regex"); (ClassificationTypeNames.StringLiteral, "string"); (ClassificationTypeNames.StructName, "struct"); (ClassificationTypeNames.TypeParameterName, "typeParameter"); (ClassificationTypeNames.VerbatimStringLiteral, "string") ] let private classificationModifierMap = Map [ (ClassificationTypeNames.StaticSymbol, "static") ] let private semanticTokenTypeMap = classificationTypeMap |> Map.values |> Seq.distinct |> flip Seq.zip (Seq.initInfinite uint32) |> Map.ofSeq let private semanticTokenModifierMap = classificationModifierMap |> Map.values |> Seq.distinct |> flip Seq.zip (Seq.initInfinite uint32) |> Map.ofSeq let private semanticTokenTypes = semanticTokenTypeMap |> Seq.sortBy (fun kvp -> kvp.Value) |> Seq.map (fun kvp -> kvp.Key) let private semanticTokenModifiers = semanticTokenModifierMap |> Seq.sortBy (fun kvp -> kvp.Value) |> Seq.map (fun kvp -> kvp.Key) let private getSemanticTokenIdFromClassification (classification: string) = classificationTypeMap |> Map.tryFind classification |> Option.bind (flip Map.tryFind semanticTokenTypeMap) let private getSemanticTokenModifierFlagFromClassification (classification: string) = classificationModifierMap |> Map.tryFind classification |> Option.bind (flip Map.tryFind semanticTokenModifierMap) |> Option.defaultValue 0u |> int32 |> (<<<) 1u let private toSemanticToken (lines: TextLineCollection) (textSpan: TextSpan, spans: IEnumerable) = let (typeId, modifiers) = spans |> Seq.fold (fun (t, m) s -> if ClassificationTypeNames.AdditiveTypeNames.Contains(s.ClassificationType) then (t, m ||| (getSemanticTokenModifierFlagFromClassification s.ClassificationType)) else (getSemanticTokenIdFromClassification s.ClassificationType, m) ) (None, 0u) let pos = lines.GetLinePositionSpan(textSpan) (uint32 pos.Start.Line, uint32 pos.Start.Character, uint32 (pos.End.Character - pos.Start.Character), typeId, modifiers) let private computePosition (((pLine, pChar, _, _, _), (cLine, cChar, cLen, cToken, cModifiers)): ((uint32 * uint32 * uint32 * uint32 * uint32) * (uint32 * uint32 * uint32 * uint32 * uint32))) = let deltaLine = cLine - pLine let deltaChar = if deltaLine = 0u then cChar - pChar else cChar (deltaLine, deltaChar, cLen, cToken, cModifiers) let private getSemanticTokensRange (context: ServerRequestContext) (uri: string) (range: Range option): AsyncLspResult = async { let docMaybe = context.GetUserDocument uri match docMaybe with | None -> return None |> LspResult.success | Some doc -> let! ct = Async.CancellationToken let! sourceText = doc.GetTextAsync(ct) |> Async.AwaitTask let textSpan = range |> Option.map (Range.toTextSpan sourceText.Lines) |> Option.defaultValue (TextSpan(0, sourceText.Length)) let! spans = Classifier.GetClassifiedSpansAsync(doc, textSpan, ct) |> Async.AwaitTask let tokens = spans |> Seq.groupBy (fun span -> span.TextSpan) |> Seq.map (toSemanticToken sourceText.Lines) |> Seq.filter (fun (_, _, _, oi, _) -> Option.isSome oi) |> Seq.map (fun (line, startChar, len, tokenId, modifiers) -> (line, startChar, len, Option.get tokenId, modifiers)) let response = { Data = Seq.zip (seq {yield (0u,0u,0u,0u,0u); yield! tokens}) tokens |> Seq.map computePosition |> Seq.map (fun (a,b,c,d,e) -> [a;b;c;d;e]) |> Seq.concat |> Seq.toArray ResultId = None } // TODO: add a result id after we support delta semantic tokens return Some response |> LspResult.success } let private dynamicRegistration (clientCapabilities: ClientCapabilities) = clientCapabilities.TextDocument |> Option.bind (fun x -> x.SemanticTokens) |> Option.bind (fun x -> x.DynamicRegistration) |> Option.defaultValue false let provider (clientCapabilities: ClientCapabilities) : U2 option = match dynamicRegistration clientCapabilities with | true -> None | false -> let semanticTokensOptions: SemanticTokensOptions = { Legend = { TokenTypes = semanticTokenTypes |> Seq.toArray TokenModifiers = semanticTokenModifiers |> Seq.toArray } Range = Some (U2.C1 true) Full = Some (U2.C1 true) WorkDoneProgress = None } Some (U2.C1 semanticTokensOptions) let registration (clientCapabilities: ClientCapabilities) : Registration option = match dynamicRegistration clientCapabilities with | false -> None | true -> let registerOptions: SemanticTokensRegistrationOptions = { Legend = { TokenTypes = semanticTokenTypes |> Seq.toArray TokenModifiers = semanticTokenModifiers |> Seq.toArray } Range = Some (U2.C1 true) Full = Some (U2.C1 true) Id = None WorkDoneProgress = None DocumentSelector = Some defaultDocumentSelector } Some { Id = Guid.NewGuid().ToString() Method = "textDocument/semanticTokens" RegisterOptions = registerOptions |> serialize |> Some } // TODO: Everytime the server will re-compute semantic tokens, is it possible to cache the result? let handleFull (context: ServerRequestContext) (p: SemanticTokensParams): AsyncLspResult = getSemanticTokensRange context p.TextDocument.Uri None let handleFullDelta (_context: ServerRequestContext) (_p: SemanticTokensDeltaParams) : AsyncLspResult option> = LspResult.notImplemented option> |> async.Return let handleRange (context: ServerRequestContext) (p: SemanticTokensRangeParams): AsyncLspResult = getSemanticTokensRange context p.TextDocument.Uri (Some p.Range) csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/SignatureHelp.fs000066400000000000000000000163241502617301100276150ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open System open Microsoft.CodeAnalysis open Microsoft.CodeAnalysis.CSharp open Microsoft.CodeAnalysis.CSharp.Syntax open Ionide.LanguageServerProtocol.Server open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer open CSharpLanguageServer.State open CSharpLanguageServer.Util open CSharpLanguageServer.Conversions open CSharpLanguageServer.Types module SignatureInformation = let internal fromMethod (m: IMethodSymbol) = let parameters = m.Parameters |> Seq.map (fun p -> { Label = SymbolName.fromSymbol SymbolDisplayFormat.MinimallyQualifiedFormat p |> U2.C1 Documentation = None }) |> Array.ofSeq let documentation = { Kind = MarkupKind.Markdown Value = DocumentationUtil.markdownDocForSymbol m } |> U2.C2 { Label = SymbolName.fromSymbol SymbolDisplayFormat.MinimallyQualifiedFormat m Documentation = Some documentation Parameters = Some parameters ActiveParameter = None } [] module SignatureHelp = type InvocationContext = { Receiver: SyntaxNode ArgumentTypes: TypeInfo list Separators: SyntaxToken list } // Algorithm from omnisharp-roslyn (https://github.com/OmniSharp/omnisharp-roslyn/blob/2d582b05839dbd23baf6e78fa2279163723a824c/src/OmniSharp.Roslyn.CSharp/Services/Signatures/SignatureHelpService.cs#L139C1-L166C10) let private methodScore (types: TypeInfo list) (m: IMethodSymbol) = let score (invocation: TypeInfo) (definition: IParameterSymbol) = if isNull invocation.ConvertedType then 1 else if SymbolEqualityComparer.Default.Equals(invocation.ConvertedType, definition.Type) then 2 else 0 if m.Parameters.Length < types.Length then Microsoft.FSharp.Core.int.MinValue else Seq.zip types m.Parameters |> Seq.map (uncurry score) |> Seq.sum let private dynamicRegistration (clientCapabilities: ClientCapabilities) = clientCapabilities.TextDocument |> Option.bind (fun x -> x.SignatureHelp) |> Option.bind (fun x -> x.DynamicRegistration) |> Option.defaultValue false let provider (clientCapabilities: ClientCapabilities) : SignatureHelpOptions option = match dynamicRegistration clientCapabilities with | true -> None | false -> Some { TriggerCharacters = Some([| "("; ","; "<"; "{"; "[" |]) WorkDoneProgress = None RetriggerCharacters = None } let registration (clientCapabilities: ClientCapabilities) : Registration option = match dynamicRegistration clientCapabilities with | false -> None | true -> let registerOptions: SignatureHelpRegistrationOptions = { TriggerCharacters = Some([| "("; ","; "<"; "{"; "[" |]) RetriggerCharacters = None WorkDoneProgress = None DocumentSelector = Some defaultDocumentSelector } Some { Id = Guid.NewGuid().ToString() Method = "textDocument/signatureHelp" RegisterOptions = registerOptions |> serialize |> Some } let handle (context: ServerRequestContext) (p: SignatureHelpParams): AsyncLspResult = async { let docMaybe = context.GetUserDocument p.TextDocument.Uri match docMaybe with | None -> return None |> LspResult.success | Some doc -> let! ct = Async.CancellationToken let! sourceText = doc.GetTextAsync(ct) |> Async.AwaitTask let! semanticModel = doc.GetSemanticModelAsync(ct) |> Async.AwaitTask let position = Position.toRoslynPosition sourceText.Lines p.Position let! syntaxTree = doc.GetSyntaxTreeAsync(ct) |> Async.AwaitTask let! root = syntaxTree.GetRootAsync(ct) |> Async.AwaitTask let rec findInvocationContext (node: SyntaxNode): InvocationContext option = match node with | :? InvocationExpressionSyntax as invocation when invocation.ArgumentList.Span.Contains(position) -> Some { Receiver = invocation.Expression ArgumentTypes = invocation.ArgumentList.Arguments |> Seq.map (fun a -> semanticModel.GetTypeInfo(a.Expression)) |> List.ofSeq Separators = invocation.ArgumentList.Arguments.GetSeparators() |> List.ofSeq } | :? BaseObjectCreationExpressionSyntax as objectCreation when objectCreation.ArgumentList |> Option.ofObj |> Option.map (fun argList -> argList.Span.Contains(position)) |> Option.defaultValue false -> Some { Receiver = objectCreation ArgumentTypes = objectCreation.ArgumentList.Arguments |> Seq.map (fun a -> semanticModel.GetTypeInfo(a.Expression)) |> List.ofSeq Separators = objectCreation.ArgumentList.Arguments.GetSeparators() |> List.ofSeq } | :? AttributeSyntax as attributeSyntax when attributeSyntax.ArgumentList |> Option.ofObj |> Option.map (fun argList -> argList.Span.Contains(position)) |> Option.defaultValue false -> Some { Receiver = attributeSyntax ArgumentTypes = attributeSyntax.ArgumentList.Arguments |> Seq.map (fun a -> semanticModel.GetTypeInfo(a.Expression)) |> List.ofSeq Separators = attributeSyntax.ArgumentList.Arguments.GetSeparators() |> List.ofSeq } | _ -> node |> Option.ofObj |> Option.bind (fun node -> findInvocationContext node.Parent) match root.FindToken(position).Parent |> findInvocationContext with | None -> return None |> LspResult.success | Some invocation -> let methodGroup = semanticModel.GetMemberGroup(invocation.Receiver).OfType() |> List.ofSeq let matchingMethodMaybe = methodGroup |> Seq.map (fun m -> m, methodScore (invocation.ArgumentTypes) m) |> Seq.tryMaxBy snd |> Option.map fst let activeParameterMaybe = invocation.Separators |> List.tryFindIndex (fun comma -> comma.Span.Start >= position) |> Option.map uint let signatureHelpResult = { Signatures = methodGroup |> Seq.map SignatureInformation.fromMethod |> Array.ofSeq ActiveSignature = matchingMethodMaybe |> Option.map (fun m -> List.findIndex ((=) m) methodGroup |> uint32) ActiveParameter = activeParameterMaybe } return Some signatureHelpResult |> LspResult.success } csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/TextDocumentSync.fs000066400000000000000000000214331502617301100303200ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open System open Microsoft.CodeAnalysis.Text open Ionide.LanguageServerProtocol.Server open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer open CSharpLanguageServer.Conversions open CSharpLanguageServer.State open CSharpLanguageServer.State.ServerState open CSharpLanguageServer.Types open CSharpLanguageServer.RoslynHelpers open CSharpLanguageServer.Logging [] module TextDocumentSync = let private logger = LogProvider.getLoggerByName "TextDocumentSync" let private applyLspContentChangesOnRoslynSourceText (changes: TextDocumentContentChangeEvent[]) (initialSourceText: SourceText) = let applyLspContentChangeOnRoslynSourceText (sourceText: SourceText) (change: TextDocumentContentChangeEvent) = match change with | U2.C1 change -> let changeTextSpan = change.Range |> Range.toLinePositionSpan sourceText.Lines |> sourceText.Lines.GetTextSpan TextChange(changeTextSpan, change.Text) |> sourceText.WithChanges | U2.C2 changeWoRange -> SourceText.From(changeWoRange.Text) changes |> Seq.fold applyLspContentChangeOnRoslynSourceText initialSourceText let private dynamicRegistration (clientCapabilities: ClientCapabilities) = clientCapabilities.TextDocument |> Option.bind (fun x -> x.Synchronization) |> Option.bind (fun x -> x.DynamicRegistration) |> Option.defaultValue false let provider (clientCapabilities: ClientCapabilities) : TextDocumentSyncOptions option = match dynamicRegistration clientCapabilities with | true -> None | false -> Some { TextDocumentSyncOptions.Default with OpenClose = Some true Save = Some (U2.C2 { IncludeText = Some true }) Change = Some TextDocumentSyncKind.Incremental } let didOpenRegistration (clientCapabilities: ClientCapabilities) : Registration option = match dynamicRegistration clientCapabilities with | false -> None | true -> let registerOptions = { DocumentSelector = Some defaultDocumentSelector } Some { Id = Guid.NewGuid().ToString() Method = "textDocument/didOpen" RegisterOptions = registerOptions |> serialize |> Some } let didChangeRegistration (clientCapabilities: ClientCapabilities) : Registration option = match dynamicRegistration clientCapabilities with | false -> None | true -> let registerOptions = { DocumentSelector = Some defaultDocumentSelector SyncKind = TextDocumentSyncKind.Incremental } Some { Id = Guid.NewGuid().ToString() Method = "textDocument/didChange" RegisterOptions = registerOptions|> serialize |> Some } let didSaveRegistration (clientCapabilities: ClientCapabilities) : Registration option = match dynamicRegistration clientCapabilities with | false -> None | true -> let registerOptions = { DocumentSelector = Some defaultDocumentSelector IncludeText = Some true } Some { Id = Guid.NewGuid().ToString() Method = "textDocument/didSave" RegisterOptions = registerOptions |> serialize |> Some } let didCloseRegistration (clientCapabilities: ClientCapabilities) : Registration option = match dynamicRegistration clientCapabilities with | false -> None | true -> let registerOptions = { DocumentSelector = Some defaultDocumentSelector } Some { Id = Guid.NewGuid().ToString() Method = "textDocument/didClose" RegisterOptions = registerOptions |> serialize |> Some } let willSaveRegistration (_clientCapabilities: ClientCapabilities) : Registration option = None let willSaveWaitUntilRegistration (_clientCapabilities: ClientCapabilities) : Registration option = None let didOpen (context: ServerRequestContext) (openParams: DidOpenTextDocumentParams) : Async> = match context.GetDocumentForUriOfType AnyDocument openParams.TextDocument.Uri with | Some (doc, docType) -> match docType with | UserDocument -> // we want to load the document in case it has been changed since we have the solution loaded // also, as a bonus we can recover from corrupted document view in case document in roslyn solution // went out of sync with editor let updatedDoc = SourceText.From(openParams.TextDocument.Text) |> doc.WithText context.Emit(OpenDocAdd (openParams.TextDocument.Uri, openParams.TextDocument.Version, DateTime.Now)) context.Emit(SolutionChange updatedDoc.Project.Solution) Ok() |> async.Return | _ -> Ok() |> async.Return | None -> let docFilePathMaybe = Util.tryParseFileUri openParams.TextDocument.Uri match docFilePathMaybe with | Some docFilePath -> async { // ok, this document is not in solution, register a new document let! newDocMaybe = tryAddDocument logger docFilePath openParams.TextDocument.Text context.Solution match newDocMaybe with | Some newDoc -> context.Emit(OpenDocAdd (openParams.TextDocument.Uri, openParams.TextDocument.Version, DateTime.Now)) context.Emit(SolutionChange newDoc.Project.Solution) | None -> () return Ok() } | None -> Ok() |> async.Return let didChange (context: ServerRequestContext) (changeParams: DidChangeTextDocumentParams) : Async> = async { let docMaybe = context.GetUserDocument changeParams.TextDocument.Uri match docMaybe with | None -> () | Some doc -> let! ct = Async.CancellationToken let! sourceText = doc.GetTextAsync(ct) |> Async.AwaitTask //logMessage (sprintf "TextDocumentDidChange: changeParams: %s" (string changeParams)) //logMessage (sprintf "TextDocumentDidChange: sourceText: %s" (string sourceText)) let updatedSourceText = sourceText |> applyLspContentChangesOnRoslynSourceText changeParams.ContentChanges let updatedDoc = doc.WithText(updatedSourceText) //logMessage (sprintf "TextDocumentDidChange: newSourceText: %s" (string updatedSourceText)) let updatedSolution = updatedDoc.Project.Solution context.Emit(SolutionChange updatedSolution) context.Emit(OpenDocAdd (changeParams.TextDocument.Uri, changeParams.TextDocument.Version, DateTime.Now)) return Ok() } let didClose (context: ServerRequestContext) (closeParams: DidCloseTextDocumentParams) : Async> = context.Emit(OpenDocRemove closeParams.TextDocument.Uri) Ok() |> async.Return let willSave (_context: ServerRequestContext) (_p: WillSaveTextDocumentParams): Async> = async { return Ok () } let willSaveWaitUntil (_context: ServerRequestContext) (_p: WillSaveTextDocumentParams): AsyncLspResult = async { return LspResult.notImplemented } let didSave (context: ServerRequestContext) (saveParams: DidSaveTextDocumentParams) : Async> = // we need to add this file to solution if not already let doc = context.GetDocument saveParams.TextDocument.Uri match doc with | Some _ -> Ok() |> async.Return | None -> async { let docFilePath = Util.parseFileUri saveParams.TextDocument.Uri let! newDocMaybe = tryAddDocument logger docFilePath saveParams.Text.Value context.Solution match newDocMaybe with | Some newDoc -> context.Emit(OpenDocTouch (saveParams.TextDocument.Uri, DateTime.Now)) context.Emit(SolutionChange newDoc.Project.Solution) | None -> () return Ok() } csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/TypeDefinition.fs000066400000000000000000000050241502617301100277700ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open System open Microsoft.CodeAnalysis open Ionide.LanguageServerProtocol.Server open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer.Types open CSharpLanguageServer.State open CSharpLanguageServer.Util [] module TypeDefinition = let private dynamicRegistration (clientCapabilities: ClientCapabilities) : bool = clientCapabilities.TextDocument |> Option.bind (fun x -> x.TypeDefinition) |> Option.bind (fun x -> x.DynamicRegistration) |> Option.defaultValue false let provider (clientCapabilities: ClientCapabilities) : U3 option = match dynamicRegistration clientCapabilities with | true -> None | false -> Some (U3.C1 true) let registration (clientCapabilities: ClientCapabilities) : Registration option = match dynamicRegistration clientCapabilities with | false -> None | true -> let registerOptions: TypeDefinitionRegistrationOptions = { DocumentSelector = Some defaultDocumentSelector Id = None WorkDoneProgress = None } Some { Id = Guid.NewGuid().ToString() Method = "textDocument/typeDefinition" RegisterOptions = registerOptions |> serialize |> Some } let handle (context: ServerRequestContext) (p: TypeDefinitionParams) : Async option>> = async { match! context.FindSymbol' p.TextDocument.Uri p.Position with | None -> return None |> LspResult.success | Some (symbol, doc) -> let typeSymbol = match symbol with | :? ILocalSymbol as localSymbol -> [localSymbol.Type] | :? IFieldSymbol as fieldSymbol -> [fieldSymbol.Type] | :? IPropertySymbol as propertySymbol -> [propertySymbol.Type] | :? IParameterSymbol as parameterSymbol -> [parameterSymbol.Type] | _ -> [] let! locations = typeSymbol |> Seq.map (flip context.ResolveSymbolLocations (Some doc.Project)) |> Async.Parallel |> Async.map (Seq.collect id >> Seq.toArray) return locations |> Declaration.C2 |> U2.C1 |> Some |> LspResult.success } csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/TypeHierarchy.fs000066400000000000000000000100521502617301100276130ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open System open Microsoft.CodeAnalysis open Ionide.LanguageServerProtocol.Server open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer.Types open CSharpLanguageServer.State open CSharpLanguageServer.Conversions open CSharpLanguageServer.Util [] module TypeHierarchy = let private isTypeSymbol (symbol: ISymbol) = match symbol with | :? INamedTypeSymbol -> true | _ -> false let private dynamicRegistration (clientCapabilities: ClientCapabilities) = clientCapabilities.TextDocument |> Option.bind (fun x -> x.TypeHierarchy) |> Option.bind (fun x -> x.DynamicRegistration) |> Option.defaultValue false let provider (clientCapabilities: ClientCapabilities) : U3 option = match dynamicRegistration clientCapabilities with | true -> None | false -> Some (U3.C1 true) let registration (clientCapabilities: ClientCapabilities) : Registration option = match dynamicRegistration clientCapabilities with | false -> None | true -> let registerOptions: TypeHierarchyRegistrationOptions = { DocumentSelector = Some defaultDocumentSelector Id = None WorkDoneProgress = None } Some { Id = Guid.NewGuid().ToString() Method = "textDocument/prepareTypeHierarchy" RegisterOptions = registerOptions |> serialize |> Some } let prepare (context: ServerRequestContext) (p: TypeHierarchyPrepareParams) : AsyncLspResult = async { match! context.FindSymbol p.TextDocument.Uri p.Position with | Some symbol when isTypeSymbol symbol -> let! itemList = TypeHierarchyItem.fromSymbol context.ResolveSymbolLocations symbol return itemList |> List.toArray |> Some |> LspResult.success | _ -> return None |> LspResult.success } let supertypes (context: ServerRequestContext) (p: TypeHierarchySupertypesParams) : AsyncLspResult = async { match! context.FindSymbol p.Item.Uri p.Item.Range.Start with | Some symbol when isTypeSymbol symbol -> let typeSymbol = symbol :?> INamedTypeSymbol let baseType = typeSymbol.BaseType |> Option.ofObj |> Option.filter (fun sym -> sym.SpecialType = SpecialType.None) |> Option.toList let interfaces = Seq.toList typeSymbol.Interfaces let supertypes = baseType @ interfaces let! items = supertypes |> Seq.map (TypeHierarchyItem.fromSymbol context.ResolveSymbolLocations) |> Async.Parallel return items |> Seq.collect id |> Seq.toArray |> Some |> LspResult.success | _ -> return None |> LspResult.success } let subtypes (context: ServerRequestContext) (p: TypeHierarchySubtypesParams) : AsyncLspResult = async { match! context.FindSymbol p.Item.Uri p.Item.Range.Start with | Some symbol when isTypeSymbol symbol -> let typeSymbol = symbol :?> INamedTypeSymbol // We only want immediately derived classes/interfaces/implementations here (we only need // subclasses not subclasses' subclasses) let! subtypes = [ context.FindDerivedClasses' typeSymbol false context.FindDerivedInterfaces' typeSymbol false context.FindImplementations' typeSymbol false ] |> Async.Parallel |> Async.map (Seq.collect id >> Seq.toList) let! items = subtypes |> Seq.map (TypeHierarchyItem.fromSymbol context.ResolveSymbolLocations) |> Async.Parallel return items |> Seq.collect id |> Seq.toArray |> Some |> LspResult.success | _ -> return None |> LspResult.success } csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/Workspace.fs000066400000000000000000000115141502617301100267750ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open System open System.IO open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open Ionide.LanguageServerProtocol.Server open Microsoft.CodeAnalysis.Text open CSharpLanguageServer open CSharpLanguageServer.State open CSharpLanguageServer.State.ServerState open CSharpLanguageServer.RoslynHelpers open CSharpLanguageServer.Logging open CSharpLanguageServer.Types [] module Workspace = let private logger = LogProvider.getLoggerByName "Workspace" let dynamicRegistration (clientCapabilities: ClientCapabilities) = clientCapabilities.Workspace |> Option.bind (fun x -> x.DidChangeWatchedFiles) |> Option.bind (fun x -> x.DynamicRegistration) |> Option.defaultValue false let registration (clientCapabilities: ClientCapabilities): Registration option = match dynamicRegistration clientCapabilities with | false -> None | true -> let fileSystemWatcher = { GlobPattern = U2.C1 "**/*.{cs,csproj,sln,slnx}" Kind = Some (WatchKind.Create ||| WatchKind.Change ||| WatchKind.Delete) } let registerOptions: DidChangeWatchedFilesRegistrationOptions = { Watchers = [| fileSystemWatcher |] } Some { Id = Guid.NewGuid().ToString() Method = "workspace/didChangeWatchedFiles" RegisterOptions = registerOptions |> serialize |> Some } let private tryReloadDocumentOnUri logger (context: ServerRequestContext) uri = async { match context.GetUserDocument uri with | Some doc -> let fileText = uri |> Util.parseFileUri |> File.ReadAllText let updatedDoc = SourceText.From(fileText) |> doc.WithText context.Emit(SolutionChange updatedDoc.Project.Solution) | None -> let docFilePathMaybe = uri |> Util.tryParseFileUri match docFilePathMaybe with | Some docFilePath -> // ok, this document is not on solution, register a new one let fileText = docFilePath |> File.ReadAllText let! newDocMaybe = tryAddDocument logger docFilePath fileText context.Solution match newDocMaybe with | Some newDoc -> context.Emit(SolutionChange newDoc.Project.Solution) | None -> () | None -> () } let private removeDocument (context: ServerRequestContext) uri = match context.GetUserDocument uri with | Some existingDoc -> let updatedProject = existingDoc.Project.RemoveDocument(existingDoc.Id) context.Emit(SolutionChange updatedProject.Solution) context.Emit(OpenDocRemove uri) | None -> () let didChangeWatchedFiles (context: ServerRequestContext) (p: DidChangeWatchedFilesParams) : Async> = async { for change in p.Changes do match Path.GetExtension(change.Uri) with | ".csproj" -> do! context.WindowShowMessage "change to .csproj detected, will reload solution" context.Emit(SolutionReloadRequest (TimeSpan.FromSeconds(5:int64))) | ".sln" | ".slnx" -> do! context.WindowShowMessage "change to .sln detected, will reload solution" context.Emit(SolutionReloadRequest (TimeSpan.FromSeconds(5:int64))) | ".cs" -> match change.Type with | FileChangeType.Created -> do! tryReloadDocumentOnUri logger context change.Uri | FileChangeType.Changed -> do! tryReloadDocumentOnUri logger context change.Uri | FileChangeType.Deleted -> do removeDocument context change.Uri | _ -> () | _ -> () return Ok() } let didChangeConfiguration (context: ServerRequestContext) (configParams: DidChangeConfigurationParams) : Async> = async { let csharpSettings = configParams.Settings |> deserialize |> (fun x -> x.csharp) |> Option.defaultValue ServerSettingsCSharpDto.Default let newServerSettings = { context.State.Settings with SolutionPath = csharpSettings.solution ApplyFormattingOptions = csharpSettings.applyFormattingOptions |> Option.defaultValue false } context.Emit(SettingsChange newServerSettings) return Ok() } csharp-language-server-0.18.0/src/CSharpLanguageServer/Handlers/WorkspaceSymbol.fs000066400000000000000000000042641502617301100301670ustar00rootroot00000000000000namespace CSharpLanguageServer.Handlers open System open Microsoft.CodeAnalysis open Ionide.LanguageServerProtocol.Server open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open CSharpLanguageServer.State open CSharpLanguageServer.Conversions [] module WorkspaceSymbol = let private dynamicRegistration (clientCapabilities: ClientCapabilities) = clientCapabilities.TextDocument |> Option.bind (fun x -> x.Formatting) |> Option.bind (fun x -> x.DynamicRegistration) |> Option.defaultValue false let provider (clientCapabilities: ClientCapabilities) : U2 option = match dynamicRegistration clientCapabilities with | true -> None | false -> U2.C1 true |> Some let registration (clientCapabilities: ClientCapabilities) : Registration option = match dynamicRegistration clientCapabilities with | false -> None | true -> let registerOptions: WorkspaceSymbolRegistrationOptions = { ResolveProvider = Some true WorkDoneProgress = None } Some { Id = Guid.NewGuid().ToString() Method = "workspace/symbol" RegisterOptions = registerOptions |> serialize |> Some } let handle (context: ServerRequestContext) (p: WorkspaceSymbolParams) : AsyncLspResult option> = async { let pattern = if String.IsNullOrEmpty(p.Query) then None else Some p.Query let! symbols = context.FindSymbols pattern return symbols |> Seq.map (SymbolInformation.fromSymbol SymbolDisplayFormat.MinimallyQualifiedFormat) |> Seq.collect id // TODO: make 100 configurable? |> Seq.truncate 100 |> Seq.toArray |> U2.C1 |> Some |> LspResult.success } let resolve (_context: ServerRequestContext) (_p: WorkspaceSymbol) : AsyncLspResult = LspResult.notImplemented |> async.Return csharp-language-server-0.18.0/src/CSharpLanguageServer/Logging.fs000066400000000000000000001443031502617301100246700ustar00rootroot00000000000000// https://github.com/TheAngryByrd/FsLibLog/blob/64f118ae8df2f2944ef69758052cb3b148b87e79/src/FsLibLog/FsLibLog.fs namespace CSharpLanguageServer.Logging open System.Text.RegularExpressions [] module Types = open System type LogLevel = | Trace = 0 | Debug = 1 | Info = 2 | Warn = 3 | Error = 4 | Fatal = 5 /// An optional message thunk. /// /// - If None is provided, this typically signals to the logger to do a isEnabled check. /// - If Some is provided, this signals the logger to log. type MessageThunk = (unit -> string) option /// The signature of a log message function type Logger = LogLevel -> MessageThunk -> exn option -> obj array -> bool type MappedContext = string -> obj -> bool -> IDisposable /// Type representing a Log [] type Log = { LogLevel: LogLevel Message: MessageThunk Exception: exn option Parameters: obj list AdditionalNamedParameters: ((string * obj * bool) list) } static member StartLogLevel(logLevel: LogLevel) = { LogLevel = logLevel Message = None Exception = None Parameters = List.empty AdditionalNamedParameters = List.empty } /// An interface wrapper for aLogger. Useful when using depedency injection frameworks. type ILog = abstract member Log: Logger abstract member MappedContext: MappedContext #if FABLE_COMPILER // Fable doesn't support System.Collections.Generic.Stack, so this implementation (from FCS) // is used instead. type Stack<'a>() = let mutable contents = Array.zeroCreate<'a> (2) let mutable count = 0 member buf.Ensure newSize = let oldSize = contents.Length if newSize > oldSize then let old = contents contents <- Array.zeroCreate (max newSize (oldSize * 2)) Array.blit old 0 contents 0 count member buf.Count = count member buf.Pop() = let item = contents.[count - 1] count <- count - 1 item member buf.Peep() = contents.[count - 1] member buf.Top(n) = [ for x in contents.[max 0 (count - n) .. count - 1] -> x ] |> List.rev member buf.Push(x) = buf.Ensure(count + 1) contents.[count] <- x count <- count + 1 member buf.IsEmpty = (count = 0) #endif [] module Inner = #if !FABLE_COMPILER open System.Collections.Generic #endif /// /// DisposableStack on Dispose will call dispose on items appended to its stack in Last In First Out. /// type DisposableStack() = let stack = Stack() interface IDisposable with member __.Dispose() = while stack.Count > 0 do stack.Pop().Dispose() member __.Push(item: IDisposable) = stack.Push item member __.Push(items: IDisposable list) = items |> List.iter stack.Push static member Create(items: IDisposable list) = let ds = new DisposableStack() ds.Push items ds type ILog with /// /// Logs a log /// /// The type representing a log message to be logged /// if the log message was logged member logger.fromLog(log: Log) = use __ = log.AdditionalNamedParameters |> List.map (fun (key, value, destructure) -> logger.MappedContext key value destructure) // This stack is important, it causes us to unwind as if you have multiple uses in a row |> DisposableStack.Create log.Parameters |> List.toArray |> logger.Log log.LogLevel log.Message log.Exception /// /// Logs a fatal log message given a log configurer. /// /// A function to configure a log /// if the log message was logged member logger.fatal'(logConfig: Log -> Log) = Log.StartLogLevel LogLevel.Fatal |> logConfig |> logger.fromLog /// /// Logs a fatal log message given a log configurer. /// /// A function to configure a log member logger.fatal(logConfig: Log -> Log) = logger.fatal' logConfig |> ignore /// /// Logs an error log message given a log configurer. /// /// A function to configure a log /// if the log message was logged member logger.error'(logConfig: Log -> Log) = Log.StartLogLevel LogLevel.Error |> logConfig |> logger.fromLog /// /// Logs an error log message given a log configurer. /// /// A function to configure a log member logger.error(logConfig: Log -> Log) = logger.error' logConfig |> ignore /// /// Logs a warn log message given a log configurer. /// /// A function to configure a log /// if the log message was logged member logger.warn'(logConfig: Log -> Log) = Log.StartLogLevel LogLevel.Warn |> logConfig |> logger.fromLog /// /// Logs a warn log message given a log configurer. /// /// A function to configure a log member logger.warn(logConfig: Log -> Log) = logger.warn' logConfig |> ignore /// /// Logs an info log message given a log configurer. /// /// A function to configure a log /// if the log message was logged member logger.info'(logConfig: Log -> Log) = Log.StartLogLevel LogLevel.Info |> logConfig |> logger.fromLog /// /// Logs an info log message given a log configurer. /// /// A function to configure a log member logger.info(logConfig: Log -> Log) = logger.info' logConfig |> ignore /// /// Logs a debug log message given a log configurer. /// /// A function to configure a log /// if the log message was logged member logger.debug'(logConfig: Log -> Log) = Log.StartLogLevel LogLevel.Debug |> logConfig |> logger.fromLog /// /// Logs a debug log message given a log configurer. /// /// A function to configure a log member logger.debug(logConfig: Log -> Log) = logger.debug' logConfig |> ignore /// /// Logs a trace log message given a log configurer. /// /// A function to configure a log /// if the log message was logged member logger.trace'(logConfig: Log -> Log) = Log.StartLogLevel LogLevel.Trace |> logConfig |> logger.fromLog /// /// Logs a trace log message given a log configurer. /// /// A function to configure a log member logger.trace(logConfig: Log -> Log) = logger.trace' logConfig |> ignore /// An interface for retrieving a concrete logger such as Serilog, Nlog, etc. type ILogProvider = abstract member GetLogger: string -> Logger abstract member OpenNestedContext: string -> IDisposable abstract member OpenMappedContext: string -> obj -> bool -> IDisposable module Log = /// /// Amends a Log with a message. /// /// The message to set for the log. /// The log to amend. /// The amended log. let setMessage (message: string) (log: Log) = { log with Message = Some(fun () -> message) } /// /// Amends a Log with a message thunk. Useful for "expensive" string construction scenarios. /// /// The function that generates a message to add to a Log. /// The log to amend. /// The amended log. let setMessageThunk (messageThunk: unit -> string) (log: Log) = { log with Message = Some messageThunk } /// /// Amends a Log with a parameter. /// /// The value to add to the log /// The log to amend. /// The amended log. let addParameter (param: 'a) (log: Log) = { log with Parameters = List.append log.Parameters [ (box param) ] } /// /// Amends a Log with a list of parameters. /// /// The values to add to the log, in the form of an `obj list`. /// The log to amend. /// The amended log. let addParameters (``params``: obj list) (log: Log) = let ``params`` = ``params`` |> List.map box { log with Parameters = log.Parameters @ ``params`` } /// /// Amends a Log with additional named parameters for context. This helper adds more context to a log. /// This DOES NOT affect the parameters set for a message template. /// This is the same calling OpenMappedContext right before logging. /// /// The key of the parameter to add to the log. /// The value of the parameter to add to the log. /// The log to amend. /// The amended log. let addContext (key: string) (value: obj) (log: Log) = { log with AdditionalNamedParameters = List.append log.AdditionalNamedParameters [ key, (box value), false ] } /// /// Amends a Log with additional named parameters for context. This helper adds more context to a log. /// This DOES NOT affect the parameters set for a message template. /// This is the same calling OpenMappedContext right before logging. /// This destructures an object rather than calling `ToString()` on it. /// WARNING: Destructring can be expensive. /// /// The key of the parameter to add to the log. /// The value of the parameter to add to the log. /// The log to amend. /// The amended log. let addContextDestructured (key: string) (value: obj) (log: Log) = { log with AdditionalNamedParameters = List.append log.AdditionalNamedParameters [ key, (box value), true ] } /// /// Amends a Log with an exn. Handles nulls. /// /// The exception to add to the log. /// The log to amend. /// The amended log. let addException (``exception``: exn) (log: Log) = { log with Exception = Option.ofObj ``exception`` } /// /// Amends a Log with an exn. Handles nulls. /// /// The exception to add to the log. /// The log to amend. /// The amended log. let addExn (``exception``: exn) (log: Log) = addException ``exception`` log /// /// Amends a Log with a given LogLevel /// /// The level to set for the log. /// The log to amend. /// The amended log. let setLogLevel (logLevel: LogLevel) (log: Log) = { log with LogLevel = logLevel } #if !FABLE_COMPILER let private formatterRegex = Regex(@"(?\d+)(?:(?[^}]+))?}(?!})", RegexOptions.Compiled) let private isAnObject value = Convert.GetTypeCode(value) = TypeCode.Object /// /// Amends a Log with a given interpolated string. This will generate a message template from a special syntax within the interpolation. The syntax for the interplated string is $"I want to log {myVariable:MyLogVariableName}". /// /// This would be equivalent of calling (setMessage "I want to log {MyLogVariableName}" >> addContextDestructured "MyLogVariable" myVariable) /// /// An interpolated string /// The log to amend. /// The amended log. let setMessageInterpolated (message: FormattableString) (log: Log) = let mutable messageFormat = message.Format let args = formatterRegex.Matches(messageFormat) |> Seq.cast |> Seq.map (fun m -> let number = Int32.Parse(m.Groups.["number"].Value) let formatGroup = m.Groups.["format"] let propertyValue = message.GetArgument(number) let propertyName = formatGroup.Value let columnFormatGroup = m.Groups.["columnFormat"] propertyName, propertyValue, columnFormatGroup.Index, columnFormatGroup.Length ) // Reverse the args so we won't change the indexes earlier in the string args |> Seq.rev |> Seq.iter (fun (_, _, removeStart, removeLength) -> if removeLength > 0 then messageFormat <- messageFormat.Remove(removeStart, removeLength) ) let namedArgs = args |> Seq.map (fun (name, _, _, _) -> box $"{{{name}}}") |> Seq.toArray messageFormat <- messageFormat.Replace("{{", "{{{{").Replace("}}", "}}}}") // Replace numbered args with named args from regex match messageFormat <- String.Format(messageFormat, args = namedArgs) let addContexts args (log: Log) = let addArgsToContext = (id, args) ||> Seq.fold (fun state (name, value, _, _) -> let contextAdder = if value |> isAnObject then addContextDestructured else addContext state >> contextAdder name value ) addArgsToContext log log |> setMessage messageFormat |> addContexts args /// /// Amends a Log with a given interpolated string. This will generate a message template from a special syntax within the interpolation. The syntax for the interplated string is $"I want to log {myVariable:MyLogVariableName}". /// /// This would be equivalent of calling (setMessage "I want to log {MyLogVariableName}" >> addContextDestructured "MyLogVariable" myVariable) /// /// An interpolated string /// The log to amend. /// The amended log. let setMessageI (message: FormattableString) (log: Log) = setMessageInterpolated message log #endif /// Provides operators to make writing logs more streamlined. module Operators = /// /// Amend a log with a message. Wrapper for Log.setMessage. /// /// The string of the base message. /// A new Log instance with the specified message. let (!!!) message = Log.setMessage message /// /// Amends a log with a parameter. Wrapper for Log.addParameter. /// /// The Log to add the parameter to. /// The value for the parameter. /// The Log with the added parameter. let (>>!) log value = log >> Log.addParameter value /// /// Amends a Log with additional named parameters for context. This helper adds more context to a log. /// This DOES NOT affect the parameters set for a message template. This is the same calling OpenMappedContext right before logging. /// /// Wrapper for Log.addContext. /// /// The log to add the parameter to. /// The name for the parameter. /// The value for the parameter. /// The amended log with the parameter added. let (>>!-) log (key, value) = log >> Log.addContext key value /// /// Amends a Log with additional named parameters for context. This helper adds more context to a log. This DOES NOT affect the parameters set for a message template. /// This is the same calling OpenMappedContext right before logging. This destructures an object rather than calling ToString() on it. WARNING: Destructring can be expensive. /// /// Wrapper for Log.addContextDestructured. /// /// The log to add the parameter to. /// The name for the parameter. /// The value for the parameter. /// The amended log with the parameter added. let (>>!+) log (key, value) = log >> Log.addContextDestructured key value /// /// Amends a Log with an exn. Handles nulls. /// /// Wrapper for Log.addException. /// /// The log to add the parameter to. /// The exception to add to the log. /// The amended log with the parameter added. let (>>!!) log e = log >> Log.addException e #if !FABLE_COMPILER module Providers = module SerilogProvider = open System open System.Linq.Expressions let getLogManagerType () = Type.GetType("Serilog.Log, Serilog") let isAvailable () = getLogManagerType () |> isNull |> not let getPushProperty () = let ndcContextType = Type.GetType("Serilog.Context.LogContext, Serilog") |> Option.ofObj |> Option.defaultWith (fun () -> Type.GetType("Serilog.Context.LogContext, Serilog.FullNetFx")) () let pushPropertyMethod = ndcContextType.GetMethod( "PushProperty", [| typedefof typedefof typedefof |] ) let nameParam = Expression.Parameter(typedefof, "name") let valueParam = Expression.Parameter(typedefof, "value") let destructureObjectParam = Expression.Parameter(typedefof, "destructureObjects") let pushPropertyMethodCall = Expression.Call(null, pushPropertyMethod, nameParam, valueParam, destructureObjectParam) let pushProperty = Expression .Lambda>( pushPropertyMethodCall, nameParam, valueParam, destructureObjectParam ) .Compile() fun key value destructure -> pushProperty.Invoke(key, value, destructure) let getForContextMethodCall () = let logManagerType = getLogManagerType () let method = logManagerType.GetMethod( "ForContext", [| typedefof typedefof typedefof |] ) let propertyNameParam = Expression.Parameter(typedefof, "propertyName") let valueParam = Expression.Parameter(typedefof, "value") let destructureObjectsParam = Expression.Parameter(typedefof, "destructureObjects") let exrs: Expression[] = [| propertyNameParam valueParam destructureObjectsParam |] let methodCall = Expression.Call(null, method, exrs) let func = Expression .Lambda>( methodCall, propertyNameParam, valueParam, destructureObjectsParam ) .Compile() fun name -> func.Invoke("SourceContext", name, false) [] type SerilogGateway = { Write: obj -> obj -> string -> obj[] -> unit WriteException: obj -> obj -> exn -> string -> obj[] -> unit IsEnabled: obj -> obj -> bool TranslateLevel: LogLevel -> obj } static member Create() = let logEventLevelType = Type.GetType("Serilog.Events.LogEventLevel, Serilog") if (logEventLevelType |> isNull) then failwith ("Type Serilog.Events.LogEventLevel was not found.") let debugLevel = Enum.Parse(logEventLevelType, "Debug", false) let errorLevel = Enum.Parse(logEventLevelType, "Error", false) let fatalLevel = Enum.Parse(logEventLevelType, "Fatal", false) let informationLevel = Enum.Parse(logEventLevelType, "Information", false) let verboseLevel = Enum.Parse(logEventLevelType, "Verbose", false) let warningLevel = Enum.Parse(logEventLevelType, "Warning", false) let translateLevel (level: LogLevel) = match level with | LogLevel.Fatal -> fatalLevel | LogLevel.Error -> errorLevel | LogLevel.Warn -> warningLevel | LogLevel.Info -> informationLevel | LogLevel.Debug -> debugLevel | LogLevel.Trace -> verboseLevel | _ -> debugLevel let loggerType = Type.GetType("Serilog.ILogger, Serilog") if (loggerType |> isNull) then failwith ("Type Serilog.ILogger was not found.") let isEnabledMethodInfo = loggerType.GetMethod("IsEnabled", [| logEventLevelType |]) let instanceParam = Expression.Parameter(typedefof) let instanceCast = Expression.Convert(instanceParam, loggerType) let levelParam = Expression.Parameter(typedefof) let levelCast = Expression.Convert(levelParam, logEventLevelType) let isEnabledMethodCall = Expression.Call(instanceCast, isEnabledMethodInfo, levelCast) let isEnabled = Expression .Lambda>(isEnabledMethodCall, instanceParam, levelParam) .Compile() let writeMethodInfo = loggerType.GetMethod( "Write", [| logEventLevelType typedefof typedefof |] ) let messageParam = Expression.Parameter(typedefof) let propertyValuesParam = Expression.Parameter(typedefof) let writeMethodExp = Expression.Call(instanceCast, writeMethodInfo, levelCast, messageParam, propertyValuesParam) let expression = Expression.Lambda>( writeMethodExp, instanceParam, levelParam, messageParam, propertyValuesParam ) let write = expression.Compile() let writeExceptionMethodInfo = loggerType.GetMethod( "Write", [| logEventLevelType typedefof typedefof typedefof |] ) let exceptionParam = Expression.Parameter(typedefof) let writeMethodExp = Expression.Call( instanceCast, writeExceptionMethodInfo, levelCast, exceptionParam, messageParam, propertyValuesParam ) let writeException = Expression .Lambda>( writeMethodExp, instanceParam, levelParam, exceptionParam, messageParam, propertyValuesParam ) .Compile() { Write = (fun logger level message formattedParmeters -> write.Invoke(logger, level, message, formattedParmeters) ) WriteException = fun logger level ex message formattedParmeters -> writeException.Invoke(logger, level, ex, message, formattedParmeters) IsEnabled = fun logger level -> isEnabled.Invoke(logger, level) TranslateLevel = translateLevel } type private SeriLogProvider() = let getLoggerByName = getForContextMethodCall () let pushProperty = getPushProperty () let serilogGatewayInit = lazy (SerilogGateway.Create()) let writeMessage logger logLevel (messageFunc: MessageThunk) ``exception`` formatParams = let serilogGateway = serilogGatewayInit.Value let translatedValue = serilogGateway.TranslateLevel logLevel match messageFunc with | None -> serilogGateway.IsEnabled logger translatedValue | Some _ when serilogGateway.IsEnabled logger translatedValue |> not -> false | Some m -> match ``exception`` with | Some ex -> serilogGateway.WriteException logger translatedValue ex (m ()) formatParams | None -> serilogGateway.Write logger translatedValue (m ()) formatParams true interface ILogProvider with member this.GetLogger(name: string) : Logger = getLoggerByName name |> writeMessage member this.OpenMappedContext (key: string) (value: obj) (destructure: bool) : IDisposable = pushProperty key value destructure member this.OpenNestedContext(message: string) : IDisposable = pushProperty "NDC" message false let create () = SeriLogProvider() :> ILogProvider module MicrosoftExtensionsLoggingProvider = open System open System.Linq.Expressions open System.Reflection open System.Collections.Generic type ILoggerFactory = obj // This has to be set from usercode for this to light up let mutable private microsoftLoggerFactory: ILoggerFactory option = None let setMicrosoftLoggerFactory (factory: ILoggerFactory) = microsoftLoggerFactory <- Option.ofObj factory let getLogFactoryType = lazy (Type.GetType("Microsoft.Extensions.Logging.ILoggerFactory, Microsoft.Extensions.Logging.Abstractions")) let isAvailable () = getLogFactoryType.Value |> isNull |> not && microsoftLoggerFactory |> Option.isSome type ILogger = obj type LoggerName = string type MicrosoftLogLevel = obj type MessageFormat = string type MessageArgs = obj array [] type LoggerFactoryGateway = { CreateLogger: ILoggerFactory -> LoggerName -> ILogger } static member Create() = let createLogger = let factoryType = getLogFactoryType.Value let createLoggerMethodInfo = factoryType.GetMethod("CreateLogger", [| typedefof |]) let instanceParam = Expression.Parameter(typedefof) let nameParam = Expression.Parameter(typedefof) let instanceCast = Expression.Convert(instanceParam, factoryType) let createLoggerMethodExp = Expression.Call(instanceCast, createLoggerMethodInfo, nameParam) let createLogger = Expression .Lambda>( createLoggerMethodExp, instanceParam, nameParam ) .Compile() createLogger |> FuncConvert.FromFunc { CreateLogger = createLogger } type LoggerGateway = { Write: ILogger -> MicrosoftLogLevel -> MessageFormat -> MessageArgs -> unit WriteError: ILogger -> MicrosoftLogLevel -> exn -> MessageFormat -> MessageArgs -> unit IsEnabled: ILogger -> MicrosoftLogLevel -> bool TranslateLevel: LogLevel -> MicrosoftLogLevel BeginScope: ILogger -> obj -> IDisposable } static member Create() = let loggerExtensions = Type.GetType( "Microsoft.Extensions.Logging.LoggerExtensions, Microsoft.Extensions.Logging.Abstractions" ) let loggerType = Type.GetType("Microsoft.Extensions.Logging.ILogger, Microsoft.Extensions.Logging.Abstractions") let logEventLevelType = Type.GetType("Microsoft.Extensions.Logging.LogLevel, Microsoft.Extensions.Logging.Abstractions") let instanceParam = Expression.Parameter(typedefof) let instanceCast = Expression.Convert(instanceParam, loggerType) let levelParam = Expression.Parameter(typedefof) let levelCast = Expression.Convert(levelParam, logEventLevelType) let isEnabled = let isEnabledMethodInfo = loggerType.GetMethod("IsEnabled", [| logEventLevelType |]) let isEnabledMethodCall = Expression.Call(instanceCast, isEnabledMethodInfo, levelCast) Expression .Lambda>(isEnabledMethodCall, instanceParam, levelParam) .Compile() |> FuncConvert.FromFunc let write, writeError = let messageParam = Expression.Parameter(typedefof) let propertyValuesParam = Expression.Parameter(typedefof) let write = let writeMethodInfo = loggerExtensions.GetMethod( "Log", BindingFlags.Static ||| BindingFlags.Public, null, [| loggerType logEventLevelType typedefof typedefof |], null ) let writeMethodExp = Expression.Call( null, writeMethodInfo, instanceCast, levelCast, messageParam, propertyValuesParam ) let expression = Expression.Lambda>( writeMethodExp, instanceParam, levelParam, messageParam, propertyValuesParam ) expression.Compile() |> FuncConvert.FromAction let writeError = let writeMethodInfo = loggerExtensions.GetMethod( "Log", BindingFlags.Static ||| BindingFlags.Public, null, [| loggerType logEventLevelType typedefof typedefof typedefof |], null ) let exnParam = Expression.Parameter(typedefof) let writeMethodExp = Expression.Call( null, writeMethodInfo, instanceCast, levelCast, exnParam, messageParam, propertyValuesParam ) let expression = Expression.Lambda>( writeMethodExp, instanceParam, levelParam, exnParam, messageParam, propertyValuesParam ) expression.Compile() |> FuncConvert.FromAction write, writeError let translateLevel = let debugLevel = Enum.Parse(logEventLevelType, "Debug", false) let errorLevel = Enum.Parse(logEventLevelType, "Error", false) let criticalLevel = Enum.Parse(logEventLevelType, "Critical", false) let informationLevel = Enum.Parse(logEventLevelType, "Information", false) let traceLevel = Enum.Parse(logEventLevelType, "Trace", false) let warningLevel = Enum.Parse(logEventLevelType, "Warning", false) fun (level: LogLevel) -> match level with | LogLevel.Fatal -> criticalLevel | LogLevel.Error -> errorLevel | LogLevel.Warn -> warningLevel | LogLevel.Info -> informationLevel | LogLevel.Debug -> debugLevel | LogLevel.Trace -> traceLevel | _ -> debugLevel let beginScope = let beginScopeMethodInfo = loggerType.GetMethod("BeginScope").MakeGenericMethod(typedefof) let stateParam = Expression.Parameter(typedefof) let beginScopeMethodCall = Expression.Call(instanceCast, beginScopeMethodInfo, stateParam) Expression .Lambda>(beginScopeMethodCall, instanceParam, stateParam) .Compile() |> FuncConvert.FromFunc { Write = write WriteError = writeError IsEnabled = isEnabled TranslateLevel = translateLevel BeginScope = beginScope } type private MicrosoftProvider() = let factoryGateway = lazy (LoggerFactoryGateway.Create()) let loggerGateway = lazy (LoggerGateway.Create()) interface ILogProvider with member this.GetLogger(name: string) : Logger = match microsoftLoggerFactory with | None -> fun _ _ _ _ -> false | Some factory -> let logger = factoryGateway.Value.CreateLogger factory name fun logLevel message exn args -> let microsoftLevel = loggerGateway.Value.TranslateLevel logLevel match message with | Some message -> let message = message () match exn with | Some ex -> loggerGateway.Value.WriteError logger microsoftLevel ex message args | None -> loggerGateway.Value.Write logger microsoftLevel message args true | None -> loggerGateway.Value.IsEnabled logger microsoftLevel member this.OpenMappedContext (key: string) (value: obj) (destructure: bool) : IDisposable = match microsoftLoggerFactory with | None -> { new IDisposable with member x.Dispose() = () } | Some factory -> // Create bogus logger that will propagate to a real logger later let logger = factoryGateway.Value.CreateLogger factory (Guid.NewGuid().ToString()) // Requires a IEnumerable to make sense // https://nblumhardt.com/2016/11/ilogger-beginscope/ [ KeyValuePair(key, value) ] |> box |> loggerGateway.Value.BeginScope logger member this.OpenNestedContext(message: string) : IDisposable = match microsoftLoggerFactory with | None -> { new IDisposable with member x.Dispose() = () } | Some factory -> // Create bogus logger that will propagate to a real logger later let logger = factoryGateway.Value.CreateLogger factory (Guid.NewGuid().ToString()) loggerGateway.Value.BeginScope logger (box message) let create () = MicrosoftProvider() :> ILogProvider #endif module LogProvider = open System open Types #if !FABLE_COMPILER open Providers #endif open System.Diagnostics open Microsoft.FSharp.Quotations.Patterns let mutable private currentLogProvider = None let private knownProviders = [ #if !FABLE_COMPILER (SerilogProvider.isAvailable, SerilogProvider.create) (MicrosoftExtensionsLoggingProvider.isAvailable, MicrosoftExtensionsLoggingProvider.create) #endif ] /// Greedy search for first available LogProvider. Order of known providers matters. let private resolvedLogger = lazy (knownProviders |> Seq.tryFind (fun (isAvailable, _) -> isAvailable ()) |> Option.map (fun (_, create) -> create ())) let private noopLogger _ _ _ _ = false let private noopDisposable = { new IDisposable with member __.Dispose() = () } /// /// Allows custom override when a getLogger function searches for a LogProvider. /// /// The to set /// let setLoggerProvider (logProvider: ILogProvider) = currentLogProvider <- Some logProvider /// /// Gets the currently set LogProvider or attempts to find known built in providers /// /// let getCurrentLogProvider () = match currentLogProvider with | None -> resolvedLogger.Value | Some p -> Some p /// /// Opens a mapped diagnostic context. This will allow you to set additional parameters to a log given a scope. /// /// The name of the property. /// The value of the property. /// If true, and the value is a non-primitive, non-array type, then the value will be converted to a structure; otherwise, unknown types will be converted to scalars, which are generally stored as strings. WARNING: Destructring can be expensive. /// An IDisposable upon disposing will remove this value from a loggers scope let openMappedContextDestucturable (key: string) (value: obj) (destructureObjects: bool) = let provider = getCurrentLogProvider () match provider with | Some p -> p.OpenMappedContext key value destructureObjects | None -> noopDisposable /// /// Opens a mapped diagnostic context. This will allow you to set additional parameters to a log given a scope. Sets destructureObjects to false. /// /// The name of the property. /// The value of the property. /// An IDisposable upon disposing will remove this value from a loggers scope let openMappedContext (key: string) (value: obj) = //TODO: We should try to find out if the value is a primitive openMappedContextDestucturable key value false /// /// Opens a nested diagnostic context. This will allow you to set additional parameters to a log given a scope. /// /// The value of the property /// An IDisposable upon disposing will remove this value from a loggers scope let openNestedContext (value: string) = let provider = getCurrentLogProvider () match provider with | Some p -> p.OpenNestedContext value | None -> noopDisposable /// /// Creates a logger given a string. This will attempt to retrieve any loggers set with Log.setLoggerProvider. It will fallback to a known list of providers. /// /// A name to give a logger. This can help you identify the location of where the log occurred upon reviewing the logs. /// let getLoggerByName (name: string) = let loggerProvider = getCurrentLogProvider () let logFunc = match loggerProvider with | Some loggerProvider -> loggerProvider.GetLogger(name) | None -> noopLogger { new ILog with member x.Log = logFunc member x.MappedContext = openMappedContextDestucturable } /// /// Creates a logger given a Type. This will attempt to retrieve any loggers set with Log.setLoggerProvider. It will fallback to a known list of providers. /// /// The type to generate a logger name from. /// let getLoggerByType (objectType: Type) = objectType |> string |> getLoggerByName /// /// Creates a logger given a 'a type. This will attempt to retrieve any loggers set with Log.setLoggerProvider. It will fallback to a known list of providers. /// /// The type to generate a name from. /// let inline getLoggerFor<'a> () = getLoggerByType (typeof<'a>) #if !FABLE_COMPILER let rec private getModuleType = function | PropertyGet (_, propertyInfo, _) -> propertyInfo.DeclaringType // | Call (_, methInfo, _) -> sprintf "%s.%s" methInfo.DeclaringType.FullName methInfo.Name // | Lambda(_, expr) -> getModuleType expr // | ValueWithName(_,_,instance) -> instance | x -> failwithf "Expression is not a property. %A" x /// /// Creates a logger given a Quotations.Expr type. This is only useful for module level declarations. It uses the DeclaringType on the PropertyInfo of the PropertyGet. /// /// It can be utilized like: /// /// /// let rec logger = LogProvider.getLoggerByQuotation <@ logger @> /// /// /// inside a module to get the modules full qualitfied name. /// /// The quotation to generate a logger name from. /// let getLoggerByQuotation (quotation: Quotations.Expr) = getModuleType quotation |> getLoggerByType type LogProvider = /// /// Creates a logger based on `Reflection.MethodBase.GetCurrentMethod().FullName` and `CallerMemberName`. This is only useful for calls within functions. Results may vary on lambda and inlined functions. /// /// Do not pass anything to this parameter to get `CallerMemberName` to work. /// static member inline getLoggerByFunc([] ?memberName: string) = let mi = System.Reflection.MethodBase.GetCurrentMethod() // When we're in a CE we get something like `WebBackend.App+thingsToCall2@130`. // CallerMemberName gets us the function that actually called it // Splitting off + seems like the best option to get the Fully Qualified Path let location = mi.DeclaringType.FullName.Split('+') |> Seq.tryHead |> Option.defaultValue "" sprintf "%s.%s" location memberName.Value |> LogProvider.getLoggerByName #endif csharp-language-server-0.18.0/src/CSharpLanguageServer/LruCache.fs000066400000000000000000000015231502617301100247640ustar00rootroot00000000000000namespace CSharpLanguageServer // It's more OO than functional, but it makes user happier than a functional & immutable version. // In LSP, there will not be lot of cocurrent requests, so a simple cache based on LRU should be enough, and the size is // usually small. type LruCache<'entry>(size: int) = let lockObj : obj = new obj() let mutable key = 0UL let mutable list : (uint64 * 'entry) list = list.Empty member this.add(entry: 'entry) : uint64 = lock lockObj (fun () -> let k = key key <- key + 1UL list <- List.append list [(k, entry)] if List.length list > size then list <- List.tail list k) member this.get(key: uint64) : 'entry option = lock lockObj (fun () -> List.tryFind (fun (k, _) -> k = key) list |> Option.map snd) csharp-language-server-0.18.0/src/CSharpLanguageServer/Lsp/000077500000000000000000000000001502617301100235015ustar00rootroot00000000000000csharp-language-server-0.18.0/src/CSharpLanguageServer/Lsp/Client.fs000066400000000000000000000035201502617301100252510ustar00rootroot00000000000000namespace CSharpLanguageServer.Lsp open Ionide.LanguageServerProtocol open Ionide.LanguageServerProtocol.Server type CSharpLspClient(sendServerNotification: ClientNotificationSender, sendServerRequest: ClientRequestSender) = inherit LspClient() override __.WindowShowMessage(p) = sendServerNotification "window/showMessage" (box p) |> Async.Ignore // TODO: Send notifications / requests to client only if client support it override __.WindowShowMessageRequest(p) = sendServerRequest.Send "window/showMessageRequest" (box p) override __.WindowLogMessage(p) = sendServerNotification "window/logMessage" (box p) |> Async.Ignore override __.TelemetryEvent(p) = sendServerNotification "telemetry/event" (box p) |> Async.Ignore override __.ClientRegisterCapability(p) = sendServerRequest.Send "client/registerCapability" (box p) override __.ClientUnregisterCapability(p) = sendServerRequest.Send "client/unregisterCapability" (box p) override __.WorkspaceWorkspaceFolders() = sendServerRequest.Send "workspace/workspaceFolders" () override __.WorkspaceConfiguration(p) = sendServerRequest.Send "workspace/configuration" (box p) override __.WorkspaceApplyEdit(p) = sendServerRequest.Send "workspace/applyEdit" (box p) override __.WorkspaceSemanticTokensRefresh() = sendServerNotification "workspace/semanticTokens/refresh" () override __.TextDocumentPublishDiagnostics(p) = sendServerNotification "textDocument/publishDiagnostics" (box p) |> Async.Ignore override __.WindowWorkDoneProgressCreate(createParams) = sendServerRequest.Send "window/workDoneProgress/create" (box createParams) override __.Progress(progressParams) = sendServerNotification "$/progress" (box progressParams) |> Async.Ignore csharp-language-server-0.18.0/src/CSharpLanguageServer/Lsp/Server.fs000066400000000000000000000426321502617301100253100ustar00rootroot00000000000000namespace CSharpLanguageServer.Lsp open System open System.Diagnostics open System.Threading.Tasks open Ionide.LanguageServerProtocol.Mappings open Ionide.LanguageServerProtocol.Server open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc open StreamJsonRpc open CSharpLanguageServer.Types open CSharpLanguageServer.Handlers open CSharpLanguageServer.Logging open CSharpLanguageServer.State open CSharpLanguageServer.State.ServerState open CSharpLanguageServer.Util module LspUtils = /// Return the JSON-RPC "not implemented" error let notImplemented<'t> = async.Return LspResult.notImplemented<'t> /// Do nothing and ignore the notification let ignoreNotification: Async = async.Return(()) open LspUtils type CSharpLspServer( lspClient: CSharpLspClient, settings: ServerSettings ) = let _logger = LogProvider.getLoggerByName "Server" let stateActor = MailboxProcessor.Start( serverEventLoop { emptyServerState with Settings = settings }) let getDocumentForUriFromCurrentState docType uri = stateActor.PostAndAsyncReply(fun rc -> GetDocumentOfTypeForUri (docType, uri, rc)) let mutable timer: System.Threading.Timer option = None let setupTimer () = timer <- Some (new System.Threading.Timer( System.Threading.TimerCallback( fun _ -> do stateActor.Post(PeriodicTimerTick)), null, dueTime=100, period=250)) let mutable _workspaceFolders: WorkspaceFolder list = [] let withContext requestType (handlerFn: ServerRequestContext -> 'a -> Async>) param = let requestName = handlerFn.ToString() // we want to be careful and lock solution for change immediately w/o entering async/returing an `async` workflow // // StreamJsonRpc lib we're using in Ionide.LanguageServerProtocol guarantees that it will not call another // handler until previous one returns a Task (in our case -- F# `async` object.) let startRequest rc = StartRequest (requestName, requestType, 0, rc) let requestId, semaphore = stateActor.PostAndReply(startRequest) let stateAcquisitionAndHandlerInvocation = async { do! semaphore.WaitAsync() |> Async.AwaitTask let! state = stateActor.PostAndAsyncReply(GetState) let context = ServerRequestContext(requestId, state, stateActor.Post) return! handlerFn context param } let wrapExceptionAsLspResult op = async { let! resultOrExn = op |> Async.Catch return match resultOrExn with | Choice1Of2 result -> result | Choice2Of2 exn -> match exn with | :? TaskCanceledException -> LspResult.requestCancelled | :? OperationCanceledException -> LspResult.requestCancelled | _ -> LspResult.internalError (string exn) } stateAcquisitionAndHandlerInvocation |> wrapExceptionAsLspResult |> unwindProtect (fun () -> stateActor.Post(FinishRequest requestId)) let withReadOnlyContext handlerFn = withContext ReadOnly handlerFn let withReadWriteContext handlerFn = withContext ReadWrite handlerFn let ignoreResult handlerFn = async { let! _ = handlerFn return () } let getRegistrations (clientCapabilities: ClientCapabilities): Registration list = let registrationBuilders = [ CallHierarchy.registration CodeAction.registration CodeLens.registration Color.registration Completion.registration Declaration.registration Definition.registration Diagnostic.registration DocumentFormatting.registration DocumentHighlight.registration DocumentLink.registration DocumentOnTypeFormatting.registration DocumentRangeFormatting.registration DocumentSymbol.registration ExecuteCommand.registration FoldingRange.registration Hover.registration Implementation.registration InlayHint.registration InlineValue.registration LinkedEditingRange.registration Moniker.registration References.registration Rename.registration SelectionRange.registration SemanticTokens.registration SignatureHelp.registration TextDocumentSync.didOpenRegistration TextDocumentSync.didChangeRegistration TextDocumentSync.didSaveRegistration TextDocumentSync.didCloseRegistration TextDocumentSync.willSaveRegistration TextDocumentSync.willSaveWaitUntilRegistration TypeDefinition.registration TypeHierarchy.registration Workspace.registration WorkspaceSymbol.registration ] registrationBuilders |> List.map ((|>) clientCapabilities) |> List.filter (Option.isSome) |> List.map (Option.get) let getServerCapabilities (lspClient: InitializeParams) = { ServerCapabilities.Default with TextDocumentSync = TextDocumentSync.provider lspClient.Capabilities |> Option.map U2.C1 CompletionProvider = Completion.provider lspClient.Capabilities HoverProvider = Hover.provider lspClient.Capabilities SignatureHelpProvider = SignatureHelp.provider lspClient.Capabilities // DeclarationProvider = Declaration.provider lspClient.Capabilities DefinitionProvider = Definition.provider lspClient.Capabilities TypeDefinitionProvider = TypeDefinition.provider lspClient.Capabilities ImplementationProvider = Implementation.provider lspClient.Capabilities ReferencesProvider = References.provider lspClient.Capabilities DocumentHighlightProvider = DocumentHighlight.provider lspClient.Capabilities DocumentSymbolProvider = DocumentSymbol.provider lspClient.Capabilities CodeActionProvider = CodeAction.provider lspClient.Capabilities CodeLensProvider = CodeLens.provider lspClient.Capabilities // DocumentLinkProvider = DocumentLink.provider lspClient.Capabilities // ColorProvider = Color.provider lspClient.Capabilities DocumentFormattingProvider = DocumentFormatting.provider lspClient.Capabilities DocumentRangeFormattingProvider = DocumentRangeFormatting.provider lspClient.Capabilities DocumentOnTypeFormattingProvider = DocumentOnTypeFormatting.provider lspClient.Capabilities RenameProvider = Rename.provider lspClient.Capabilities // FoldingRangeProvider = FoldingRange.provider lspClient.Capabilities ExecuteCommandProvider = ExecuteCommand.provider lspClient.Capabilities // SelectionRangeProvider = SelectionRange.provider lspClient.Capabilities // LinkedEditingRangeProvider = LinkedEditingRange.provider lspClient.Capabilities CallHierarchyProvider = CallHierarchy.provider lspClient.Capabilities SemanticTokensProvider = SemanticTokens.provider lspClient.Capabilities // MonikerProvider = Moniker.provider lspClient.Capabilities TypeHierarchyProvider = TypeHierarchy.provider lspClient.Capabilities // InlineValueProvider = InlineValue.provider lspClient.Capabilities InlayHintProvider = InlayHint.provider lspClient.Capabilities DiagnosticProvider = Diagnostic.provider lspClient.Capabilities WorkspaceSymbolProvider = WorkspaceSymbol.provider lspClient.Capabilities } interface ICSharpLspServer with override __.Dispose() = () override __.Initialize(p) = let serverCapabilities = getServerCapabilities p p |> withReadWriteContext (Initialization.handleInitialize lspClient setupTimer serverCapabilities) override __.Initialized(_) = () |> withReadWriteContext (Initialization.handleInitialized lspClient stateActor getRegistrations) |> ignoreResult override __.Shutdown() = () |> withReadWriteContext Initialization.handleShutdown override __.Exit() = ignoreNotification override __.TextDocumentHover(p) = p |> withReadOnlyContext Hover.handle override __.TextDocumentDidOpen(p) = p |> withReadOnlyContext (TextDocumentSync.didOpen) |> ignoreResult override __.TextDocumentDidChange(p) = p |> withReadWriteContext (TextDocumentSync.didChange) |> ignoreResult override __.TextDocumentDidClose(p) = p |> withReadWriteContext (TextDocumentSync.didClose) |> ignoreResult override __.TextDocumentWillSave(p) = p |> withReadWriteContext TextDocumentSync.willSave |> ignoreResult override __.TextDocumentWillSaveWaitUntil(p) = p |> withReadWriteContext TextDocumentSync.willSaveWaitUntil override __.TextDocumentDidSave(p) = p |> withReadWriteContext (TextDocumentSync.didSave) |> ignoreResult override __.TextDocumentCompletion(p) = p |> withReadOnlyContext Completion.handle override __.CompletionItemResolve(p) = p |> withReadOnlyContext Completion.resolve override __.TextDocumentPrepareRename(p) = p |> withReadOnlyContext Rename.prepare override __.TextDocumentRename(p) = p |> withReadOnlyContext Rename.handle override __.TextDocumentDefinition(p) = p |> withReadOnlyContext Definition.handle override __.TextDocumentReferences(p) = p |> withReadOnlyContext References.handle override __.TextDocumentDocumentHighlight(p) = p |> withReadOnlyContext DocumentHighlight.handle override __.TextDocumentDocumentLink(p) = p |> withReadOnlyContext DocumentLink.handle override __.DocumentLinkResolve(p) = p |> withReadOnlyContext DocumentLink.resolve override __.TextDocumentTypeDefinition(p) = p |> withReadOnlyContext TypeDefinition.handle override __.TextDocumentImplementation(p) = p |> withReadOnlyContext Implementation.handle override __.TextDocumentCodeAction(p) = p |> withReadOnlyContext CodeAction.handle override __.CodeActionResolve(p) = p |> withReadOnlyContext CodeAction.resolve override __.TextDocumentCodeLens(p) = p |> withReadOnlyContext CodeLens.handle override __.CodeLensResolve(p) = p |> withReadOnlyContext CodeLens.resolve override __.TextDocumentSignatureHelp(p) = p |> withReadOnlyContext SignatureHelp.handle override __.TextDocumentDocumentColor(p) = p |> withReadOnlyContext Color.handle override __.TextDocumentColorPresentation(p) = p |> withReadOnlyContext Color.present override __.TextDocumentFormatting(p) = p |> withReadOnlyContext DocumentFormatting.handle override __.TextDocumentRangeFormatting(p) = p |> withReadOnlyContext DocumentRangeFormatting.handle override __.TextDocumentOnTypeFormatting(p) = p |> withReadOnlyContext DocumentOnTypeFormatting.handle override __.TextDocumentDocumentSymbol(p) = p |> withReadOnlyContext DocumentSymbol.handle override __.WorkspaceDidChangeWatchedFiles(p) = p |> withReadWriteContext Workspace.didChangeWatchedFiles |> ignoreResult override __.WorkspaceDidChangeWorkspaceFolders(_p) = ignoreNotification override __.WorkspaceDidChangeConfiguration(p) = p |> withReadWriteContext Workspace.didChangeConfiguration |> ignoreResult override __.WorkspaceWillCreateFiles(_) = notImplemented override __.WorkspaceDidCreateFiles(_) = ignoreNotification override __.WorkspaceWillRenameFiles(_) = notImplemented override __.WorkspaceDidRenameFiles(_) = ignoreNotification override __.WorkspaceWillDeleteFiles(_) = notImplemented override __.WorkspaceDidDeleteFiles(_) = ignoreNotification override __.WorkspaceSymbol(p) = p |> withReadOnlyContext WorkspaceSymbol.handle override __.WorkspaceExecuteCommand(p) = p |> withReadOnlyContext ExecuteCommand.handle override __.TextDocumentFoldingRange(p) = p |> withReadOnlyContext FoldingRange.handle override __.TextDocumentSelectionRange(p) = p |> withReadOnlyContext SelectionRange.handle override __.TextDocumentSemanticTokensFull(p) = p |> withReadOnlyContext SemanticTokens.handleFull override __.TextDocumentSemanticTokensFullDelta(p) = p |> withReadOnlyContext SemanticTokens.handleFullDelta override __.TextDocumentSemanticTokensRange(p) = p |> withReadOnlyContext SemanticTokens.handleRange override __.TextDocumentInlayHint(p) = p |> withReadOnlyContext InlayHint.handle override __.InlayHintResolve(p) = p |> withReadOnlyContext InlayHint.resolve override __.WindowWorkDoneProgressCancel (_) = raise (System.NotImplementedException()) override __.TextDocumentInlineValue(_) = notImplemented override __.TextDocumentPrepareCallHierarchy(p) = p |> withReadOnlyContext CallHierarchy.prepare override __.CallHierarchyIncomingCalls(p) = p |> withReadOnlyContext CallHierarchy.incomingCalls override __.CallHierarchyOutgoingCalls(p) = p |> withReadOnlyContext CallHierarchy.outgoingCalls override __.TextDocumentPrepareTypeHierarchy(p) = p |> withReadOnlyContext TypeHierarchy.prepare override __.TypeHierarchySupertypes(p) = p |> withReadOnlyContext TypeHierarchy.supertypes override __.TypeHierarchySubtypes(p) = p |> withReadOnlyContext TypeHierarchy.subtypes override __.TextDocumentDeclaration(p) = p |> withReadOnlyContext Declaration.handle override __.WorkspaceDiagnostic(p) = p |> withReadOnlyContext Diagnostic.handleWorkspaceDiagnostic override __.CancelRequest(_) = ignoreNotification override __.NotebookDocumentDidChange(_) = ignoreNotification override __.NotebookDocumentDidClose(_) = ignoreNotification override __.NotebookDocumentDidOpen(_) = ignoreNotification override __.NotebookDocumentDidSave(_) = ignoreNotification override __.WorkspaceSymbolResolve(p) = p |> withReadOnlyContext WorkspaceSymbol.resolve override __.TextDocumentDiagnostic(p) = p |> withReadOnlyContext Diagnostic.handle override __.TextDocumentLinkedEditingRange(p) = p |> withReadOnlyContext LinkedEditingRange.handle override __.TextDocumentMoniker(p) = p |> withReadOnlyContext Moniker.handle override __.Progress(_) = ignoreNotification override __.SetTrace(_) = ignoreNotification override __.CSharpMetadata(p) = p |> withReadOnlyContext CSharpMetadata.handle module Server = let logger = LogProvider.getLoggerByName "LSP" let private createRpc (handler: IJsonRpcMessageHandler) : JsonRpc = let rec (|HandleableException|_|) (e: exn) = match e with | :? LocalRpcException -> Some() | :? TaskCanceledException -> Some() | :? OperationCanceledException -> Some() | :? System.AggregateException as aex -> if aex.InnerExceptions.Count = 1 then (|HandleableException|_|) aex.InnerException else None | _ -> None { new JsonRpc(handler) with member _.IsFatalException(ex: Exception) = match ex with | HandleableException -> false | _ -> true } let private customRequestHandlings = // Compiler of F# can't infer the type of `s` in `"csharp/metadata", serverRequestHandling (fun s p -> s.CSharpMetadata(p))` // to `ICSharpLspServer` even if we have written the type of `customRequestHandlings` to // `Map>`. So write a helper function to avoid write the type of `s` every time. let requestHandling (run: ICSharpLspServer -> 'param -> AsyncLspResult<'result>) : ServerRequestHandling = serverRequestHandling run [ "csharp/metadata", requestHandling (fun s p -> s.CSharpMetadata(p)) ] |> Map.ofList // TODO: // 1. log the begin and end of request. // 2. if there is exception during the request, log it. let private requestHandlings = Map.union (defaultRequestHandlings ()) customRequestHandlings let startCore settings = use input = Console.OpenStandardInput() use output = Console.OpenStandardOutput() let serverCreator client = new CSharpLspServer(client, settings) :> ICSharpLspServer let clientCreator = fun (a, b) -> new CSharpLspClient(a, b) Ionide.LanguageServerProtocol.Server.start requestHandlings input output clientCreator serverCreator createRpc let start options = try let result = startCore options int result with ex -> logger.error ( Log.setMessage "{name} crashed:" >> Log.addContext "name" (Process.GetCurrentProcess().ProcessName) >> Log.addException ex ) 3 csharp-language-server-0.18.0/src/CSharpLanguageServer/Options.fs000066400000000000000000000011131502617301100247240ustar00rootroot00000000000000namespace CSharpLanguageServer module Options = open Argu type CLIArguments = | [] Version | [] LogLevel of level:string | [] Solution of solution:string with interface IArgParserTemplate with member s.Usage = match s with | Version -> "display versioning information" | Solution _ -> ".sln file to load (relative to CWD)" | LogLevel _ -> "log level, ; default is `log`" csharp-language-server-0.18.0/src/CSharpLanguageServer/Program.fs000066400000000000000000000046541502617301100247150ustar00rootroot00000000000000module CSharpLanguageServer.Program open System open System.Reflection open Argu open Serilog open Serilog.Core open Serilog.Events open CSharpLanguageServer.Types open CSharpLanguageServer.Lsp [] let entry args = try let argParser = ArgumentParser.Create(programName = "csharp-ls") let serverArgs = argParser.Parse args serverArgs.TryGetResult(<@ Options.CLIArguments.Version @>) |> Option.iter (fun _ -> printfn "csharp-ls, %s" (Assembly.GetExecutingAssembly().GetName().Version |> string) exit 0) let logLevelArg = serverArgs.TryGetResult(<@ Options.CLIArguments.LogLevel @>) |> Option.defaultValue "log" let logLevel = match logLevelArg with | "error" -> LogEventLevel.Error | "warning" -> LogEventLevel.Warning | "info" -> LogEventLevel.Information | "log" -> LogEventLevel.Verbose | _ -> LogEventLevel.Information let logConfig = LoggerConfiguration() .MinimumLevel.ControlledBy(LoggingLevelSwitch(logLevel)) .Enrich.FromLogContext() .WriteTo.Async(fun conf -> conf.Console( outputTemplate = "[{Timestamp:HH:mm:ss.fff} {Level:u3}] [{SourceContext}] {Message:lj}{NewLine}{Exception}", // Redirect all logs to stderr since stdout is used to communicate with client. standardErrorFromLevel = Nullable<_>(LogEventLevel.Verbose), theme = Serilog.Sinks.SystemConsole.Themes.AnsiConsoleTheme.Code ) |> ignore) Log.Logger <- logConfig.CreateLogger() let settings = { ServerSettings.Default with SolutionPath = serverArgs.TryGetResult(<@ Options.CLIArguments.Solution @>) LogLevel = logLevelArg } Server.start settings with | :? ArguParseException as ex -> printfn "%s" ex.Message match ex.ErrorCode with | ErrorCode.HelpText -> 0 | _ -> 1 // Unrecognised arguments | e -> printfn "Server crashing error - %s \n %s" e.Message e.StackTrace 3 csharp-language-server-0.18.0/src/CSharpLanguageServer/ProgressReporter.fs000066400000000000000000000031631502617301100266270ustar00rootroot00000000000000namespace CSharpLanguageServer open System open Ionide.LanguageServerProtocol open Ionide.LanguageServerProtocol.Server open Ionide.LanguageServerProtocol.Types type ProgressReporter(client: ILspClient) = let mutable canReport = false let mutable endSent = false member val Token = ProgressToken.C2 (Guid.NewGuid().ToString()) member this.Begin(title, ?cancellable, ?message, ?percentage) = async { let! progressCreateResult = client.WindowWorkDoneProgressCreate({ Token = this.Token }) match progressCreateResult with | Error _ -> canReport <- false | Ok() -> canReport <- true let param = WorkDoneProgressBegin.Create( title = title, ?cancellable = cancellable, ?message = message, ?percentage = percentage ) do! client.Progress({ Token = this.Token; Value = serialize param }) } member this.Report(?cancellable, ?message, ?percentage) = async { if canReport && not endSent then let param = WorkDoneProgressReport.Create( ?cancellable = cancellable, ?message = message, ?percentage = percentage ) do! client.Progress({ Token = this.Token; Value = serialize param }) } member this.End(?message) = async { if canReport && not endSent then endSent <- true let param = WorkDoneProgressEnd.Create( ?message = message ) do! client.Progress({ Token = this.Token; Value = serialize param }) } csharp-language-server-0.18.0/src/CSharpLanguageServer/README.md000077700000000000000000000000001502617301100261222../../README.mdustar00rootroot00000000000000csharp-language-server-0.18.0/src/CSharpLanguageServer/RoslynHelpers.fs000066400000000000000000000777701502617301100261300ustar00rootroot00000000000000module CSharpLanguageServer.RoslynHelpers open System open System.Collections.Generic open System.IO open System.Reflection open System.Threading open System.Threading.Tasks open System.Collections.Immutable open System.Text.RegularExpressions open Castle.DynamicProxy open ICSharpCode.Decompiler open ICSharpCode.Decompiler.CSharp open ICSharpCode.Decompiler.CSharp.Transforms open Ionide.LanguageServerProtocol open Ionide.LanguageServerProtocol.Types open Microsoft.Build.Exceptions open Microsoft.CodeAnalysis open Microsoft.CodeAnalysis.CSharp open Microsoft.CodeAnalysis.CSharp.Syntax open Microsoft.CodeAnalysis.Host open Microsoft.CodeAnalysis.Host.Mef open Microsoft.CodeAnalysis.MSBuild open Microsoft.CodeAnalysis.Text open CSharpLanguageServer open CSharpLanguageServer.Conversions open CSharpLanguageServer.Logging type DocumentSymbolCollectorForMatchingSymbolName (documentUri, sym: ISymbol) = inherit CSharpSyntaxWalker(SyntaxWalkerDepth.Token) let mutable collectedLocations = [] let mutable suggestedLocations = [] let collectIdentifier (identifier: SyntaxToken) exactMatch = let location: Types.Location = { Uri = documentUri Range = identifier.GetLocation().GetLineSpan().Span |> Range.fromLinePositionSpan } if exactMatch then collectedLocations <- location :: collectedLocations else suggestedLocations <- location :: suggestedLocations member __.GetLocations() = if not (Seq.isEmpty collectedLocations) then collectedLocations |> Seq.rev |> List.ofSeq else suggestedLocations |> Seq.rev |> List.ofSeq override __.Visit(node) = if sym.Kind = SymbolKind.Method then if node :? MethodDeclarationSyntax then let nodeMethodDecl = node :?> MethodDeclarationSyntax if nodeMethodDecl.Identifier.ValueText = sym.Name then let methodArityMatches = let symMethod = sym :?> IMethodSymbol symMethod.Parameters.Length = nodeMethodDecl.ParameterList.Parameters.Count collectIdentifier nodeMethodDecl.Identifier methodArityMatches else if node :? TypeDeclarationSyntax then let typeDecl = node :?> TypeDeclarationSyntax if typeDecl.Identifier.ValueText = sym.Name then collectIdentifier typeDecl.Identifier false else if node :? PropertyDeclarationSyntax then let propertyDecl = node :?> PropertyDeclarationSyntax if propertyDecl.Identifier.ValueText = sym.Name then collectIdentifier propertyDecl.Identifier false else if node :? EventDeclarationSyntax then let eventDecl = node :?> EventDeclarationSyntax if eventDecl.Identifier.ValueText = sym.Name then collectIdentifier eventDecl.Identifier false // TODO: collect other type of syntax nodes too base.Visit(node) type CleanCodeGenerationOptionsProviderInterceptor (_logMessage) = interface IInterceptor with member __.Intercept(invocation: IInvocation) = match invocation.Method.Name with "GetCleanCodeGenerationOptionsAsync" -> let workspacesAssembly = Assembly.Load("Microsoft.CodeAnalysis.Workspaces") let cleanCodeGenOptionsType = workspacesAssembly.GetType("Microsoft.CodeAnalysis.CodeGeneration.CleanCodeGenerationOptions") let methodGetDefault = cleanCodeGenOptionsType.GetMethod("GetDefault") let argLanguageServices = invocation.Arguments[0] let defaultCleanCodeGenOptions = methodGetDefault.Invoke(null, [| argLanguageServices |]) let valueTaskType = typedefof> let valueTaskTypeForCleanCodeGenOptions = valueTaskType.MakeGenericType([| cleanCodeGenOptionsType |]) invocation.ReturnValue <- Activator.CreateInstance(valueTaskTypeForCleanCodeGenOptions, defaultCleanCodeGenOptions) | _ -> NotImplementedException(string invocation.Method) |> raise type LegacyWorkspaceOptionServiceInterceptor (logMessage) = interface IInterceptor with member __.Intercept(invocation: IInvocation) = //logMessage (sprintf "LegacyWorkspaceOptionServiceInterceptor: %s" (string invocation.Method)) match invocation.Method.Name with | "RegisterWorkspace" -> () | "GetGenerateEqualsAndGetHashCodeFromMembersGenerateOperators" -> invocation.ReturnValue <- box true | "GetGenerateEqualsAndGetHashCodeFromMembersImplementIEquatable" -> invocation.ReturnValue <- box true | "GetGenerateConstructorFromMembersOptionsAddNullChecks" -> invocation.ReturnValue <- box true | "get_GenerateOverrides" -> invocation.ReturnValue <- box true | "get_CleanCodeGenerationOptionsProvider" -> let workspacesAssembly = Assembly.Load("Microsoft.CodeAnalysis.Workspaces") let cleanCodeGenOptionsProvType = workspacesAssembly.GetType("Microsoft.CodeAnalysis.CodeGeneration.AbstractCleanCodeGenerationOptionsProvider") let generator = ProxyGenerator() let interceptor = CleanCodeGenerationOptionsProviderInterceptor(logMessage) let proxy = generator.CreateClassProxy(cleanCodeGenOptionsProvType, interceptor) invocation.ReturnValue <- proxy | _ -> NotImplementedException(string invocation.Method) |> raise type PickMembersServiceInterceptor (_logMessage) = interface IInterceptor with member __.Intercept(invocation: IInvocation) = match invocation.Method.Name with | "PickMembers" -> let argMembers = invocation.Arguments[1] let argOptions = invocation.Arguments[2] let pickMembersResultType = invocation.Method.ReturnType invocation.ReturnValue <- Activator.CreateInstance(pickMembersResultType, argMembers, argOptions, box true) | _ -> NotImplementedException(string invocation.Method) |> raise type ExtractClassOptionsServiceInterceptor (_logMessage) = let getExtractClassOptionsImpl(argOriginalType: INamedTypeSymbol): Object = let featuresAssembly = Assembly.Load("Microsoft.CodeAnalysis.Features") let typeName = "Base" + argOriginalType.Name let fileName = typeName + ".cs" let sameFile = box true let immArrayType = typeof let extractClassMemberAnalysisResultType = featuresAssembly.GetType("Microsoft.CodeAnalysis.ExtractClass.ExtractClassMemberAnalysisResult") let resultListType = typedefof>.MakeGenericType(extractClassMemberAnalysisResultType) let resultList = Activator.CreateInstance(resultListType) let memberFilter (m: ISymbol) = match m with | :? IMethodSymbol as ms -> ms.MethodKind = MethodKind.Ordinary | :? IFieldSymbol as fs -> not fs.IsImplicitlyDeclared | _ -> m.Kind = SymbolKind.Property || m.Kind = SymbolKind.Event let selectedMembersToAdd = argOriginalType.GetMembers() |> Seq.filter memberFilter for memberToAdd in selectedMembersToAdd do let memberAnalysisResult = Activator.CreateInstance(extractClassMemberAnalysisResultType, memberToAdd, false) resultListType.GetMethod("Add").Invoke(resultList, [| memberAnalysisResult |]) |> ignore let resultListAsArray = resultListType.GetMethod("ToArray").Invoke(resultList, null) let immArrayCreateFromArray = immArrayType.GetMethods() |> Seq.filter (fun m -> m.GetParameters().Length = 1 && (m.GetParameters()[0]).ParameterType.IsArray) |> Seq.head let emptyMemberAnalysisResults = immArrayCreateFromArray.MakeGenericMethod([| extractClassMemberAnalysisResultType |]).Invoke(null, [| resultListAsArray |]) let extractClassOptionsType = featuresAssembly.GetType("Microsoft.CodeAnalysis.ExtractClass.ExtractClassOptions") Activator.CreateInstance( extractClassOptionsType, fileName, typeName, sameFile, emptyMemberAnalysisResults) interface IInterceptor with member __.Intercept(invocation: IInvocation) = match invocation.Method.Name with | "GetExtractClassOptionsAsync" -> let argOriginalType = invocation.Arguments[1] :?> INamedTypeSymbol let extractClassOptionsValue = getExtractClassOptionsImpl(argOriginalType) let fromResultMethod = typeof.GetMethod("FromResult") let typedFromResultMethod = fromResultMethod.MakeGenericMethod([| extractClassOptionsValue.GetType() |]) invocation.ReturnValue <- typedFromResultMethod.Invoke(null, [| extractClassOptionsValue |]) | "GetExtractClassOptions" -> let argOriginalType = invocation.Arguments[1] :?> INamedTypeSymbol invocation.ReturnValue <- getExtractClassOptionsImpl(argOriginalType) | _ -> NotImplementedException(string invocation.Method) |> raise type ExtractInterfaceOptionsServiceInterceptor (logMessage) = interface IInterceptor with member __.Intercept(invocation: IInvocation) = match invocation.Method.Name with | "GetExtractInterfaceOptionsAsync" -> let argExtractableMembers = invocation.Arguments[2] :?> List let argDefaultInterfaceName = invocation.Arguments[3] :?> string let fileName = sprintf "%s.cs" argDefaultInterfaceName let featuresAssembly = Assembly.Load("Microsoft.CodeAnalysis.Features") let extractInterfaceOptionsResultType = featuresAssembly.GetType("Microsoft.CodeAnalysis.ExtractInterface.ExtractInterfaceOptionsResult") let locationEnumType = extractInterfaceOptionsResultType.GetNestedType("ExtractLocation") let location = Enum.Parse(locationEnumType, "NewFile") // or "SameFile" let workspacesAssembly = Assembly.Load("Microsoft.CodeAnalysis.Workspaces") let cleanCodeGenOptionsProvType = workspacesAssembly.GetType("Microsoft.CodeAnalysis.CodeGeneration.AbstractCleanCodeGenerationOptionsProvider") let generator = ProxyGenerator() let interceptor = CleanCodeGenerationOptionsProviderInterceptor(logMessage) let cleanCodeGenerationOptionsProvider = generator.CreateClassProxy(cleanCodeGenOptionsProvType, interceptor) let extractInterfaceOptionsResultValue = Activator.CreateInstance( extractInterfaceOptionsResultType, false, // isCancelled argExtractableMembers.ToImmutableArray(), argDefaultInterfaceName, fileName, location, cleanCodeGenerationOptionsProvider) let fromResultMethod = typeof.GetMethod("FromResult") let typedFromResultMethod = fromResultMethod.MakeGenericMethod([| extractInterfaceOptionsResultType |]) invocation.ReturnValue <- typedFromResultMethod.Invoke(null, [| extractInterfaceOptionsResultValue |]) | _ -> NotImplementedException(string invocation.Method.Name) |> raise type MoveStaticMembersOptionsServiceInterceptor (_logMessage) = interface IInterceptor with member __.Intercept(invocation: IInvocation) = match invocation.Method.Name with | "GetMoveMembersToTypeOptions" -> let _argDocument = invocation.Arguments[0] :?> Document let _argOriginalType = invocation.Arguments[1] :?> INamedTypeSymbol let argSelectedMembers = invocation.Arguments[2] :?> ImmutableArray let featuresAssembly = Assembly.Load("Microsoft.CodeAnalysis.Features") let msmOptionsType = featuresAssembly.GetType("Microsoft.CodeAnalysis.MoveStaticMembers.MoveStaticMembersOptions") let newStaticClassName = "NewStaticClass" let msmOptions = Activator.CreateInstance( msmOptionsType, newStaticClassName + ".cs", newStaticClassName, argSelectedMembers, false |> box) invocation.ReturnValue <- msmOptions | _ -> NotImplementedException(string invocation.Method) |> raise type RemoteHostClientProviderInterceptor (_logMessage) = interface IInterceptor with member __.Intercept(invocation: IInvocation) = match invocation.Method.Name with | "TryGetRemoteHostClientAsync" -> let workspacesAssembly = Assembly.Load("Microsoft.CodeAnalysis.Workspaces") let remoteHostClientType = workspacesAssembly.GetType("Microsoft.CodeAnalysis.Remote.RemoteHostClient") let methodInfo = typeof.GetMethod("FromResult", BindingFlags.Static ||| BindingFlags.Public) let genericMethod = methodInfo.MakeGenericMethod(remoteHostClientType) let nullResultTask = genericMethod.Invoke(null, [| null |]) invocation.ReturnValue <- nullResultTask | _ -> NotImplementedException(string invocation.Method) |> raise type WorkspaceServicesInterceptor () = let logger = LogProvider.getLoggerByName "WorkspaceServicesInterceptor" interface IInterceptor with member __.Intercept(invocation: IInvocation) = invocation.Proceed() if invocation.Method.Name = "GetService" && invocation.ReturnValue = null then let updatedReturnValue = let serviceType = invocation.GenericArguments[0] let generator = ProxyGenerator() match serviceType.FullName with | "Microsoft.CodeAnalysis.Options.ILegacyGlobalOptionsWorkspaceService" -> let interceptor = LegacyWorkspaceOptionServiceInterceptor() generator.CreateInterfaceProxyWithoutTarget(serviceType, interceptor) | "Microsoft.CodeAnalysis.PickMembers.IPickMembersService" -> let interceptor = PickMembersServiceInterceptor() generator.CreateInterfaceProxyWithoutTarget(serviceType, interceptor) | "Microsoft.CodeAnalysis.ExtractClass.IExtractClassOptionsService" -> let interceptor = ExtractClassOptionsServiceInterceptor() generator.CreateInterfaceProxyWithoutTarget(serviceType, interceptor) | "Microsoft.CodeAnalysis.ExtractInterface.IExtractInterfaceOptionsService" -> let interceptor = ExtractInterfaceOptionsServiceInterceptor() generator.CreateInterfaceProxyWithoutTarget(serviceType, interceptor) | "Microsoft.CodeAnalysis.MoveStaticMembers.IMoveStaticMembersOptionsService" -> let interceptor = MoveStaticMembersOptionsServiceInterceptor() generator.CreateInterfaceProxyWithoutTarget(serviceType, interceptor) | "Microsoft.CodeAnalysis.Remote.IRemoteHostClientProvider" -> let interceptor = RemoteHostClientProviderInterceptor() generator.CreateInterfaceProxyWithoutTarget(serviceType, interceptor) | "Microsoft.CodeAnalysis.SourceGeneratorTelemetry.ISourceGeneratorTelemetryCollectorWorkspaceService" | "Microsoft.CodeAnalysis.CodeRefactorings.PullMemberUp.Dialog.IPullMemberUpOptionsService" | "Microsoft.CodeAnalysis.Packaging.IPackageInstallerService" -> // supress "GetService failed" messages for these services null | _ -> logger.debug ( Log.setMessage "GetService failed for {serviceType}" >> Log.addContext "serviceType" (serviceType.FullName) ) null invocation.ReturnValue <- updatedReturnValue type CSharpLspHostServices () = inherit HostServices() member private this.hostServices = MSBuildMefHostServices.DefaultServices override this.CreateWorkspaceServices (workspace: Workspace) = // Ugly but we can't: // 1. use Castle since there is no default constructor of MefHostServices. // 2. call this.hostServices.CreateWorkspaceServices directly since it's internal. let methodInfo = this.hostServices.GetType().GetMethod("CreateWorkspaceServices", BindingFlags.Instance|||BindingFlags.NonPublic) let services = methodInfo.Invoke(this.hostServices, [| workspace |]) |> Unchecked.unbox let generator = ProxyGenerator() let interceptor = WorkspaceServicesInterceptor() generator.CreateClassProxyWithTarget(services, interceptor) let loadProjectFilenamesFromSolution (solutionPath: string) = assert Path.IsPathRooted(solutionPath) let projectFilenames = new List() let solutionFile = Microsoft.Build.Construction.SolutionFile.Parse(solutionPath) for project in solutionFile.ProjectsInOrder do if project.ProjectType = Microsoft.Build.Construction.SolutionProjectType.KnownToBeMSBuildFormat then projectFilenames.Add(project.AbsolutePath) projectFilenames |> Set.ofSeq type TfmCategory = | NetFramework of Version | NetStandard of Version | NetCoreApp of Version | Net of Version | Unknown let selectMostCapableCompatibleTfm (tfms: string seq) : string option = let parseTfm (tfm: string) : TfmCategory = let patterns = [ @"^net(?\d)(?\d)?(?\d)?$", NetFramework @"^netstandard(?\d+)\.(?\d+)$", NetStandard @"^netcoreapp(?\d+)\.(?\d+)$", NetCoreApp @"^net(?\d+)\.(?\d+)$", Net ] let matchingTfmCategory (pat, categoryCtor) = let m = Regex.Match(tfm.ToLowerInvariant(), pat) if m.Success then let readVersionNum (groupName: string) = let group = m.Groups.[groupName] if group.Success then (int group.Value) else 0 Version(readVersionNum "major", readVersionNum "minor", readVersionNum "build") |> categoryCtor |> Some else None patterns |> List.tryPick matchingTfmCategory |> Option.defaultValue Unknown let rankTfm = function | Net v -> 3000 + v.Major * 10 + v.Minor | NetCoreApp v -> 2000 + v.Major * 10 + v.Minor | NetStandard v -> 1000 + v.Major * 10 + v.Minor | NetFramework v -> 0 + v.Major * 10 + v.Minor | Unknown -> -1 tfms |> Seq.sortByDescending (parseTfm >> rankTfm) |> Seq.tryHead let applyWorkspaceTargetFrameworkProp (logger: ILog) (projs: string seq) props = let tfms = new List() for projectFilename in projs do let projectCollection = new Microsoft.Build.Evaluation.ProjectCollection(); let props = new Dictionary(); try let buildProject = projectCollection.LoadProject(projectFilename, props, toolsVersion=null) let noneIfEmpty s = s |> Option.ofObj |> Option.bind (fun s -> if String.IsNullOrEmpty(s) then None else Some s) let targetFramework = buildProject.GetPropertyValue("TargetFramework") |> noneIfEmpty match targetFramework with | Some tfm -> tfms.Add(tfm.Trim()) | _ -> () let targetFrameworks = buildProject.GetPropertyValue("TargetFrameworks") |> noneIfEmpty match targetFrameworks with | Some semicolonSeparatedTfms -> for tfm in semicolonSeparatedTfms.Split(";") do tfms.Add(tfm.Trim()) | _ -> () projectCollection.UnloadProject(buildProject) with | :? InvalidProjectFileException as ipfe -> logger.debug ( Log.setMessage "applyWorkspaceTargetFrameworkProp: failed to load {projectFilename}: {ex}" >> Log.addContext "projectFilename" projectFilename >> Log.addContext "ex" (string ipfe) ) let distinctTfms = tfms |> Set.ofSeq logger.debug ( Log.setMessage "applyWorkspaceTargetFrameworkProp: distinctTfms={distinctTfms}" >> Log.addContext "distinctTfms" (String.Join(";", distinctTfms)) ) match distinctTfms.Count with | 0 -> props | 1 -> props | _ -> match selectMostCapableCompatibleTfm distinctTfms with | Some tfm -> props |> Map.add "TargetFramework" tfm | None -> props let resolveDefaultWorkspaceProps (logger: ILog) projs : Map = Map.empty |> applyWorkspaceTargetFrameworkProp logger projs let tryLoadSolutionOnPath (lspClient: ILspClient) (logger: ILog) (solutionPath: string) = assert Path.IsPathRooted(solutionPath) let progress = ProgressReporter(lspClient) let logMessage m = lspClient.WindowLogMessage({ Type = MessageType.Info Message = sprintf "csharp-ls: %s" m }) let showMessage m = lspClient.WindowShowMessage({ Type = MessageType.Info Message = sprintf "csharp-ls: %s" m }) async { try let beginMessage = sprintf "Loading solution \"%s\"..." solutionPath do! progress.Begin(beginMessage) do! logMessage beginMessage let projs = loadProjectFilenamesFromSolution solutionPath let workspaceProps = resolveDefaultWorkspaceProps logger projs if workspaceProps.Count > 0 then logger.info ( Log.setMessage "Will use these MSBuild props: {workspaceProps}" >> Log.addContext "workspaceProps" (string workspaceProps) ) let msbuildWorkspace = MSBuildWorkspace.Create(workspaceProps, CSharpLspHostServices()) msbuildWorkspace.LoadMetadataForReferencedProjects <- true let! solution = msbuildWorkspace.OpenSolutionAsync(solutionPath) |> Async.AwaitTask for diag in msbuildWorkspace.Diagnostics do logger.info ( Log.setMessage "msbuildWorkspace.Diagnostics: {message}" >> Log.addContext "message" (diag.ToString()) ) do! logMessage (sprintf "msbuildWorkspace.Diagnostics: %s" (diag.ToString())) let endMessage = sprintf "Finished loading solution \"%s\"" solutionPath do! progress.End endMessage do! logMessage endMessage return Some solution with | ex -> let errorMessage = sprintf "Solution \"%s\" could not be loaded: %s" solutionPath (ex.ToString()) do! progress.End errorMessage do! showMessage errorMessage return None } let tryLoadSolutionFromProjectFiles (lspClient: ILspClient) (logger: ILog) (logMessage: string -> Async) (projs: string list) = let progress = ProgressReporter(lspClient) async { do! progress.Begin($"Loading {projs.Length} project(s)...", false, $"0/{projs.Length}", 0u) let loadedProj = ref 0 let workspaceProps = resolveDefaultWorkspaceProps logger projs if workspaceProps.Count > 0 then logger.info ( Log.setMessage "Will use these MSBuild props: {workspaceProps}" >> Log.addContext "workspaceProps" (string workspaceProps) ) let msbuildWorkspace = MSBuildWorkspace.Create(workspaceProps, CSharpLspHostServices()) msbuildWorkspace.LoadMetadataForReferencedProjects <- true for file in projs do if projs.Length < 10 then do! logMessage (sprintf "loading project \"%s\".." file) try do! msbuildWorkspace.OpenProjectAsync(file) |> Async.AwaitTask |> Async.Ignore with ex -> logger.error ( Log.setMessage "could not OpenProjectAsync('{file}'): {exception}" >> Log.addContext "file" file >> Log.addContext "ex" (string ex) ) let projectFile = new FileInfo(file) let projName = projectFile.Name let loaded = Interlocked.Increment(loadedProj) let percent = 100 * loaded / projs.Length |> uint do! progress.Report(false, $"{projName} {loaded}/{projs.Length}", percent) for diag in msbuildWorkspace.Diagnostics do logger.trace ( Log.setMessage "msbuildWorkspace.Diagnostics: {message}" >> Log.addContext "message" (diag.ToString()) ) do! progress.End (sprintf "OK, %d project file(s) loaded" projs.Length) //workspace <- Some(msbuildWorkspace :> Workspace) return Some msbuildWorkspace.CurrentSolution } let findAndLoadSolutionOnDir (lspClient: ILspClient) (logger: ILog) dir = async { let fileNotOnNodeModules (filename: string) = filename.Split(Path.DirectorySeparatorChar) |> Seq.contains "node_modules" |> not let solutionFiles = [ "*.sln"; "*.slnx" ] |> List.collect(fun p -> Directory.GetFiles(dir, p, SearchOption.AllDirectories) |> List.ofArray) |> Seq.filter fileNotOnNodeModules |> Seq.toList let logMessage m = lspClient.WindowLogMessage({ Type = MessageType.Info Message = sprintf "csharp-ls: %s" m }) do! logMessage (sprintf "%d solution(s) found: [%s]" solutionFiles.Length (String.Join(", ", solutionFiles)) ) let singleSolutionFound = match solutionFiles with | [x] -> Some x | _ -> None match singleSolutionFound with | None -> do! logMessage ("no or multiple .sln/.slnx files found on " + dir) do! logMessage ("looking for .csproj/fsproj files on " + dir + "..") let projFiles = let csprojFiles = Directory.GetFiles(dir, "*.csproj", SearchOption.AllDirectories) let fsprojFiles = Directory.GetFiles(dir, "*.fsproj", SearchOption.AllDirectories) [ csprojFiles; fsprojFiles ] |> Seq.concat |> Seq.filter fileNotOnNodeModules |> Seq.toList if projFiles.Length = 0 then let message = "no or .csproj/.fsproj or sln files found on " + dir do! logMessage message Exception message |> raise return! tryLoadSolutionFromProjectFiles lspClient logger logMessage projFiles | Some solutionPath -> return! tryLoadSolutionOnPath lspClient logger solutionPath } let loadSolutionOnSolutionPathOrDir (lspClient: ILspClient) (logger: ILog) (solutionPathMaybe: string option) (rootPath: string) = match solutionPathMaybe with | Some solutionPath -> async { let rootedSolutionPath = match (Path.IsPathRooted(solutionPath)) with | true -> solutionPath | false -> Path.Combine(rootPath, solutionPath) return! tryLoadSolutionOnPath lspClient logger rootedSolutionPath } | None -> async { let logMessage: LogMessageParams = { Type = MessageType.Info Message = sprintf "csharp-ls: attempting to find and load solution based on root path (\"%s\").." rootPath } do! lspClient.WindowLogMessage(logMessage) return! findAndLoadSolutionOnDir lspClient logger rootPath } let getContainingTypeOrThis (symbol: ISymbol): INamedTypeSymbol = if (symbol :? INamedTypeSymbol) then symbol :?> INamedTypeSymbol else symbol.ContainingType let getFullReflectionName (containingType: INamedTypeSymbol) = let stack = Stack(); stack.Push(containingType.MetadataName); let mutable ns = containingType.ContainingNamespace; let mutable doContinue = true while doContinue do stack.Push(ns.Name); ns <- ns.ContainingNamespace doContinue <- ns <> null && not ns.IsGlobalNamespace String.Join(".", stack) let tryAddDocument (logger: ILog) (docFilePath: string) (text: string) (solution: Solution) : Async = 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! 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, text=SourceText.From(text), folders=null, filePath=docFilePath) Some newDoc |> async.Return | None -> async { logger.trace ( Log.setMessage "No parent project could be resolved to add file \"{file}\" to workspace" >> Log.addContext "file" docFilePath ) return None } return newDocumentMaybe } let makeDocumentFromMetadata (compilation: Microsoft.CodeAnalysis.Compilation) (project: Microsoft.CodeAnalysis.Project) (l: Microsoft.CodeAnalysis.Location) (fullName: string) = let mdLocation = l let reference = compilation.GetMetadataReference(mdLocation.MetadataModule.ContainingAssembly) let peReference = reference :?> PortableExecutableReference |> Option.ofObj let assemblyLocation = peReference |> Option.map (fun r -> r.FilePath) |> Option.defaultValue "???" let decompilerSettings = DecompilerSettings() decompilerSettings.ThrowOnAssemblyResolveErrors <- false // this shouldn't be a showstopper for us let decompiler = CSharpDecompiler(assemblyLocation, decompilerSettings) // Escape invalid identifiers to prevent Roslyn from failing to parse the generated code. // (This happens for example, when there is compiler-generated code that is not yet recognized/transformed by the decompiler.) decompiler.AstTransforms.Add(EscapeInvalidIdentifiers()) let fullTypeName = ICSharpCode.Decompiler.TypeSystem.FullTypeName(fullName) let text = decompiler.DecompileTypeAsString(fullTypeName) let mdDocumentFilename = $"$metadata$/projects/{project.Name}/assemblies/{mdLocation.MetadataModule.ContainingAssembly.Name}/symbols/{fullName}.cs" let mdDocumentEmpty = project.AddDocument(mdDocumentFilename, String.Empty) let mdDocument = SourceText.From(text) |> mdDocumentEmpty.WithText (mdDocument, text) csharp-language-server-0.18.0/src/CSharpLanguageServer/State/000077500000000000000000000000001502617301100240235ustar00rootroot00000000000000csharp-language-server-0.18.0/src/CSharpLanguageServer/State/ServerRequestContext.fs000066400000000000000000000234161502617301100305470ustar00rootroot00000000000000namespace CSharpLanguageServer.State open Microsoft.CodeAnalysis open Microsoft.CodeAnalysis.FindSymbols open Ionide.LanguageServerProtocol.Types open CSharpLanguageServer.State.ServerState open CSharpLanguageServer.Types open CSharpLanguageServer.RoslynHelpers open CSharpLanguageServer.Conversions open CSharpLanguageServer.Util type ServerRequestContext (requestId: int, state: ServerState, emitServerEvent) = let mutable solutionMaybe = state.Solution member _.RequestId = requestId member _.State = state member _.ClientCapabilities = state.ClientCapabilities member _.Solution = solutionMaybe.Value member _.OpenDocs = state.OpenDocs member _.DecompiledMetadata = state.DecompiledMetadata member _.WindowShowMessage (m: string) = match state.LspClient with | Some lspClient -> lspClient.WindowShowMessage( { Type = MessageType.Info Message = sprintf "csharp-ls: %s" m }) | None -> async.Return () member this.GetDocumentForUriOfType = getDocumentForUriOfType this.State member this.GetUserDocument (u: string) = this.GetDocumentForUriOfType UserDocument u |> Option.map fst member this.GetDocument (u: string) = this.GetDocumentForUriOfType AnyDocument u |> Option.map fst member _.Emit ev = match ev with | SolutionChange newSolution -> solutionMaybe <- Some newSolution | _ -> () emitServerEvent ev member this.EmitMany es = for e in es do this.Emit e member private this.ResolveSymbolLocation (project: Microsoft.CodeAnalysis.Project option) sym (l: Microsoft.CodeAnalysis.Location) = async { match l.IsInMetadata, l.IsInSource, project with | true, _, Some project -> let! ct = Async.CancellationToken let! compilation = project.GetCompilationAsync(ct) |> Async.AwaitTask let fullName = sym |> getContainingTypeOrThis |> getFullReflectionName let uri = $"csharp:/metadata/projects/{project.Name}/assemblies/{l.MetadataModule.ContainingAssembly.Name}/symbols/{fullName}.cs" let mdDocument, stateChanges = match Map.tryFind uri state.DecompiledMetadata with | Some value -> (value.Document, []) | None -> let (documentFromMd, text) = makeDocumentFromMetadata compilation project l fullName let csharpMetadata = { ProjectName = project.Name AssemblyName = l.MetadataModule.ContainingAssembly.Name SymbolName = fullName Source = text } (documentFromMd, [ DecompiledMetadataAdd (uri, { Metadata = csharpMetadata; Document = documentFromMd })]) this.EmitMany stateChanges // figure out location on the document (approx implementation) let! syntaxTree = mdDocument.GetSyntaxTreeAsync(ct) |> Async.AwaitTask let collector = DocumentSymbolCollectorForMatchingSymbolName(uri, sym) let! root = syntaxTree.GetRootAsync(ct) |> Async.AwaitTask collector.Visit(root) let fallbackLocationInMetadata = { Uri = uri Range = { Start = { Line = 0u; Character = 0u }; End = { Line = 0u; Character = 1u } } } return match collector.GetLocations() with | [] -> [fallbackLocationInMetadata] | ls -> ls | false, true, _ -> return match (Location.fromRoslynLocation l) with | Some loc -> [loc] | None -> [] | _, _, _ -> return [] } member this.ResolveSymbolLocations (symbol: Microsoft.CodeAnalysis.ISymbol) (project: Microsoft.CodeAnalysis.Project option) = async { let mutable aggregatedLspLocations = [] for l in symbol.Locations do let! symLspLocations = this.ResolveSymbolLocation project symbol l aggregatedLspLocations <- aggregatedLspLocations @ symLspLocations return aggregatedLspLocations } member this.FindSymbol' (uri: DocumentUri) (pos: Position): Async<(ISymbol * Document) 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) } member this.FindSymbol (uri: DocumentUri) (pos: Position): Async = this.FindSymbol' uri pos |> Async.map (Option.map fst) member private __._FindDerivedClasses (symbol: INamedTypeSymbol) (transitive: bool): Async = async { match state.Solution with | None -> return [] | Some currentSolution -> let! ct = Async.CancellationToken return! SymbolFinder.FindDerivedClassesAsync(symbol, currentSolution, transitive, cancellationToken=ct) |> Async.AwaitTask } member private __._FindDerivedInterfaces (symbol: INamedTypeSymbol) (transitive: bool): Async = async { match state.Solution with | None -> return [] | Some currentSolution -> let! ct = Async.CancellationToken return! SymbolFinder.FindDerivedInterfacesAsync(symbol, currentSolution, transitive, cancellationToken=ct) |> Async.AwaitTask } member __.FindImplementations (symbol: ISymbol): Async = async { match state.Solution with | None -> return [] | Some currentSolution -> let! ct = Async.CancellationToken return! SymbolFinder.FindImplementationsAsync(symbol, currentSolution, cancellationToken=ct) |> Async.AwaitTask } member __.FindImplementations' (symbol: INamedTypeSymbol) (transitive: bool): Async = async { match state.Solution with | None -> return [] | Some currentSolution -> let! ct = Async.CancellationToken return! SymbolFinder.FindImplementationsAsync(symbol, currentSolution, transitive, cancellationToken=ct) |> Async.AwaitTask } member this.FindDerivedClasses (symbol: INamedTypeSymbol): Async = this._FindDerivedClasses symbol true member this.FindDerivedClasses' (symbol: INamedTypeSymbol) (transitive: bool): Async = this._FindDerivedClasses symbol transitive member this.FindDerivedInterfaces (symbol: INamedTypeSymbol): Async = this._FindDerivedInterfaces symbol true member this.FindDerivedInterfaces' (symbol: INamedTypeSymbol) (transitive: bool): Async = this._FindDerivedInterfaces symbol transitive member __.FindCallers (symbol: ISymbol): Async = async { match state.Solution with | None -> return [] | Some currentSolution -> let! ct = Async.CancellationToken return! SymbolFinder.FindCallersAsync(symbol, currentSolution, cancellationToken=ct) |> Async.AwaitTask } member this.ResolveTypeSymbolLocations (project: Microsoft.CodeAnalysis.Project) (symbols: Microsoft.CodeAnalysis.ITypeSymbol list) = async { let mutable aggregatedLspLocations = [] for sym in symbols do for l in sym.Locations do let! symLspLocations = this.ResolveSymbolLocation (Some project) sym l aggregatedLspLocations <- aggregatedLspLocations @ symLspLocations return aggregatedLspLocations } member this.FindSymbols (pattern: string option): Async = async { let findTask ct = match pattern with | Some pat -> fun (sln: Solution) -> SymbolFinder.FindSourceDeclarationsWithPatternAsync(sln, pat, SymbolFilter.TypeAndMember, cancellationToken=ct) | None -> let true' = System.Func(fun _ -> true) fun (sln: Solution) -> SymbolFinder.FindSourceDeclarationsAsync(sln, true', SymbolFilter.TypeAndMember, cancellationToken=ct) match this.State.Solution with | None -> return [] | Some solution -> let! ct = Async.CancellationToken return! findTask ct solution |> Async.AwaitTask } member this.FindReferences (symbol: ISymbol) (withDefinition: bool): Async = async { match this.State.Solution with | None -> return [] | Some solution -> let! ct = Async.CancellationToken let locationsFromReferencedSym (r: ReferencedSymbol) = let locations = r.Locations |> Seq.map (fun rl -> rl.Location) match withDefinition with | true -> locations |> Seq.append r.Definition.Locations | false -> locations let! refs = SymbolFinder.FindReferencesAsync(symbol, solution, cancellationToken=ct) |> Async.AwaitTask return refs |> Seq.collect locationsFromReferencedSym } member this.GetDocumentVersion (uri: DocumentUri): int option = Uri.unescape uri |> this.OpenDocs.TryFind |> Option.map _.Version csharp-language-server-0.18.0/src/CSharpLanguageServer/State/ServerState.fs000066400000000000000000000406361502617301100266350ustar00rootroot00000000000000module CSharpLanguageServer.State.ServerState open System open System.IO open System.Threading open System.Threading.Tasks open Microsoft.CodeAnalysis open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol open CSharpLanguageServer.RoslynHelpers open CSharpLanguageServer.Types open CSharpLanguageServer.Logging open CSharpLanguageServer.Conversions type DecompiledMetadataDocument = { Metadata: CSharpMetadataInformation Document: Document } type ServerRequestType = ReadOnly | ReadWrite type ServerOpenDocInfo = { Version: int Touched: DateTime } type ServerRequest = { Id: int Name: string Type: ServerRequestType Semaphore: SemaphoreSlim Priority: int // 0 is the highest priority, 1 is lower prio, etc. // priority is used to order pending R/O requests and is ignored wrt R/W requests Enqueued: DateTime } and ServerState = { Settings: ServerSettings RootPath: string LspClient: ILspClient option ClientCapabilities: ClientCapabilities Solution: Solution option OpenDocs: Map DecompiledMetadata: Map LastRequestId: int RunningRequests: Map RequestQueue: ServerRequest list SolutionReloadPending: DateTime option PushDiagnosticsDocumentBacklog: string list PushDiagnosticsCurrentDocTask: (string * Task) option } let pullFirstRequestMaybe requestQueue = match requestQueue with | [] -> (None, []) | (firstRequest :: queueRemainder) -> (Some firstRequest, queueRemainder) let pullNextRequestMaybe requestQueue = match requestQueue with | [] -> (None, requestQueue) | nonEmptyRequestQueue -> let requestIsReadOnly r = r.Type = ServerRequestType.ReadOnly // here we will try to take non-interrupted r/o request sequence at the front, // order it by priority and run the most prioritized one first let nextRoRequestByPriorityMaybe = nonEmptyRequestQueue |> Seq.takeWhile requestIsReadOnly |> Seq.sortBy (fun r -> r.Priority) |> Seq.tryHead // otherwise, if no r/o request by priority was found then we should just take the first request let nextRequest = nextRoRequestByPriorityMaybe |> Option.defaultValue (nonEmptyRequestQueue |> Seq.head) let queueRemainder = nonEmptyRequestQueue |> List.except [nextRequest] (Some nextRequest, queueRemainder) let emptyServerState = { Settings = ServerSettings.Default RootPath = Directory.GetCurrentDirectory() LspClient = None ClientCapabilities = emptyClientCapabilities Solution = None OpenDocs = Map.empty DecompiledMetadata = Map.empty LastRequestId = 0 RunningRequests = Map.empty RequestQueue = [] SolutionReloadPending = None PushDiagnosticsDocumentBacklog = [] PushDiagnosticsCurrentDocTask = None } type ServerDocumentType = | UserDocument // user Document from solution, on disk | DecompiledDocument // Document decompiled from metadata, readonly | AnyDocument type ServerStateEvent = | SettingsChange of ServerSettings | RootPathChange of string | ClientChange of ILspClient option | ClientCapabilityChange of ClientCapabilities | SolutionChange of Solution | DecompiledMetadataAdd of string * DecompiledMetadataDocument | OpenDocAdd of string * int * DateTime | OpenDocRemove of string | OpenDocTouch of string * DateTime | GetState of AsyncReplyChannel | GetDocumentOfTypeForUri of ServerDocumentType * string * AsyncReplyChannel | StartRequest of string * ServerRequestType * int * AsyncReplyChannel | FinishRequest of int | ProcessRequestQueue | SolutionReloadRequest of TimeSpan | PushDiagnosticsDocumentBacklogUpdate | PushDiagnosticsProcessPendingDocuments | PushDiagnosticsDocumentDiagnosticsResolution of Result<(string * int option * Diagnostic array), Exception> | PeriodicTimerTick let getDocumentForUriOfType state docType (u: string) = let uri = Uri(u.Replace("%3A", ":", true, null)) match state.Solution with | Some solution -> let matchingUserDocuments = solution.Projects |> Seq.collect (fun p -> p.Documents) |> Seq.filter (fun d -> Uri(d.FilePath, UriKind.Absolute) = uri) |> List.ofSeq let matchingUserDocumentMaybe = match matchingUserDocuments with | [d] -> Some (d, UserDocument) | _ -> None let matchingDecompiledDocumentMaybe = Map.tryFind u state.DecompiledMetadata |> Option.map (fun x -> (x.Document, DecompiledDocument)) match docType with | UserDocument -> matchingUserDocumentMaybe | DecompiledDocument -> matchingDecompiledDocumentMaybe | AnyDocument -> matchingUserDocumentMaybe |> Option.orElse matchingDecompiledDocumentMaybe | None -> None let processServerEvent (logger: ILog) state postSelf msg : Async = async { match msg with | SettingsChange newSettings -> let newState: ServerState = { state with Settings = newSettings } let solutionChanged = not (state.Settings.SolutionPath = newState.Settings.SolutionPath) if solutionChanged then postSelf (SolutionReloadRequest (TimeSpan.FromMilliseconds(250))) return newState | GetState replyChannel -> replyChannel.Reply(state) return state | GetDocumentOfTypeForUri (docType, uri, replyChannel) -> let documentAndTypeMaybe = getDocumentForUriOfType state docType uri replyChannel.Reply(documentAndTypeMaybe |> Option.map fst) return state | StartRequest (name, requestType, requestPriority, replyChannel) -> postSelf ProcessRequestQueue let newRequest = { Id=state.LastRequestId+1 Name=name Type=requestType Semaphore=new SemaphoreSlim(0, 1) Priority=requestPriority Enqueued=DateTime.Now } replyChannel.Reply((newRequest.Id, newRequest.Semaphore)) return { state with LastRequestId=newRequest.Id RequestQueue=state.RequestQueue @ [newRequest] } | FinishRequest requestId -> let request = state.RunningRequests |> Map.tryFind requestId match request with | Some(request) -> request.Semaphore.Dispose() let newRunningRequests = state.RunningRequests |> Map.remove requestId let newState = { state with RunningRequests = newRunningRequests } postSelf ProcessRequestQueue return newState | None -> logger.debug ( Log.setMessage "serverEventLoop/FinishRequest#{requestId}: request not found in state.RunningRequests" >> Log.addContext "requestId" (requestId |> string) ) return state | ProcessRequestQueue -> let runningRWRequestMaybe = state.RunningRequests |> Seq.map (fun kv -> kv.Value) |> Seq.tryFind (fun r -> r.Type = ReadWrite) // let numRunningRequests = state.RunningRequests |> Map.count let canRunNextRequest = (Option.isNone runningRWRequestMaybe) // && (numRunningRequests < 4) return if not canRunNextRequest then state // block until current ReadWrite request is finished else let (nextRequestMaybe, queueRemainder) = pullNextRequestMaybe state.RequestQueue match nextRequestMaybe with | None -> state | Some nextRequest -> // try to process next msg from the remainder, if possible, later postSelf ProcessRequestQueue let newState = { state with RequestQueue = queueRemainder RunningRequests = state.RunningRequests |> Map.add nextRequest.Id nextRequest } // unblock this request to run by sending it current state nextRequest.Semaphore.Release() |> ignore newState | RootPathChange rootPath -> return { state with RootPath = rootPath } | ClientChange lspClient -> return { state with LspClient = lspClient } | ClientCapabilityChange cc -> return { state with ClientCapabilities = cc } | SolutionChange s -> postSelf PushDiagnosticsDocumentBacklogUpdate return { state with Solution = Some s } | DecompiledMetadataAdd (uri, md) -> let newDecompiledMd = Map.add uri md state.DecompiledMetadata return { state with DecompiledMetadata = newDecompiledMd } | OpenDocAdd (doc, ver, timestamp) -> postSelf PushDiagnosticsDocumentBacklogUpdate let openDocInfo = { Version = ver Touched = timestamp } let newOpenDocs = state.OpenDocs |> Map.add doc openDocInfo return { state with OpenDocs = newOpenDocs } | OpenDocRemove uri -> postSelf PushDiagnosticsDocumentBacklogUpdate let newOpenDocVersions = state.OpenDocs |> Map.remove uri return { state with OpenDocs = newOpenDocVersions } | OpenDocTouch (uri, timestamp) -> postSelf PushDiagnosticsDocumentBacklogUpdate let openDocInfo = state.OpenDocs |> Map.tryFind uri match openDocInfo with | None -> return state | Some openDocInfo -> let updatedOpenDocInfo = { openDocInfo with Touched = timestamp } let newOpenDocVersions = state.OpenDocs |> Map.add uri updatedOpenDocInfo return { state with OpenDocs = newOpenDocVersions } | SolutionReloadRequest reloadNoLaterThanIn -> // we need to wait a bit before starting this so we // can buffer many incoming requests at once let newSolutionReloadDeadline = let suggestedDeadline = DateTime.Now + reloadNoLaterThanIn match state.SolutionReloadPending with | Some currentDeadline -> if (suggestedDeadline < currentDeadline) then suggestedDeadline else currentDeadline | None -> suggestedDeadline return { state with SolutionReloadPending = newSolutionReloadDeadline |> Some } | PushDiagnosticsDocumentBacklogUpdate -> // here we build new backlog for background diagnostics processing // which will consider documents by their last modification date // for processing first let newBacklog = state.OpenDocs |> Seq.sortByDescending (fun kv -> kv.Value.Touched) |> Seq.map (fun kv -> kv.Key) |> List.ofSeq return { state with PushDiagnosticsDocumentBacklog = newBacklog } | PushDiagnosticsProcessPendingDocuments -> match state.PushDiagnosticsCurrentDocTask with | Some _ -> // another document is still being processed, do nothing return state | None -> // try pull next doc from the backlog to process let nextDocUri, newBacklog = match state.PushDiagnosticsDocumentBacklog with | [] -> (None, []) | uri :: remainder -> (Some uri, remainder) // push diagnostic is enabled only if pull diagnostics is // not reported to be supported by the client let diagnosticPullSupported = state.ClientCapabilities.TextDocument |> Option.map _.Diagnostic |> Option.map _.IsSome |> Option.defaultValue false match diagnosticPullSupported, nextDocUri with | false, Some docUri -> let newState = { state with PushDiagnosticsDocumentBacklog = newBacklog } let docAndTypeMaybe = docUri |> getDocumentForUriOfType state ServerDocumentType.AnyDocument match docAndTypeMaybe with | None -> // could not find document for this enqueued uri logger.debug ( Log.setMessage "PushDiagnosticsProcessPendingDocuments: could not find document w/ uri \"{docUri}\"" >> Log.addContext "docUri" (string docUri) ) return newState | Some (doc, _docType) -> let resolveDocumentDiagnostics (): Task = task { let! semanticModelMaybe = doc.GetSemanticModelAsync() match semanticModelMaybe |> Option.ofObj with | None -> Error (Exception("could not GetSemanticModelAsync")) |> PushDiagnosticsDocumentDiagnosticsResolution |> postSelf | Some semanticModel -> let diagnostics = semanticModel.GetDiagnostics() |> Seq.map Diagnostic.fromRoslynDiagnostic |> Array.ofSeq Ok (docUri, None, diagnostics) |> PushDiagnosticsDocumentDiagnosticsResolution |> postSelf } let newTask = Task.Run(resolveDocumentDiagnostics) let newState = { newState with PushDiagnosticsCurrentDocTask = Some (docUri, newTask) } return newState | _, _-> // backlog is empty or pull diagnostics is enabled instead,--nothing to do return state | PushDiagnosticsDocumentDiagnosticsResolution result -> // enqueue processing for the next doc on the queue (if any) postSelf PushDiagnosticsProcessPendingDocuments let newState = { state with PushDiagnosticsCurrentDocTask = None } match result with | Error exn -> logger.debug ( Log.setMessage "PushDiagnosticsDocumentDiagnosticsResolution: {exn}" >> Log.addContext "exn" (exn) ) return newState | Ok (docUri, version, diagnostics) -> match state.LspClient with | None -> return newState | Some lspClient -> let resolvedDocumentDiagnostics = { Uri = docUri Version = version Diagnostics = diagnostics } do! lspClient.TextDocumentPublishDiagnostics(resolvedDocumentDiagnostics) return newState | PeriodicTimerTick -> postSelf PushDiagnosticsProcessPendingDocuments let solutionReloadTime = state.SolutionReloadPending |> Option.defaultValue (DateTime.Now.AddDays(1)) match solutionReloadTime < DateTime.Now with | true -> let! newSolution = loadSolutionOnSolutionPathOrDir state.LspClient.Value logger state.Settings.SolutionPath state.RootPath return { state with Solution = newSolution SolutionReloadPending = None } | false -> return state } let serverEventLoop initialState (inbox: MailboxProcessor) = let logger = LogProvider.getLoggerByName "serverEventLoop" let rec loop state = async { let! msg = inbox.Receive() try let! newState = msg |> processServerEvent logger state inbox.Post return! loop newState with ex -> logger.debug ( Log.setMessage "serverEventLoop: crashed with {exception}" >> Log.addContext "exception" (string ex) ) raise ex } loop initialState type ServerSettingsDto = { csharp: ServerSettingsCSharpDto option } and ServerSettingsCSharpDto = { solution: string option applyFormattingOptions: bool option } static member Default = { solution = None applyFormattingOptions = None } csharp-language-server-0.18.0/src/CSharpLanguageServer/Types.fs000066400000000000000000000032451502617301100244050ustar00rootroot00000000000000module CSharpLanguageServer.Types open Ionide.LanguageServerProtocol open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.JsonRpc type ServerSettings = { SolutionPath: string option LogLevel: string ApplyFormattingOptions: bool } static member Default: ServerSettings = { SolutionPath = None LogLevel = "log" ApplyFormattingOptions = false } type CSharpMetadataInformation = { ProjectName: string AssemblyName: string SymbolName: string Source: string } type CSharpMetadataParams = { TextDocument: TextDocumentIdentifier } type CSharpMetadataResponse = CSharpMetadataInformation [] type ICSharpLspServer = inherit ILspServer abstract CSharpMetadata: CSharpMetadataParams -> AsyncLspResult [] type ICSharpLspClient = inherit ILspClient // Use a ClientCapabilitiesDTO instead of ClientCapabilities to avoid Option.map & Option.bind? // 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 Scheme = Some "file" Pattern = Some "**/*.cs" } // Type abbreviations cannot have augmentations, extensions let defaultDocumentSelector: DocumentSelector = [| defaultDocumentFilter |> U2.C1 |] let emptyClientCapabilities: ClientCapabilities = { Workspace = None TextDocument = None NotebookDocument = None Window = None General = None Experimental = None } csharp-language-server-0.18.0/src/CSharpLanguageServer/Util.fs000066400000000000000000000033141502617301100242130ustar00rootroot00000000000000module CSharpLanguageServer.Util open System open System.Runtime.InteropServices open System.IO let parseFileUri s: string = Uri(s).LocalPath let tryParseFileUri s: string option = try let uri = Uri(s) Some uri.LocalPath with _ex -> None let makeFileUri (path: string): string = let fullPath = Path.GetFullPath(path) match RuntimeInformation.IsOSPlatform(OSPlatform.Windows) with | true -> "file:///" + fullPath | false -> "file://" + fullPath let unwindProtect cleanupFn op = async { try return! op finally cleanupFn () } // TPL Task's wrap exceptions in AggregateException, -- this fn unpacks them let rec unpackException (exn : Exception) = match exn with | :? AggregateException as agg -> match Seq.tryExactlyOne agg.InnerExceptions with | Some x -> unpackException x | None -> exn | _ -> exn // flip f takes its (first) two arguments in the reverse order of f, just like // the function with the same name in Haskell. let flip f x y = f y x let curry f x y = f (x, y) let uncurry f (x, y) = f x y module Seq = let inline tryMaxBy (projection: 'T -> 'U) (source: 'T seq): 'T option = if isNull source || Seq.isEmpty source then None else Seq.maxBy projection source |> Some module Option = let inline ofString (value: string) = match String.IsNullOrWhiteSpace(value) with | true -> None | false -> Some value module Async = let map f computation = async.Bind(computation, f >> async.Return) module Map = let union map1 map2 = Map.fold (fun acc key value -> Map.add key value acc) map1 map2 csharp-language-server-0.18.0/tests/000077500000000000000000000000001502617301100173035ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/000077500000000000000000000000001502617301100244175ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/CSharpLanguageServer.Tests.fsproj000066400000000000000000000020751502617301100327640ustar00rootroot00000000000000 net9.0 false false FS0988 csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/CodeActionTests.fs000066400000000000000000000025201502617301100300030ustar00rootroot00000000000000module CSharpLanguageServer.Tests.CodeActionTests open NUnit.Framework open Ionide.LanguageServerProtocol.Types open CSharpLanguageServer.Tests.Tooling [] let testCodeActionOnMethodNameWorks() = use client = setupServerClient defaultClientProfile "TestData/testCodeActionOnMethodNameWorks" client.StartAndWaitForSolutionLoad() use classFile = client.Open("Project/Class.cs") let caParams0: CodeActionParams = { TextDocument = { Uri = classFile.Uri } Range = { Start = { Line = 2u; Character = 16u } End = { Line = 2u; Character = 16u } } Context = { Diagnostics = [| |] Only = None TriggerKind = None } WorkDoneToken = None PartialResultToken = None } let caResult0 : TextDocumentCodeActionResult option = client.Request("textDocument/codeAction", caParams0) Assert.IsTrue(caResult0.IsSome) match caResult0 with | Some [| U2.C2 x |] -> Assert.AreEqual("Extract base class...", x.Title) Assert.AreEqual(None, x.Kind) Assert.AreEqual(None, x.Diagnostics) Assert.AreEqual(None, x.Disabled) Assert.IsTrue(x.Edit.IsSome) | _ -> failwith "Some [| U2.C1 x |] was expected" csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/DefinitionTests.fs000066400000000000000000000054071502617301100300720ustar00rootroot00000000000000module CSharpLanguageServer.Tests.DefinitionTests open NUnit.Framework open Ionide.LanguageServerProtocol.Types open CSharpLanguageServer.Tests.Tooling [] let testDefinitionWorks () = use client = setupServerClient defaultClientProfile "TestData/testDefinitionWorks" client.StartAndWaitForSolutionLoad() use classFile = client.Open("Project/Class.cs") let definitionParams0: DefinitionParams = { TextDocument = { Uri = classFile.Uri } Position = { Line = 0u; Character = 0u } WorkDoneToken = None PartialResultToken = None } let declaration0: Declaration option = client.Request("textDocument/definition", definitionParams0) Assert.IsTrue(declaration0.IsNone) let definitionParams1: DefinitionParams = { TextDocument = { Uri = classFile.Uri } Position = { Line = 2u; Character = 16u } WorkDoneToken = None PartialResultToken = None } let declaration1: Declaration option = client.Request("textDocument/definition", definitionParams1) match declaration1.Value with | U2.C1 _ -> failwith "Location[] was expected" | U2.C2 declaration1Locations -> let expectedLocations1: Location array = [| { Uri = classFile.Uri Range = { Start = { Line = 2u; Character = 16u } End = { Line = 2u; Character = 23u } } } |] Assert.AreEqual(expectedLocations1, declaration1Locations) [] let testDefinitionWorksInAspNetProject () = use client = setupServerClient defaultClientProfile "TestData/testDefinitionWorksInAspNetProject" client.StartAndWaitForSolutionLoad() use testIndexViewModelCsFile = client.Open("Project/Models/Test/IndexViewModel.cs") use testControllerCsFile = client.Open("Project/Controllers/TestController.cs") let definitionParams0: DefinitionParams = { TextDocument = { Uri = testControllerCsFile.Uri } Position = { Line = 11u; Character = 12u } WorkDoneToken = None PartialResultToken = None } let definition0: Declaration option = client.Request("textDocument/definition", definitionParams0) let expectedLocations0: Location array = [| { Uri = testIndexViewModelCsFile.Uri Range = { Start = { Line = 3u; Character = 19u } End = { Line = 3u; Character = 25u } } } |] match definition0 with | Some (U2.C2 definition0Locations) -> Assert.AreEqual(expectedLocations0, definition0Locations) | _ -> failwithf "Some Location[] was expected but %s received" (string definition0) csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/DiagnosticTests.fs000066400000000000000000000151751502617301100300710ustar00rootroot00000000000000module CSharpLanguageServer.Tests.DiagnosticTests open System.Threading open NUnit.Framework open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.Server open CSharpLanguageServer.Tests.Tooling [] let testPushDiagnosticsWork () = use client = setupServerClient defaultClientProfile "TestData/testPushDiagnosticsWork" client.StartAndWaitForSolutionLoad() // // open Class.cs file and wait for diagnostics to be pushed // use classFile = client.Open("Project/Class.cs") Thread.Sleep(4000) let state = client.GetState() let version0, diagnosticList0 = state.PushDiagnostics |> Map.find classFile.Uri Assert.AreEqual(None, version0) Assert.AreEqual(3, diagnosticList0.Length) let diagnostic0 = diagnosticList0.[0] Assert.AreEqual("Identifier expected", diagnostic0.Message) Assert.AreEqual(Some DiagnosticSeverity.Error, diagnostic0.Severity) Assert.AreEqual(0, diagnostic0.Range.Start.Line) Assert.AreEqual(3, diagnostic0.Range.Start.Character) let diagnostic1 = diagnosticList0.[1] Assert.AreEqual("; expected", diagnostic1.Message) let diagnostic2 = diagnosticList0.[2] Assert.AreEqual( "The type or namespace name 'XXX' could not be found (are you missing a using directive or an assembly reference?)", diagnostic2.Message) // // now change the file to contain no content (and thus no diagnostics) // classFile.DidChange("") Thread.Sleep(4000) let state = client.GetState() let version1, diagnosticList1 = state.PushDiagnostics |> Map.find classFile.Uri Assert.AreEqual(None, version1) Assert.AreEqual(0, diagnosticList1.Length) () [] let testPullDiagnosticsWork () = use client = setupServerClient defaultClientProfile "TestData/testPullDiagnosticsWork" client.StartAndWaitForSolutionLoad() // // open Class.cs file and pull diagnostics // use classFile = client.Open("Project/Class.cs") let diagnosticParams: DocumentDiagnosticParams = { WorkDoneToken = None PartialResultToken = None TextDocument = { Uri = classFile.Uri } Identifier = None PreviousResultId = None } let report0: DocumentDiagnosticReport option = client.Request("textDocument/diagnostic", diagnosticParams) match report0 with | Some (U2.C1 report) -> Assert.AreEqual("full", report.Kind) Assert.AreEqual(None, report.ResultId) Assert.AreEqual(3, report.Items.Length) let diagnostic0 = report.Items.[0] Assert.AreEqual(0, diagnostic0.Range.Start.Line) Assert.AreEqual(3, diagnostic0.Range.Start.Character) Assert.AreEqual(Some DiagnosticSeverity.Error, diagnostic0.Severity) Assert.AreEqual("Identifier expected", diagnostic0.Message) Assert.AreEqual( "https://msdn.microsoft.com/query/roslyn.query?appId=roslyn&k=k(CS1001)", diagnostic0.CodeDescription.Value.Href) let diagnostic1 = report.Items.[1] Assert.AreEqual("; expected", diagnostic1.Message) let diagnostic2 = report.Items.[2] Assert.AreEqual( "The type or namespace name 'XXX' could not be found (are you missing a using directive or an assembly reference?)", diagnostic2.Message) | _ -> failwith "U2.C1 is expected" // // now try to do the same but with file fixed to contain no content (and thus no diagnostics) // classFile.DidChange("") let report1: DocumentDiagnosticReport option = client.Request("textDocument/diagnostic", diagnosticParams) match report1 with | Some (U2.C1 report) -> Assert.AreEqual("full", report.Kind) Assert.AreEqual(None, report.ResultId) Assert.AreEqual(0, report.Items.Length) | _ -> failwith "U2.C1 is expected" () [] let testWorkspaceDiagnosticsWork() = use client = setupServerClient defaultClientProfile "TestData/testWorkspaceDiagnosticsWork" client.StartAndWaitForSolutionLoad() let diagnosticParams: WorkspaceDiagnosticParams = { WorkDoneToken = None PartialResultToken = None Identifier = None PreviousResultIds = Array.empty } let report0: WorkspaceDiagnosticReport option = client.Request("workspace/diagnostic", diagnosticParams) match report0 with | Some report0 -> Assert.AreEqual(3, report0.Items.Length) match report0.Items[0] with | U2.C1 fullReport -> Assert.AreEqual("full", fullReport.Kind) Assert.AreEqual(None, fullReport.ResultId) Assert.AreEqual(3, fullReport.Items.Length) let diagnostic0 = fullReport.Items[0] Assert.AreEqual(true, diagnostic0.Code.IsSome) Assert.AreEqual("Identifier expected", diagnostic0.Message) | _ -> failwith "'U2.C1' was expected" | _ -> failwith "'Some' was expected" [] let testWorkspaceDiagnosticsWorkWithStreaming() = use client = setupServerClient defaultClientProfile "TestData/testWorkspaceDiagnosticsWork" client.StartAndWaitForSolutionLoad() let partialResultToken: ProgressToken = System.Guid.NewGuid() |> string |> U2.C2 let diagnosticParams: WorkspaceDiagnosticParams = { WorkDoneToken = None PartialResultToken = Some partialResultToken Identifier = None PreviousResultIds = Array.empty } let report0: WorkspaceDiagnosticReport option = client.Request("workspace/diagnostic", diagnosticParams) // report should have 0 results, all of them streamed to lsp client via $/progress instead match report0 with | Some report0 -> Assert.AreEqual(0, report0.Items.Length) | _ -> failwith "'Some' was expected" let progress = client.GetProgressParams partialResultToken Assert.AreEqual(3, progress.Length) let report0 = progress[0].Value |> deserialize Assert.AreEqual(1, report0.Items.Length) match report0.Items[0] with | U2.C1 fullReport -> Assert.AreEqual("full", fullReport.Kind) Assert.AreEqual(None, fullReport.ResultId) Assert.AreEqual(3, fullReport.Items.Length) let diagnostic0 = fullReport.Items[0] Assert.AreEqual(true, diagnostic0.Code.IsSome) Assert.AreEqual("Identifier expected", diagnostic0.Message) | _ -> failwith "'U2.C1' was expected" let report1 = progress[1].Value |> deserialize Assert.AreEqual(1, report1.Items.Length) csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/DocumentFormattingTests.fs000066400000000000000000000023531502617301100316100ustar00rootroot00000000000000module CSharpLanguageServer.Tests.DocumentFormattingTests open System.IO open NUnit.Framework open Ionide.LanguageServerProtocol.Types open CSharpLanguageServer.Tests.Tooling [] let testEditorConfigFormatting () = use client = setupServerClient defaultClientProfile "TestData/testEditorConfigFormatting" client.StartAndWaitForSolutionLoad() use classFile = client.Open("Project/Class.cs") let docFormattingParams0: DocumentFormattingParams = { TextDocument = { Uri = classFile.Uri } WorkDoneToken = None Options = { TabSize = 8u InsertSpaces = false TrimTrailingWhitespace = Some true InsertFinalNewline = Some true TrimFinalNewlines = Some true } } let textEdits: TextEdit[] option = client.Request("textDocument/formatting", docFormattingParams0) match textEdits with | Some tes -> let expectedClassContents = File.ReadAllText(Path.Combine(client.ProjectDir, "Project", "ExpectedFormatting.cs.txt")) Assert.AreEqual(expectedClassContents, classFile.GetFileContentsWithTextEditsApplied(tes)) | None -> failwith "Some TextEdit's were expected" csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/DocumentationTests.fs000066400000000000000000000207661502617301100306200ustar00rootroot00000000000000module CSharpLanguageServer.Tests.DocumentationTests open System open NUnit.Framework open CSharpLanguageServer.DocumentationUtil [] [doc string", "doc string")>] [\ndoc string\n\n", "doc string")>] [doc string\n y", """doc string Parameters: - ``x``: y""")>] [Gets the standard error output stream.\n\ A that represents the standard error output stream.\n\ ", """Gets the standard error output stream. Returns: A ``System.IO.TextWriter`` that represents the standard error output stream.""" )>] [\n\ Asserts that a condition is true. If the condition is false the method throws\n\ an .\n\ \n\ The evaluated condition\n\ \n\ ", """Asserts that a condition is true. If the condition is false the method throws an ``NUnit.Framework.AssertionException``. Parameters: - ``condition``: The evaluated condition""" )>] [Writes a string to the text stream, followed by a line terminator.\n\ The string to write. If is , only the line terminator is written.\n\ The is closed.\n\ An I/O error occurs.\n\ ", """Writes a string to the text stream, followed by a line terminator. Parameters: - ``value``: The string to write. If ``value`` is ``null``, only the line terminator is written. Exceptions: - ``System.ObjectDisposedException``: The ``System.IO.TextWriter`` is closed. - ``System.IO.IOException``: An I/O error occurs.""" )>] [ Test method. Does another thing. """, "Test method. Does another thing.")>] [test xx", "test ``xx``")>] [test contents-of-unknown-tag", "test contents-of-unknown-tag")>] [test contents-of-unknown-inline-tag", "test contents-of-unknown-inline-tag")>] [summary\n contents-of-unknown-top-level-tag", "summary\n\ contents-of-unknown-top-level-tag")>] [summaryremarks", "summary\n\nRemarks: remarks")>] [A", "A")>] [yb", """ Parameters: - ``x``: y - ``a``: b""")>] [descy", """desc Types: - ``x``: y""")>] [ Adds a child . Nodes can have any number of children, but every child must have a unique name. Child nodes are automatically deleted when the parent node is deleted, so an entire scene can be removed by deleting its topmost node. If is , improves the readability of the added . If not named, the is renamed to its type, and if it shares with a sibling, a number is suffixed more appropriately. This operation is very slow. As such, it is recommended leaving this to , which assigns a dummy name featuring @ in both situations. If is different than , the child will be added as internal node. These nodes are ignored by methods like , unless their parameter include_internal is . The intended usage is to hide the internal nodes from the user, so the user won't accidentally delete or modify them. Used by some GUI nodes, e.g. . See for available modes. Note: If already has a parent, this method will fail. Use first to remove from its current parent. For example: Node childNode = GetChild(0); if (childNode.GetParent() != null) { childNode.GetParent().RemoveChild(childNode); } AddChild(childNode); If you need the child node to be added below a specific node in the list of children, use instead of this method. Note: If you want a child to be persisted to a , you must set in addition to calling . This is typically relevant for tool scripts and editor plugins. If is called without setting , the newly added will not be visible in the scene tree, though it will be visible in the 2D/3D view. """, """Adds a child ``node``. Nodes can have any number of children, but every child must have a unique name. Child nodes are automatically deleted when the parent node is deleted, so an entire scene can be removed by deleting its topmost node. If ``forceReadableName`` is ``true``, improves the readability of the added ``node``. If not named, the ``node`` is renamed to its type, and if it shares ``Godot.Node.Name`` with a sibling, a number is suffixed more appropriately. This operation is very slow. As such, it is recommended leaving this to ``false``, which assigns a dummy name featuring ``@`` in both situations. If ``internal`` is different than ``Godot.Node.InternalMode.Disabled``, the child will be added as internal node. These nodes are ignored by methods like ``Godot.Node.GetChildren(System.Boolean)``, unless their parameter ``include_internal`` is ``true``. The intended usage is to hide the internal nodes from the user, so the user won't accidentally delete or modify them. Used by some GUI nodes, e.g. ``Godot.ColorPicker``. See ``Godot.Node.InternalMode`` for available modes. Note: If ``node`` already has a parent, this method will fail. Use ``Godot.Node.RemoveChild(Godot.Node)`` first to remove ``node`` from its current parent. For example: Node childNode = GetChild(0); if (childNode.GetParent() != null) { childNode.GetParent().RemoveChild(childNode); } AddChild(childNode); If you need the child node to be added below a specific node in the list of children, use ``Godot.Node.AddSibling(Godot.Node,System.Boolean)`` instead of this method. Note: If you want a child to be persisted to a ``Godot.PackedScene``, you must set ``Godot.Node.Owner`` in addition to calling ``Godot.Node.AddChild(Godot.Node,System.Boolean,Godot.Node.InternalMode)``. This is typically relevant for tool scripts and editor plugins. If ``Godot.Node.AddChild(Godot.Node,System.Boolean,Godot.Node.InternalMode)`` is called without setting ``Godot.Node.Owner``, the newly added ``Godot.Node`` will not be visible in the scene tree, though it will be visible in the 2D/3D view.""" )>] let testFormatDocXml (inputXml, expectedMD: string) = let resultMd = String.Join("\n", formatDocXml inputXml) Assert.AreEqual(expectedMD.Replace("\r\n", "\n"), resultMd) csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/HoverTests.fs000066400000000000000000000044261502617301100270650ustar00rootroot00000000000000module CSharpLanguageServer.Tests.HoverTests open NUnit.Framework open Ionide.LanguageServerProtocol.Types open CSharpLanguageServer.Tests.Tooling [] let testHoverWorks() = use client = setupServerClient defaultClientProfile "TestData/testHoverWorks" client.StartAndWaitForSolutionLoad() use classFile = client.Open("Project/Class.cs") // // check hover at method name // let hover0Params: HoverParams = { TextDocument = { Uri = classFile.Uri } Position = { Line = 2u; Character = 16u } WorkDoneToken = None } let hover0: Hover option = client.Request("textDocument/hover", hover0Params) Assert.IsTrue(hover0.IsSome) match hover0 with | Some hover -> match hover.Contents with | U3.C1 c -> Assert.AreEqual(MarkupKind.Markdown, c.Kind) Assert.AreEqual("```csharp\nvoid Class.Method(string arg)\n```", c.Value) | _ -> failwith "C1 was expected" Assert.IsTrue(hover.Range.IsNone) | _ -> failwith "Some (U3.C1 c) was expected" // // check hover on `string` value (external System.String type) // let hover1Params: HoverParams = { TextDocument = { Uri = classFile.Uri } Position = { Line = 4u; Character = 8u } WorkDoneToken = None } let hover1: Hover option = client.Request("textDocument/hover", hover1Params) Assert.IsTrue(hover1.IsSome) match hover1 with | Some hover -> match hover.Contents with | U3.C1 c -> Assert.AreEqual(MarkupKind.Markdown, c.Kind) Assert.AreEqual("""```csharp string ``` Represents text as a sequence of UTF-16 code units.""", c.Value.ReplaceLineEndings()) | _ -> failwith "C1 was expected" Assert.IsTrue(hover.Range.IsNone) | _ -> failwith "Some (U3.C1 c) was expected" // // check hover at beginning of the file (nothing should come up) // let hover2Params: HoverParams = { TextDocument = { Uri = classFile.Uri } Position = { Line = 0u; Character = 0u } WorkDoneToken = None } let hover2: Hover option = client.Request("textDocument/hover", hover2Params) Assert.IsTrue(hover2.IsNone) csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/InitializationTests.fs000066400000000000000000000125221502617301100307650ustar00rootroot00000000000000module CSharpLanguageServer.Tests.InitializationTests open NUnit.Framework open CSharpLanguageServer.Tests.Tooling open Ionide.LanguageServerProtocol.Types let assertHoverWorks (client: ClientController) file pos expectedMarkupContent = use classFile = client.Open(file) let hover0Params: HoverParams = { TextDocument = { Uri = classFile.Uri } Position = pos WorkDoneToken = None } let hover0: Hover option = client.Request("textDocument/hover", hover0Params) match hover0 with | Some { Contents = U3.C1 markupContent; Range = None } -> Assert.AreEqual(MarkupKind.Markdown, markupContent.Kind) Assert.AreEqual(expectedMarkupContent, markupContent.Value) | x -> failwithf "'{ Contents = U3.C1 markupContent; Range = None }' was expected but '%s' received" (string x) [] let testServerRegistersCapabilitiesWithTheClient () = use client = setupServerClient defaultClientProfile "TestData/testServerRegistersCapabilitiesWithTheClient" client.StartAndWaitForSolutionLoad() let serverInfo = client.GetState().ServerInfo.Value Assert.AreEqual("csharp-ls", serverInfo.Name) let serverCaps = client.GetState().ServerCapabilities.Value Assert.AreEqual( { Change = Some TextDocumentSyncKind.Incremental OpenClose = Some true Save = Some (U2.C2 { IncludeText = Some true }) WillSave = None WillSaveWaitUntil = None } |> U2.C1 |> Some, serverCaps.TextDocumentSync) Assert.AreEqual( null, serverCaps.Workspace) Assert.AreEqual( true |> U2.C1 |> Some, serverCaps.HoverProvider) Assert.AreEqual( true |> U3.C1 |> Some, serverCaps.ImplementationProvider) Assert.AreEqual( true |> U2.C1 |> Some, serverCaps.DocumentSymbolProvider) Assert.AreEqual( true |> U2.C1 |> Some, serverCaps.DefinitionProvider) Assert.AreEqual( null, serverCaps.InlineValueProvider) Assert.AreEqual( { DocumentSelector = Some [|U2.C1 { Language = None Scheme = Some "file" Pattern = Some "**/*.cs" }|] WorkDoneProgress = None Identifier = None InterFileDependencies = false WorkspaceDiagnostics = true Id = None } |> U2.C2 |> Some, serverCaps.DiagnosticProvider) Assert.AreEqual( true |> U2.C1 |> Some, serverCaps.DocumentHighlightProvider) Assert.AreEqual( { WorkDoneProgress = None TriggerCharacters = Some [|"."; "'"|] AllCommitCharacters = None ResolveProvider = None CompletionItem = None } |> Some, serverCaps.CompletionProvider) Assert.AreEqual( { WorkDoneProgress = None CodeActionKinds = None ResolveProvider = Some true } |> U2.C2 |> Some, serverCaps.CodeActionProvider) Assert.AreEqual( true |> U2.C1 |> Some, serverCaps.RenameProvider) Assert.AreEqual( null, serverCaps.DeclarationProvider) Assert.AreEqual( true |> U2.C1 |> Some, serverCaps.DocumentFormattingProvider) Assert.AreEqual( true |> U2.C1 |> Some, serverCaps.ReferencesProvider) Assert.AreEqual( true |> U2.C1 |> Some, serverCaps.WorkspaceSymbolProvider) Assert.AreEqual( { WorkDoneProgress = None TriggerCharacters = Some [|"("; ","; "<"; "{"; "["|] RetriggerCharacters = None } |> Some, serverCaps.SignatureHelpProvider) Assert.AreEqual( null, serverCaps.MonikerProvider) Assert.IsTrue(client.ServerDidRespondTo "initialize") Assert.IsTrue(client.ServerDidRespondTo "initialized") [] let testSlnxSolutionFileWillBeFoundAndLoaded () = use client = setupServerClient defaultClientProfile "TestData/testSlnx" client.StartAndWaitForSolutionLoad() Assert.IsTrue(client.ServerMessageLogContains(fun m -> m.Contains "1 solution(s) found")) Assert.IsTrue(client.ServerDidRespondTo "initialize") Assert.IsTrue(client.ServerDidRespondTo "initialized") assertHoverWorks client "Project/Class.cs" { Line = 2u; Character = 16u } "```csharp\nvoid Class.MethodA(string arg)\n```" [] let testMultiTargetProjectLoads () = use client = setupServerClient defaultClientProfile "TestData/testMultiTargetProjectLoads" client.StartAndWaitForSolutionLoad() Assert.IsTrue(client.ServerMessageLogContains(fun m -> m.Contains "loading project")) assertHoverWorks client "Project/Class.cs" { Line = 2u; Character = 16u } "```csharp\nvoid Class.Method(string arg)\n```" csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/InternalTests.fs000066400000000000000000000011711502617301100275500ustar00rootroot00000000000000module CSharpLanguageServer.Tests.InternalTests open NUnit.Framework open CSharpLanguageServer.RoslynHelpers [] [] [] [] [] [] let testTheMostCapableTfmIsSelected(tfmList: string, expectedTfm: string) = let selectedTfm = tfmList.Split(";") |> selectMostCapableCompatibleTfm Assert.AreEqual(expectedTfm |> Option.ofObj, selectedTfm) csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/ReferenceTests.fs000066400000000000000000000135111502617301100276730ustar00rootroot00000000000000module CSharpLanguageServer.Tests.ReferenceTests open NUnit.Framework open Ionide.LanguageServerProtocol.Types open CSharpLanguageServer.Tests.Tooling [] [] let testReferenceWorks(testDataDir: string) = use client = setupServerClient defaultClientProfile testDataDir client.StartAndWaitForSolutionLoad() use classFile = client.Open("Project/Class.cs") // // try references request at empty line line 1 -- should return 0 results // let referenceParams0: ReferenceParams = { TextDocument = { Uri = classFile.Uri } Position = { Line = 0u; Character = 0u } WorkDoneToken = None PartialResultToken = None Context = { IncludeDeclaration = false } } let locations0: Location[] option = client.Request("textDocument/references", referenceParams0) Assert.IsTrue(locations0.IsNone) // // try references request at MethodA declaration on line 2 // let referenceParams1: ReferenceParams = { TextDocument = { Uri = classFile.Uri } Position = { Line = 2u; Character = 16u } WorkDoneToken = None PartialResultToken = None Context = { IncludeDeclaration = false } } let locations1: Location[] option = client.Request("textDocument/references", referenceParams1) let expectedLocations1: Location array = [| { Uri = classFile.Uri Range = { Start = { Line = 8u; Character = 8u } End = { Line = 8u; Character = 15u } } } |] Assert.AreEqual(expectedLocations1, locations1.Value) // // try references request at MethodA declaration on line 2 // (with IncludeDeclaration=true) // let referenceParams2: ReferenceParams = { TextDocument = { Uri = classFile.Uri } Position = { Line = 2u; Character = 16u } WorkDoneToken = None PartialResultToken = None Context = { IncludeDeclaration = true } } let locations2: Location[] option = client.Request("textDocument/references", referenceParams2) let expectedLocations2: Location array = [| { Uri = classFile.Uri Range = { Start = { Line = 2u; Character = 16u } End = { Line = 2u; Character = 23u } } } { Uri = classFile.Uri Range = { Start = { Line = 8u; Character = 8u } End = { Line = 8u; Character = 15u } } } |] Assert.AreEqual(expectedLocations2, locations2.Value) [] [] let testReferenceWorksToAspNetRazorPageReferencedValue() = use client = setupServerClient defaultClientProfile "TestData/testReferenceWorksToAspNetRazorPageReferencedValue" client.StartAndWaitForSolutionLoad() use testIndexViewModelCsFile = client.Open("Project/Models/Test/IndexViewModel.cs") use testControllerCsFile = client.Open("Project/Controllers/TestController.cs") use viewsTestIndexCshtmlFile = client.Open("Project/Views/Test/Index.cshtml") let referenceParams0: ReferenceParams = { TextDocument = { Uri = testIndexViewModelCsFile.Uri } Position = { Line = 3u; Character = 20u } WorkDoneToken = None PartialResultToken = None Context = { IncludeDeclaration = false } } let locations0: Location[] option = client.Request("textDocument/references", referenceParams0) Assert.IsTrue(locations0.IsSome) Assert.AreEqual(2, locations0.Value.Length) let expectedLocations0: Location array = [| { Uri = testControllerCsFile.Uri Range = { Start = { Line = 11u; Character = 12u } End = { Line = 11u; Character = 18u } } } { Uri = viewsTestIndexCshtmlFile.Uri Range = { Start = { Line = 1u; Character = 7u } End = { Line = 1u; Character = 13u } } } |] Assert.AreEqual(expectedLocations0, locations0.Value) // // do same but with IncludeDeclaration=true // let referenceParams1: ReferenceParams = { TextDocument = { Uri = testIndexViewModelCsFile.Uri } Position = { Line = 3u; Character = 20u } WorkDoneToken = None PartialResultToken = None Context = { IncludeDeclaration = true } } let locations1: Location[] option = client.Request("textDocument/references", referenceParams1) Assert.IsTrue(locations1.IsSome) Assert.AreEqual(5, locations1.Value.Length) let expectedLocations1: Location array = [| { Uri = viewsTestIndexCshtmlFile.Uri Range = { Start = { Line = 1u; Character = 7u } End = { Line = 1u; Character = 13u } } } { Uri = testIndexViewModelCsFile.Uri Range = { Start = { Line = 3u; Character = 19u } End = { Line = 3u; Character = 25u } } } { Uri = testIndexViewModelCsFile.Uri Range = { Start = { Line = 3u; Character = 28u } End = { Line = 3u; Character = 31u } } } { Uri = testIndexViewModelCsFile.Uri Range = { Start = { Line = 3u; Character = 33u } End = { Line = 3u; Character = 36u } } } { Uri = testControllerCsFile.Uri Range = { Start = { Line = 11u; Character = 12u } End = { Line = 11u; Character = 18u } } } |] let sortedLocations1 = locations1.Value |> Array.sortBy (fun f -> (f.Range.Start.Line, f.Range.Start.Character)) Assert.AreEqual(expectedLocations1, sortedLocations1) csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/000077500000000000000000000000001502617301100261305ustar00rootroot00000000000000testCodeActionOnMethodNameWorks/000077500000000000000000000000001502617301100342465ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestDataProject/000077500000000000000000000000001502617301100356545ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testCodeActionOnMethodNameWorksClass.cs000066400000000000000000000000771502617301100372540ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testCodeActionOnMethodNameWorks/Projectclass Class { public void Method(string arg) { } } Project.csproj000066400000000000000000000002551502617301100405060ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testCodeActionOnMethodNameWorks/Project Exe net9.0 csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testDefinitionWorks/000077500000000000000000000000001502617301100321465ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testDefinitionWorks/Project/000077500000000000000000000000001502617301100335545ustar00rootroot00000000000000Class.cs000066400000000000000000000002071502617301100350700ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testDefinitionWorks/Projectclass Class { public void MethodA(string arg) { } public void MethodB(string arg) { MethodA(arg); } } Project.csproj000066400000000000000000000002551502617301100363270ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testDefinitionWorks/Project Exe net9.0 testDefinitionWorksInAspNetProject/000077500000000000000000000000001502617301100350205ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestDataProject/000077500000000000000000000000001502617301100364265ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testDefinitionWorksInAspNetProjectControllers/000077500000000000000000000000001502617301100407345ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testDefinitionWorksInAspNetProject/ProjectTestController.cs000066400000000000000000000004751502617301100442540ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testDefinitionWorksInAspNetProject/Project/Controllersusing Microsoft.AspNetCore.Mvc; using Project.Models.Test; namespace Printlog.Web.ClientPart.Controllers; public class TestController : Controller { public IActionResult Index() { var model = new IndexViewModel() { Output = "test" }; return View(model); } } Models/000077500000000000000000000000001502617301100376515ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testDefinitionWorksInAspNetProject/ProjectTest/000077500000000000000000000000001502617301100405705ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testDefinitionWorksInAspNetProject/Project/ModelsIndexViewModel.cs000066400000000000000000000001471502617301100440040ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testDefinitionWorksInAspNetProject/Project/Models/Testnamespace Project.Models.Test; public class IndexViewModel { public string? Output { get; set; } } Program.cs000066400000000000000000000007461502617301100403730ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testDefinitionWorksInAspNetProject/Projectusing Microsoft.AspNetCore; using System.Threading.Tasks; using Microsoft.AspNetCore.Hosting; namespace Project; public class Program { public static async Task Main(string[] args) { await BuildWebHost(args).RunAsync(); } public static IWebHost BuildWebHost(string[] args) { var builder = WebHost.CreateDefaultBuilder(args); builder = builder.UseKestrel().UseStartup(); return builder.Build(); } } Project.csproj000066400000000000000000000004471502617301100412630ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testDefinitionWorksInAspNetProject/Project net9.0 enable Startup.cs000066400000000000000000000012771502617301100404260ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testDefinitionWorksInAspNetProject/Projectusing Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Hosting; using Microsoft.Extensions.Configuration; using Microsoft.Extensions.DependencyInjection; namespace Project; public class Startup { public Startup(IConfiguration configuration, IWebHostEnvironment env) { } public void ConfigureServices(IServiceCollection services) { services.AddOptions(); } public void Configure( IApplicationBuilder app, IWebHostEnvironment env) { app.UseAuthentication(); app.UseAuthorization(); app.UseEndpoints(endpoints => { endpoints.MapControllers(); }); } } Views/000077500000000000000000000000001502617301100375235ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testDefinitionWorksInAspNetProject/ProjectTest/000077500000000000000000000000001502617301100404425ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testDefinitionWorksInAspNetProject/Project/ViewsIndex.cshtml000066400000000000000000000000701502617301100427220ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testDefinitionWorksInAspNetProject/Project/Views/Test@model Project.Models.Test.IndexViewModel @Model.Output _ViewImports.cshtml000066400000000000000000000000651502617301100433670ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testDefinitionWorksInAspNetProject/Project/Views@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers _ViewStart.cshtml000066400000000000000000000000401502617301100430200ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testDefinitionWorksInAspNetProject/Project/Views@{ Layout = "_Layout"; } csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testEditorConfigFormatting/000077500000000000000000000000001502617301100334375ustar00rootroot00000000000000Project/000077500000000000000000000000001502617301100347665ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testEditorConfigFormatting.editorconfig000066400000000000000000000003571502617301100374500ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testEditorConfigFormatting/Projectroot = true [*.cs] csharp_space_after_keywords_in_control_flow_statements = false csharp_space_before_open_square_brackets = true csharp_space_after_cast = true csharp_new_line_before_open_brace = none csharp_indent_switch_labels = false Class.cs000066400000000000000000000010421502617301100363570ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testEditorConfigFormatting/Project// csharp_space_after_keywords_in_control_flow_statements = false if (true) ; // csharp_space_before_open_square_brackets = true var array = new int[10]; // csharp_space_after_cast = true var num = (int)15.0; // csharp_new_line_before_open_brace = none void foo() { } // csharp_indent_switch_labels = true switch (Random.Shared.Next(3)) { case 1: Console.WriteLine("Case 1"); break; case 2: Console.WriteLine("Case 2"); break; default: Console.WriteLine("Default case"); break; } ExpectedFormatting.cs.txt000066400000000000000000000007761502617301100417410ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testEditorConfigFormatting/Project// csharp_space_after_keywords_in_control_flow_statements = false if(true) ; // csharp_space_before_open_square_brackets = true var array = new int [10]; // csharp_space_after_cast = true var num = (int) 15.0; // csharp_new_line_before_open_brace = none void foo() { } // csharp_indent_switch_labels = true switch(Random.Shared.Next(3)) { case 1: Console.WriteLine("Case 1"); break; case 2: Console.WriteLine("Case 2"); break; default: Console.WriteLine("Default case"); break; } Project.csproj000066400000000000000000000002551502617301100376200ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testEditorConfigFormatting/Project Exe net9.0 csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testHoverWorks/000077500000000000000000000000001502617301100311415ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testHoverWorks/Project/000077500000000000000000000000001502617301100325475ustar00rootroot00000000000000Class.cs000066400000000000000000000001301502617301100340560ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testHoverWorks/Projectclass Class { public void Method(string arg) { string str = ""; } } Project.csproj000066400000000000000000000002551502617301100353220ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testHoverWorks/Project Exe net9.0 csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testMultiTargetProjectLoads/000077500000000000000000000000001502617301100336035ustar00rootroot00000000000000Project/000077500000000000000000000000001502617301100351325ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testMultiTargetProjectLoadsClass.cs000066400000000000000000000000771502617301100365320ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testMultiTargetProjectLoads/Projectclass Class { public void Method(string arg) { } } Project.csproj000066400000000000000000000002661502617301100377660ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testMultiTargetProjectLoads/Project Exe net6.0;net8.0 csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testPullDiagnosticsWork/000077500000000000000000000000001502617301100327775ustar00rootroot00000000000000Project/000077500000000000000000000000001502617301100343265ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testPullDiagnosticsWorkClass.cs000066400000000000000000000000041502617301100357140ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testPullDiagnosticsWork/ProjectXXX Project.csproj000066400000000000000000000002551502617301100371600ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testPullDiagnosticsWork/Project Exe net9.0 csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testPushDiagnosticsWork/000077500000000000000000000000001502617301100330025ustar00rootroot00000000000000Project/000077500000000000000000000000001502617301100343315ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testPushDiagnosticsWorkClass.cs000066400000000000000000000000041502617301100357170ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testPushDiagnosticsWork/ProjectXXX Project.csproj000066400000000000000000000002551502617301100371630ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testPushDiagnosticsWork/Project Exe net9.0 csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testReferenceWorksDotnet8/000077500000000000000000000000001502617301100332225ustar00rootroot00000000000000Project/000077500000000000000000000000001502617301100345515ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testReferenceWorksDotnet8Class.cs000066400000000000000000000002071502617301100361440ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testReferenceWorksDotnet8/Projectclass Class { public void MethodA(string arg) { } public void MethodB(string arg) { MethodA(arg); } } Project.csproj000066400000000000000000000002551502617301100374030ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testReferenceWorksDotnet8/Project Exe net8.0 csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testReferenceWorksDotnet9/000077500000000000000000000000001502617301100332235ustar00rootroot00000000000000Project/000077500000000000000000000000001502617301100345525ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testReferenceWorksDotnet9Class.cs000066400000000000000000000002071502617301100361450ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testReferenceWorksDotnet9/Projectclass Class { public void MethodA(string arg) { } public void MethodB(string arg) { MethodA(arg); } } Project.csproj000066400000000000000000000002551502617301100374040ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testReferenceWorksDotnet9/Project Exe net9.0 testReferenceWorksToAspNetRazorPageReferencedValue/000077500000000000000000000000001502617301100401065ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestDataProject/000077500000000000000000000000001502617301100415145ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testReferenceWorksToAspNetRazorPageReferencedValueControllers/000077500000000000000000000000001502617301100440225ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testReferenceWorksToAspNetRazorPageReferencedValue/ProjectTestController.cs000066400000000000000000000004751502617301100473420ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testReferenceWorksToAspNetRazorPageReferencedValue/Project/Controllersusing Microsoft.AspNetCore.Mvc; using Project.Models.Test; namespace Printlog.Web.ClientPart.Controllers; public class TestController : Controller { public IActionResult Index() { var model = new IndexViewModel() { Output = "test" }; return View(model); } } Models/000077500000000000000000000000001502617301100427375ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testReferenceWorksToAspNetRazorPageReferencedValue/ProjectTest/000077500000000000000000000000001502617301100436565ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testReferenceWorksToAspNetRazorPageReferencedValue/Project/ModelsIndexViewModel.cs000066400000000000000000000001471502617301100470720ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testReferenceWorksToAspNetRazorPageReferencedValue/Project/Models/Testnamespace Project.Models.Test; public class IndexViewModel { public string? Output { get; set; } } Program.cs000066400000000000000000000007461502617301100434610ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testReferenceWorksToAspNetRazorPageReferencedValue/Projectusing Microsoft.AspNetCore; using System.Threading.Tasks; using Microsoft.AspNetCore.Hosting; namespace Project; public class Program { public static async Task Main(string[] args) { await BuildWebHost(args).RunAsync(); } public static IWebHost BuildWebHost(string[] args) { var builder = WebHost.CreateDefaultBuilder(args); builder = builder.UseKestrel().UseStartup(); return builder.Build(); } } Project.csproj000066400000000000000000000004471502617301100443510ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testReferenceWorksToAspNetRazorPageReferencedValue/Project net9.0 enable Startup.cs000066400000000000000000000012771502617301100435140ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testReferenceWorksToAspNetRazorPageReferencedValue/Projectusing Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Hosting; using Microsoft.Extensions.Configuration; using Microsoft.Extensions.DependencyInjection; namespace Project; public class Startup { public Startup(IConfiguration configuration, IWebHostEnvironment env) { } public void ConfigureServices(IServiceCollection services) { services.AddOptions(); } public void Configure( IApplicationBuilder app, IWebHostEnvironment env) { app.UseAuthentication(); app.UseAuthorization(); app.UseEndpoints(endpoints => { endpoints.MapControllers(); }); } } Views/000077500000000000000000000000001502617301100426115ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testReferenceWorksToAspNetRazorPageReferencedValue/ProjectTest/000077500000000000000000000000001502617301100435305ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testReferenceWorksToAspNetRazorPageReferencedValue/Project/ViewsIndex.cshtml000066400000000000000000000000701502617301100460100ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testReferenceWorksToAspNetRazorPageReferencedValue/Project/Views/Test@model Project.Models.Test.IndexViewModel @Model.Output _ViewImports.cshtml000066400000000000000000000000651502617301100464550ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testReferenceWorksToAspNetRazorPageReferencedValue/Project/Views@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers _ViewStart.cshtml000066400000000000000000000000401502617301100461060ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testReferenceWorksToAspNetRazorPageReferencedValue/Project/Views@{ Layout = "_Layout"; } testServerRegistersCapabilitiesWithTheClient/000077500000000000000000000000001502617301100370555ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestDataProject/000077500000000000000000000000001502617301100404635ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testServerRegistersCapabilitiesWithTheClientClass.cs000066400000000000000000000000171502617301100420550ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testServerRegistersCapabilitiesWithTheClient/Projectclass Class {} Project.csproj000066400000000000000000000002551502617301100433150ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testServerRegistersCapabilitiesWithTheClient/Project Exe net9.0 csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testSlnx/000077500000000000000000000000001502617301100277545ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testSlnx/Project/000077500000000000000000000000001502617301100313625ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testSlnx/Project/Class.cs000066400000000000000000000002071502617301100327550ustar00rootroot00000000000000class Class { public void MethodA(string arg) { } public void MethodB(string arg) { MethodA(arg); } } Project.csproj000066400000000000000000000002551502617301100341350ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testSlnx/Project Exe net9.0 csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testSlnx/Test.slnx000066400000000000000000000001051502617301100315750ustar00rootroot00000000000000 testWorkspaceDiagnosticsWork/000077500000000000000000000000001502617301100337425ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestDataProject/000077500000000000000000000000001502617301100353505ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testWorkspaceDiagnosticsWorkClass.cs000066400000000000000000000000041502617301100367360ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testWorkspaceDiagnosticsWork/ProjectXXX Project.csproj000066400000000000000000000002551502617301100402020ustar00rootroot00000000000000csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/TestData/testWorkspaceDiagnosticsWork/Project Exe net9.0 csharp-language-server-0.18.0/tests/CSharpLanguageServer.Tests/Tooling.fs000066400000000000000000000667351502617301100264050ustar00rootroot00000000000000module CSharpLanguageServer.Tests.Tooling open System open System.Collections.Generic open System.IO open System.Diagnostics open System.Text open System.Threading.Tasks open System.Threading open System.Runtime.InteropServices open System.Reflection open NUnit.Framework open Newtonsoft.Json.Linq open Ionide.LanguageServerProtocol.Types open Ionide.LanguageServerProtocol.Server let emptyClientCapabilities: ClientCapabilities = { Workspace = None TextDocument = None NotebookDocument = None Window = None General = None Experimental = None } type ClientProfile = { LoggingEnabled: bool ClientCapabilities: ClientCapabilities } let defaultClientProfile = { LoggingEnabled = false ClientCapabilities = emptyClientCapabilities } let makeServerProcessInfo projectTempDir = let serverExe = Path.Combine(Environment.CurrentDirectory) let tfm = Path.GetFileName(serverExe) let buildMode = Path.GetFileName(Path.GetDirectoryName(serverExe)) let baseDir = serverExe |> Path.GetDirectoryName |> Path.GetDirectoryName |> Path.GetDirectoryName |> Path.GetDirectoryName |> Path.GetDirectoryName let baseServerFileName = Path.Combine(baseDir, "src", "CSharpLanguageServer", "bin", buildMode, tfm, "CSharpLanguageServer") let serverFileName = match Environment.OSVersion.Platform with | PlatformID.Win32NT -> baseServerFileName + ".exe" | _ -> baseServerFileName Assert.IsTrue(File.Exists(serverFileName)) let processStartInfo = new ProcessStartInfo() processStartInfo.FileName <- serverFileName processStartInfo.RedirectStandardInput <- true processStartInfo.RedirectStandardOutput <- true processStartInfo.RedirectStandardError <- true processStartInfo.UseShellExecute <- false processStartInfo.CreateNoWindow <- true processStartInfo.WorkingDirectory <- projectTempDir processStartInfo type ClientServerRpcRequestInfo = { Method: string RpcRequestMsg: JObject ResultReplyChannel: option>> } type RpcEndpoint = Server | Client type RpcMessageLogEntry = { Source: RpcEndpoint TimestampMS: int Message: JObject } type ClientState = { ClientProfile: ClientProfile LoggingEnabled: bool ProjectDir: string option ProcessStartInfo: ProcessStartInfo option ServerProcess: Process option ServerStderrLineReadTask: Task ServerStdoutJsonRpcMessageRead: Task NextRpcRequestId: int OutstandingServerRpcReqs: Map SetupTimestamp: DateTime RpcLog: RpcMessageLogEntry list ServerInfo: InitializeResultServerInfo option ServerCapabilities: ServerCapabilities option PushDiagnostics: Map } let defaultClientState = { ClientProfile = { LoggingEnabled = false; ClientCapabilities = emptyClientCapabilities } LoggingEnabled = false ProjectDir = None ProcessStartInfo = None ServerProcess = None ServerStderrLineReadTask = Task.CompletedTask ServerStdoutJsonRpcMessageRead = Task.CompletedTask NextRpcRequestId = 1 OutstandingServerRpcReqs = Map.empty SetupTimestamp = DateTime.MinValue RpcLog = [] ServerInfo = None ServerCapabilities = None PushDiagnostics = Map.empty } type ClientEvent = | SetupWithProfile of ClientProfile | UpdateState of (ClientState -> ClientState) | ServerStartRequest of string * AsyncReplyChannel | ServerStopRequest of AsyncReplyChannel | GetState of AsyncReplyChannel | ServerStderrLineRead of string option | RpcMessageReceived of Result | SendServerRpcRequest of string * JToken * option>> | ServerRpcCallResultOrError of JObject | SendServerRpcNotification of string * JToken | ClientRpcCall of JValue * string * JObject | SendClientRpcCallResult of JToken * JToken | SendRpcMessage of JObject | EmitLogMessage of DateTime * string * string | GetRpcLog of AsyncReplyChannel let processClientEvent (state: ClientState) (post: ClientEvent -> unit) msg : Async = async { let logMessage logger msg = post (EmitLogMessage (DateTime.Now, logger, msg)) match msg with | SetupWithProfile clientProfile -> return { state with SetupTimestamp = DateTime.Now ClientProfile = clientProfile } | UpdateState stateUpdateFn -> return stateUpdateFn(state) | ServerStartRequest (projectDir, rc) -> let processStartInfo = makeServerProcessInfo projectDir let p = new Process() p.StartInfo <- processStartInfo logMessage "ServerStartRequest" "StartServer: p.Start().." let startResult = p.Start() logMessage "ServerStartRequest" (String.Format("StartServer: p.Start(): {0}, {1}", startResult, p.Id)) post (RpcMessageReceived (Ok None)) post (ServerStderrLineRead None) let newState = { state with ProjectDir = Some projectDir ProcessStartInfo = Some processStartInfo ServerProcess = Some p } rc.Reply(newState) return newState | ServerStopRequest rc -> let p = state.ServerProcess.Value logMessage "StopServer" "p.Kill().." p.Kill() logMessage "StopServer" "p.WaitForExit().." p.WaitForExit() logMessage "StopServer" "p.WaitForExit(): OK" logMessage "StopServer" (sprintf "exit code=%d" p.ExitCode) rc.Reply(()) return { state with ServerProcess = None } | GetState rc -> rc.Reply(state) return state | ServerStderrLineRead line -> match line with | Some line -> logMessage "StdErr" line | None -> () let readNextStdErrLine () = if not state.ServerProcess.Value.HasExited then let line = state.ServerProcess.Value.StandardError.ReadLine() post (ServerStderrLineRead (Some line)) let nextStdErrLineReadTask = Task.Run(readNextStdErrLine) return { state with ServerStderrLineReadTask = nextStdErrLineReadTask } | RpcMessageReceived result -> let tryReadJsonRpcHeader (stdout: Stream) = let headerBytes = List() let terminatorReached () = headerBytes.Count >= 4 && headerBytes[headerBytes.Count - 4] = (byte '\r') && headerBytes[headerBytes.Count - 3] = (byte '\n') && headerBytes[headerBytes.Count - 2] = (byte '\r') && headerBytes[headerBytes.Count - 1] = (byte '\n') let mutable eof = false while (not eof && not (terminatorReached())) do let b: int = stdout.ReadByte() if b < 0 then eof <- true else headerBytes.Add(byte b) () match eof with | true -> None | false -> let headers = Encoding.UTF8.GetString(headerBytes.ToArray()) |> _.Split("\r\n") |> Seq.filter (fun s -> s.Length > 0) |> Seq.map (_.Split(":")) let contentLength = headers |> Seq.filter (fun a -> a[0].ToLower().Trim() = "content-length") |> Seq.map (fun a -> a[1] |> Int32.Parse) |> Seq.head Some {| ContentLength = contentLength; ContentType = None |} let readNextJsonRpcMessage () = match state.ServerProcess with | None -> logMessage "RpcMessageReceived" "no state.ServerProcess, will not read next rpc message" () | Some serverProcess -> try let stdout = serverProcess.StandardOutput.BaseStream if not stdout.CanRead then failwith "stdout.CanRead = false" let headerMaybe = tryReadJsonRpcHeader stdout match headerMaybe with | None -> logMessage "RpcMessageReceived" "readNextJsonRpcMessage: EOF received when reading header" () | Some header -> let content: byte[] = Array.zeroCreate header.ContentLength let bytesRead = stdout.Read(content) if bytesRead <> header.ContentLength then failwith "readNextJsonRpcMessage: could not read full content" let msg = Encoding.UTF8.GetString(content) |> JObject.Parse post (RpcMessageReceived (Ok (Some msg))) with ex -> post (RpcMessageReceived (Error ex)) match result with | Error e -> logMessage "RpcMessageReceived" (sprintf "e=%s" (string e)) return state | Ok rpcMsgMaybe -> match rpcMsgMaybe with | Some rpcMsg -> if rpcMsg.ContainsKey("result") || rpcMsg.ContainsKey("error") then post (ServerRpcCallResultOrError rpcMsg) else if rpcMsg.ContainsKey("method") then post (ClientRpcCall (rpcMsg["id"] :?> JValue, string rpcMsg["method"], rpcMsg["params"] :?> JObject)) else failwith (sprintf "RpcMessageReceived: unknown json rpc msg type: %s" (string rpcMsg)) | None -> () let nextJsonRpcMessageReadTask = Task.Run(readNextJsonRpcMessage) let newRpcLog = match rpcMsgMaybe with | Some rpcMsg -> state.RpcLog @ [{ Source = Server; TimestampMS = 0; Message = rpcMsg }] | None -> state.RpcLog return { state with ServerStdoutJsonRpcMessageRead = nextJsonRpcMessageReadTask RpcLog = newRpcLog } | ClientRpcCall (id, m, p) -> let newState = match m with | "window/showMessage" -> let p = p |> deserialize logMessage "windows/showMessage" (String.Format("[{0}] \"{1}\"", p.Type, p.Message)) state | "window/logMessage" -> let p = p |> deserialize logMessage "windows/logMessage" (String.Format("[{0}] \"{1}\"", p.Type, p.Message)) state | "$/progress" -> logMessage "$/progress" (String.Format("({0}) \"{1}\"", p["value"]["kind"], p["value"]["message"])) state | "client/registerCapability" -> logMessage "ClientRpcCall" (String.Format("client/registerCapability: registrations={0}", p["registrations"])) post (SendClientRpcCallResult (id, null)) state | "workspace/configuration" -> logMessage "ClientRpcCall" (String.Format("workspace/configuration: params={0}", p)) post (SendClientRpcCallResult (id, new JArray())) state | "window/workDoneProgress/create" -> logMessage "ClientRpcCall" (String.Format("window/workDoneProgress/create: params={0}", p)) post (SendClientRpcCallResult (id, null)) state | "textDocument/publishDiagnostics" -> logMessage "ClientRpcCall" (sprintf "textDocument/publishDiagnostics: %s" (string p)) let p = p |> deserialize let newPushDiagnostics = state.PushDiagnostics |> Map.add p.Uri (p.Version, p.Diagnostics) { state with PushDiagnostics = newPushDiagnostics } | _ -> logMessage "ClientRpcCall" (String.Format("ClientRpcCall: unhandled method call: \"{0}\"", m)) state return newState | SendServerRpcRequest (m, p, rc) -> let rpcRequestId = state.NextRpcRequestId let msg = JObject() msg["jsonrpc"] <- JValue "2.0" msg["id"] <- JValue rpcRequestId msg["method"] <- JValue m msg["params"] <- p post (SendRpcMessage msg) let newOutstandingServerRpcReqs = state.OutstandingServerRpcReqs |> Map.add rpcRequestId { Method = m; RpcRequestMsg = msg; ResultReplyChannel = rc } return { state with OutstandingServerRpcReqs = newOutstandingServerRpcReqs NextRpcRequestId = state.NextRpcRequestId + 1 } | ServerRpcCallResultOrError rpcMsg -> let rpcCallId = int rpcMsg["id"] let rpcRequest = state.OutstandingServerRpcReqs |> Map.find rpcCallId let newOutstandingServerRpcReqs = state.OutstandingServerRpcReqs |> Map.remove rpcCallId let resultOrError: Result = if rpcMsg.ContainsKey("result") then Ok (rpcMsg["result"]) elif rpcMsg.ContainsKey("error") then Error (rpcMsg["error"]) else failwithf "unknown result rpcMsg: %s" (string rpcMsg) match rpcRequest.ResultReplyChannel with | Some rc -> rc.Reply(resultOrError) | None -> () return { state with OutstandingServerRpcReqs = newOutstandingServerRpcReqs } | SendServerRpcNotification (m, p) -> let msg = JObject() msg["jsonrpc"] <- JValue "2.0" msg["method"] <- JValue m msg["params"] <- p post (SendRpcMessage msg) return state | SendClientRpcCallResult (id, result) -> let msg = JObject() msg["jsonrpc"] <- JValue "2.0" msg["id"] <- id msg["result"] <- result post (SendRpcMessage msg) return state | SendRpcMessage rpcMsg -> let rpcMsgJson = (string rpcMsg) match state.ServerProcess with | None -> logMessage "SendRpcMessage" (sprintf "dropping rpcMsg as there is no state.ServerProcess: %s " rpcMsgJson) return state | Some serverProcess -> let serverStdin = serverProcess.StandardInput let formattedMessage = String.Format("Content-Length: {0}\r\n\r\n{1}", rpcMsgJson.Length, rpcMsgJson) serverStdin.Write(formattedMessage) serverStdin.Flush() let newRpcLog = state.RpcLog @ [{ Source = Client; TimestampMS = 0; Message = rpcMsg }] return { state with RpcLog = newRpcLog } | EmitLogMessage (timestamp, logger, msg) -> let offsetMs = int (timestamp - state.SetupTimestamp).TotalMilliseconds let timestampFmt = if offsetMs >= 0 then (sprintf "+%06i" offsetMs) else (sprintf "%07i" offsetMs) if state.LoggingEnabled then Console.Error.WriteLine("[{0} {1}] {2}", timestampFmt, logger, msg) return state | GetRpcLog rc -> rc.Reply(state.RpcLog) return state } let clientEventLoop (initialState: ClientState) (inbox: MailboxProcessor) = let rec loop state = async { let! msg = inbox.Receive() let! newState = processClientEvent state inbox.Post msg return! loop newState } async { try do! loop initialState with ex -> Console.Error.WriteLine("clientEventLoop: failed {0}", ex) raise ex } let prepareTempTestDirFrom (sourceTestDir: DirectoryInfo) : string = if not sourceTestDir.Exists then failwith (sprintf "%s does not exist!" (sourceTestDir.ToString())) let tempDir = Path.Combine( Path.GetTempPath(), "CSharpLanguageServer.Tests." + System.DateTime.Now.Ticks.ToString()) // a hack for macOS let tempTestDirName = match RuntimeInformation.IsOSPlatform(OSPlatform.OSX), tempDir.StartsWith("/private") with | true, false -> "/private" + tempDir | _ -> tempDir let tempTestDir = new DirectoryInfo(tempTestDirName) tempTestDir.Create() let fileFilter (file: FileInfo) = file.Name = ".editorconfig" || file.Extension = ".cs" || file.Extension = ".csproj" || file.Extension = ".sln" || file.Extension = ".slnx" || file.Extension = ".cshtml" || file.Extension = ".txt" let dirFilter sourceSubdirName = sourceSubdirName <> "bin" && sourceSubdirName <> "obj" let rec copyDirWithFilter (sourceDir: DirectoryInfo) (targetDir: DirectoryInfo) : DirectoryInfo = for file in sourceDir.GetFiles() do if fileFilter file then let targetFilename = Path.Combine(targetDir.ToString(), file.Name) file.CopyTo(targetFilename) |> ignore for sourceSubdir in sourceDir.GetDirectories() do if dirFilter sourceSubdir.Name then let targetSubdir = DirectoryInfo(Path.Combine(targetDir.ToString(), sourceSubdir.Name)) targetSubdir.Create() copyDirWithFilter sourceSubdir targetSubdir |> ignore targetDir copyDirWithFilter sourceTestDir tempTestDir |> string let rec deleteDirectory (path: string) = if Directory.Exists(path) then Directory.GetFileSystemEntries(path) |> Array.iter (fun item -> if File.Exists(item) then File.Delete(item) else deleteDirectory item) Directory.Delete(path) type FileController (client: MailboxProcessor, projectDir: string, filename: string) = let mutable fileContents: option = None member __.FileName = filename member __.Uri = match Environment.OSVersion.Platform with | PlatformID.Win32NT -> ("file:///" + projectDir + "/" + filename).Replace("\\", "/") | _ -> "file://" + projectDir + "/" + filename interface IDisposable with member this.Dispose() = let didCloseParams: DidCloseTextDocumentParams = { TextDocument = { Uri = this.Uri } } client.Post(SendServerRpcNotification ("textDocument/didClose", serialize didCloseParams)) () member this.Open () = let fileText = Path.Combine(projectDir, filename) |> File.ReadAllBytes |> Encoding.UTF8.GetString fileContents <- Some fileText let textDocument = { Uri = this.Uri LanguageId = "csharp" Version = 1 Text = fileText } let didOpenParams: DidOpenTextDocumentParams = { TextDocument = textDocument } client.Post(SendServerRpcNotification ("textDocument/didOpen", serialize didOpenParams)) member this.DidChange(text: string) = let didChangeParams: DidChangeTextDocumentParams = { TextDocument = { Uri = this.Uri; Version = 2 } ContentChanges = [| { Text = text } |> U2.C2 |] } client.Post(SendServerRpcNotification ("textDocument/didChange", serialize didChangeParams)) member __.GetFileContentsWithTextEditsApplied (tes: TextEdit[]) = let indexOfPos (c: string) (pos: Position) : int = let lines = c.Split([|'\n'|], StringSplitOptions.None) let lineOffset = lines |> Seq.take (int pos.Line) |> Seq.sumBy (fun l -> l.Length + 1) lineOffset + (int pos.Character) let applyTextEdit (c: string) (te: TextEdit) = c.Substring(0, indexOfPos c te.Range.Start) + te.NewText.Replace("\\n", "\n") + c.Substring(indexOfPos c te.Range.End) tes |> Array.rev |> Array.fold applyTextEdit fileContents.Value type ClientController (client: MailboxProcessor, testDataDir: DirectoryInfo) = let mutable projectDir: string option = None let mutable solutionLoaded: bool = false let logMessage m msg = client.Post (EmitLogMessage (DateTime.Now, (sprintf "ClientActorController.%s" m), msg)) interface IDisposable with member __.Dispose() = if solutionLoaded then logMessage "Dispose" "sending ServerStopRequest.." client.PostAndReply(fun rc -> ServerStopRequest rc) logMessage "Dispose" "OK, ServerStopRequest has finished" // We don't care about cleanup when running under GitHub Actions C/I, // also Windows version of C/I would fail from time to time due to // another process locking the files on the temporary dir for some reason. let runningInGithubActions = System.Environment.GetEnvironmentVariable("GITHUB_ACTIONS") |> Option.ofObj |> Option.map (fun v -> v = "true") |> Option.defaultValue false match projectDir, runningInGithubActions with | Some projectDir, false -> logMessage "Dispose" (sprintf "Removing files on project dir \"%s\".." projectDir) deleteDirectory projectDir | _ -> () member __.ProjectDir: string = projectDir.Value member this.StartAndWaitForSolutionLoad() = if solutionLoaded then failwith "Solution has already been loaded for this ClientController!" solutionLoaded <- true let log = logMessage "StartInitializeAndWaitForSolutionLoad" projectDir <- Some (prepareTempTestDirFrom testDataDir) log "sending ServerStartRequest" let state = client.PostAndReply(fun rc -> ServerStartRequest (projectDir.Value, rc)) let initializeParams: InitializeParams = { RootPath = None ProcessId = (Process.GetCurrentProcess().Id) |> int |> Some RootUri = (sprintf "file://%s" projectDir.Value) |> Some Capabilities = state.ClientProfile.ClientCapabilities WorkDoneToken = None ClientInfo = None Locale = None InitializationOptions = None Trace = None WorkspaceFolders = None } let initializeResult = let initResponse = client.PostAndReply>( fun rc -> SendServerRpcRequest ("initialize", serialize initializeParams, Some rc)) match initResponse with | Ok result -> deserialize result | Error error -> failwithf "initialize has failed with %s" (string error) client.Post(UpdateState (fun s -> { s with ServerInfo = initializeResult.ServerInfo ServerCapabilities = Some initializeResult.Capabilities })) log "OK, 'initialize' request complete" let _ = client.PostAndReply>( fun rc -> SendServerRpcRequest ("initialized", JObject(), Some rc)) log "OK, 'initialized' request complete" this.WaitForProgressEnd(fun m -> m = "OK, 1 project file(s) loaded" || m.Contains("Finished loading solution")) member __.WaitForProgressEnd(messagePred: (string -> bool)) = let timeoutMS = 60 * 1000 let start = DateTime.Now let progressEndMatch m = m.Source = Server && (m.Message.["method"] |> string) = "$/progress" && (m.Message.["params"].["value"].["kind"] |> string) = "end" && messagePred(m.Message.["params"].["value"].["message"] |> string) let mutable haveProgressEnd = false while (not haveProgressEnd) do let rpcLog = client.PostAndReply(fun rc -> GetRpcLog rc) haveProgressEnd <- rpcLog |> Seq.exists progressEndMatch if (DateTime.Now - start).TotalMilliseconds > timeoutMS then failwith (sprintf "WaitForProgressEnd: no $/progress[end] received in %dms" timeoutMS) Thread.Sleep(25) member __.Shutdown () = let _ = client.PostAndReply>( fun rc -> SendServerRpcRequest ("shutdown", JObject(), Some rc)) client.Post(SendServerRpcRequest ("exit", JObject(), None)) member __.Stop () = client.PostAndReply(fun rc -> ServerStopRequest rc) member __.GetState () = client.PostAndReply(fun rc -> GetState rc) member __.GetRpcLog () = client.PostAndReply(fun rc -> GetRpcLog rc) member __.GetProgressParams (token: ProgressToken) = client.PostAndReply(fun rc -> GetRpcLog rc) |> Seq.filter (fun m -> m.Source = Server) |> Seq.filter (fun m -> (string m.Message["method"]) = "$/progress") |> Seq.map (fun m -> m.Message["params"] |> deserialize) |> Seq.filter (fun pp -> pp.Token = token) |> List.ofSeq member __.DumpRpcLog () = let rpcLog = client.PostAndReply(fun rc -> GetRpcLog rc) for m in rpcLog do logMessage "RpcLog" (sprintf "%s; %s" (string m.Source) (string m.Message)) member __.ServerDidInvoke (rpcMethod: string) = let rpcLog = client.PostAndReply(fun rc -> GetRpcLog rc) rpcLog |> Seq.exists (fun m -> m.Source = Server && (string m.Message["method"]) = rpcMethod) member __.ServerDidRespondTo (rpcMethod: string) = let rpcLog = client.PostAndReply(fun rc -> GetRpcLog rc) let invocation = rpcLog |> Seq.find (fun m -> m.Source = Client && (string m.Message["method"]) = rpcMethod) rpcLog |> Seq.exists (fun m -> m.Source = Client && (m.Message.["id"] |> string) = (invocation.Message.["id"] |> string) && (m.Message.["method"] |> string) = rpcMethod) member __.ServerMessageLogContains (pred: string -> bool): bool = let rpcLog = client.PostAndReply(fun rc -> GetRpcLog rc) rpcLog |> Seq.exists(fun m -> m.Source = Server && (string m.Message["method"]) = "window/logMessage" && (pred (string m.Message.["params"].["message"]))) member __.Request<'Request, 'Response>(method: string, request: 'Request): 'Response = let requestJObject = request |> serialize let responseJToken = client.PostAndReply>(fun rc -> SendServerRpcRequest (method, requestJObject, Some rc)) match responseJToken with | Ok resultJToken -> resultJToken |> deserialize<'Response> | Error errorJToken -> failwithf "request to method \"%s\" has failed with error: %s" method (string errorJToken) member __.Open(filename: string): FileController = let file = new FileController(client, projectDir.Value, filename) file.Open() file let setupServerClient (clientProfile: ClientProfile) (testDataDirName: string) = let initialState = { defaultClientState with LoggingEnabled = clientProfile.LoggingEnabled } let clientActor = MailboxProcessor.Start(clientEventLoop initialState) clientActor.Post(SetupWithProfile clientProfile) let testAssemblyLocationDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) let actualTestDataDirName = DirectoryInfo(Path.Combine(testAssemblyLocationDir, "..", "..", "..", testDataDirName)) new ClientController (clientActor, actualTestDataDirName)