Merge pull request #6874 from dibarbet/merge_main_to_prerelease

Snap main to prerelease

Author: dibarbet

.eslintrc.js

@@ -33,6 +33,7 @@ module.exports = {
         ],
         "@typescript-eslint/no-namespace": "off",
         "@typescript-eslint/promise-function-async": "error",
+        "prefer-promise-reject-errors": "error",
         "curly": "error",
         "prettier/prettier": [ "error", { "endOfLine": "auto" } ],
         "unicorn/filename-case": [

.gitattributes

@@ -0,0 +1,5 @@
+# This is a generated file from vscode-l10n tool, and it always uses 'lf' and line ending. Set it to 'lf' so we don't get warning every time when localization file get changed.
+l10n/bundle.l10n.json text eol=lf
+
+# This is a Unix shell script, so it always use the 'lf' line ends
+scripts/remoteProcessPickerScript text eol=lf

.gitignore

@@ -3,12 +3,14 @@ obj
 node_modules
 out
 .roslyn/
+.roslynDevKit/
 .omnisharp/
 .omnisharp-*/
 .vs/
 .debugger/
 .razor/
 .razoromnisharp/
+.razortelemetry/
 .vscode-test/
 dist/
 *.razor.json

.vscode/extensions.json

@@ -1,6 +1,7 @@
 {
     "recommendations": [
         "dbaeumer.vscode-eslint",
-        "esbenp.prettier-vscode"
+        "esbenp.prettier-vscode",
+        "orta.vscode-jest"
     ]
 }

.vscode/launch.json

@@ -16,9 +16,9 @@
     },
     "csharp.suppressDotnetRestoreNotification": true,
     "typescript.tsdk": "./node_modules/typescript/lib",
-    "mocha.enabled": true,
     "omnisharp.autoStart": false,
     "editor.formatOnSave": false,
     "eslint.lintTask.enable": true,
-    "dotnet.defaultSolution": "disable"
+    "dotnet.defaultSolution": "disable",
+    "jest.autoRun": "off"
 }

.vscode/settings.json

@@ -2,9 +2,11 @@
 .logs/**
 .nyc_output/**
 !.roslyn/**
+!.roslynDevKit/**
 !.omnisharp/**
 !.razor/**
 !.razoromnisharp/**
+!.razortelemetry/**
 .rpt2_cache/**
 .github/**
 .vscode/**
@@ -15,6 +17,11 @@ server/**
 src/**
 tasks/**
 test/**
+omnisharptest/**
+__mocks__/**
+jest.config.ts
+baseJestConfig.ts
+.prettierignore
 typings/**
 vsix/**
 node_modules
@@ -29,7 +36,6 @@ CODEOWNERS
 gulpfile.ts
 !install.Lock
 ISSUE_TEMPLATE
-.mocharc.jsonc
 !README.md
 !CHANGELOG.md
 *.md

.vscodeignore

@@ -1,55 +1,154 @@
-## Local development
+## Table of Contents
 
-### Pre-requisites
+- [Setting Up Local Development Environment](#setting-up-local-development-environment)
+  - [Prerequisites for Development](#prerequisites-for-development)
+  - [Building, Running, and Testing the Repository](#building-running-and-testing-the-repository)
+  - [Setting Up Local Language Servers](#setting-up-local-language-servers)
+    - [Roslyn](#roslyn)
+    - [Razor](#razor)
+  - [Debugging Local Language Servers](#debugging-local-language-servers)
+  - [Configuring Local Language Servers](#configuring-local-language-servers)
+    - [Finding the `settings.json` file for your workspace](#finding-the-settingsjson-file-for-your-workspace)
+    - [Configuring Roslyn Language Server](#configuring-roslyn-language-server)
+    - [Configuring Razor Language Server](#configuring-razor-language-server)
+- [Creating VSIX Packages for the Extension](#creating-vsix-packages-for-the-extension)
+- [Updating the `Roslyn` Language Server Version](#updating-the-roslyn-language-server-version)
 
-First install:
+## Setting Up Local Development Environment
 
-* Node.js ([v16.16 LTS](https://nodejs.org/en/blog/release/v16.16.0) is recommended).
-* Npm (The version shipped with node is fine, for example for v16.16.0 it would be 8.19.2)
+Setting up your local development environment for the vscode-csharp repository involves several steps. This guide will walk you through the process.
+
+### Prerequisites for Development
+
+Before you start, make sure you have the following software installed on your machine:
+
+* Node.js ([v18.17.0 LTS](https://nodejs.org/en/blog/release/v18.17.0) is recommended).
+* Npm (The version shipped with node is fine)
 * .NET 7.0 SDK (dotnet should be on your path)
 
-### Build and run the extension
+Once you have these installed, you can navigate to the cloned vscode-csharp repository to proceed with building, running, and testing the repository.
+
+### Building, Running, and Testing the Repository
+
+Follow these steps to build, run, and test the repository:
+
+#### Building
+
+1. Run `npm i` - This command installs the project dependencies.
+2. Run `npm i -g gulp` - This command installs Gulp globally.
+3. Run `gulp installDependencies` - This command downloads the various dependencies as specified by the version in the [package.json](package.json) file.
+4. Run `code .` - This command opens the project in Visual Studio Code.
+
+#### Running
+
+After completing the build steps:
+
+1. Run `npm run watch` (Optional) - This command watches for code changes.
+2. Press <kbd>Ctrl+Shift+D</kbd> to open the Run view in VS Code and ensure `Launch Extension` is selected.
+3. Start debugging by pressing <kbd>F5</kbd>.
+
+#### Testing
+
+To run tests:
+
+1. Execute `npm run test` or press <kbd>F5</kbd> in VS Code with the "Launch Tests" debug configuration selected.
+2. For integration tests, select either of the two 'current file' integration tests (one for roslyn and one for razor), from the drop-down and press <kbd>F5</kbd> to start debugging:
+- For Roslyn Server: `Launch Current File slnWithCsproj Integration Tests`
+- For Razor Server:  `Launch Current File BasicRazorApp2_1 Integration Tests`
+
+These will allow you to actually debug the test, but the 'Razor integration tests' configuration does not.
+
+### Setting Up Local Language Servers
+
+This section shows how to set up local Razor or Roslyn language servers for debugging with the VSCode C# extension.
+
+#### Roslyn
+
+1. Clone the [Roslyn repository](https://github.com/dotnet/roslyn). This repository contains the Roslyn server implementation.
+2. Follow the build instructions provided in the repository.
+
+The server DLL is typically at `$roslynRepoRoot/artifacts/bin/Microsoft.CodeAnalysis.LanguageServer/Debug/net7.0/Microsoft.CodeAnalysis.LanguageServer.dll`, but this may vary based on the built configuration.
+
+#### Razor
+
+1. Clone the [Razor repository](https://github.com/dotnet/razor). This repository contains the Razor server implementation.
+2. Follow the build instructions provided in the repository.
+
+The server DLL is typically at `$razorRepoRoot/artifacts/bin/rzls/Debug/net8.0`.
+
+### Debugging Local Language Servers
+
+Before running the language servers, familiarize yourself with the steps in the [Configuring Local Language Servers](#configuring-local-language-servers) section to configure either the Roslyn or Razor language servers for debugging .
+
+**Note**: You would only need to configure this for the workspace you wish to debug, NOT for the repo root of vscode-csharp repo.
+
+Follow these steps to enable debugging:
+
+1. Press `Ctrl+Shift+D` and then `F5` to launch the extension. This will open a new VS Code instance for `vscode-csharp` repo.
+2. In the new VS Code instance, open the project or solution you want to debug.
+3. Follow instructions in [Configuring Local Language Servers](#configuring-local-language-servers) to find and configure the workspace settings for the language server you want to debug.
+4. Ensure the language server is fully built in Debug mode.
+5. Meanwhile in a Visual Studio instance open the `.sln` solution file for the language server you want to debug. Keep this instance open for use in a later step.
+6. Back on VS Code, press `Ctrl+Shift+P` and select `Reload Window`. This ensures the changes made in step 3 are applied.
+7. After reloading, a window will pop up prompting you to select or open a Visual Studio instance. Now, select the instance you opened in step 5.
+8. The language server will now trigger a breakpoint on `Debugger.Launch()` when it starts.
+
+### Configuring Local Language Servers
+
+This section provides instructions on how to debug locally built Roslyn and Razor language servers. You can do this by either directly editing the `settings.json` file of your workspace or through the VSCode settings interface.
 
-To run and develop the extension do the following:
+#### Finding the `settings.json` file for your workspace
+- Open the Command Palette with `Ctrl+Shift+P` (or `Cmd+Shift+P` on macOS)
+- Type "Preferences: Open Workspace Settings"
+- Select the option that appears.
+- In the Workspace Settings tab, in the upper right corner, you'll see an icon that looks like a document with an arrow, which is the "Open Settings (JSON)" button.
+- Click on this button to open the `settings.json` file.
 
-* Run `npm i`
-* Run `npm i -g gulp`
-* Run `gulp installDependencies` (this will download the various dependencies as specified by the version in the [package.json](package.json))
-* Open in Visual Studio Code (`code .`)
-* _Optional:_ run `npm run watch`, make code changes
-* Press <kbd>F5</kbd> to debug
+#### Configuring Roslyn Language Server
 
-To **test** do the following: `npm run test` or <kbd>F5</kbd> in VS Code with the "Launch Tests" debug configuration.
+In your workspace `settings.json` file, add the following lines:
 
-### Using a locally developed Roslyn server
+```json
+"dotnet.server.waitForDebugger": true,
+"dotnet.server.path": "<roslynRepoRoot>/artifacts/bin/Microsoft.CodeAnalysis.LanguageServer/Debug/net7.0/Microsoft.CodeAnalysis.LanguageServer.dll"
+```
 
-https://github.com/dotnet/roslyn contains the server implementation.  Follow the instructions there to build the repo as normal.  Once built, the server DLL will be located in the build output directory, typically
+Replace <roslynRepoRoot> with the actual path to your Roslyn repository.
 
-`$roslynRepoRoot/artifacts/bin/Microsoft.CodeAnalysis.LanguageServer/Debug/net7.0/Microsoft.CodeAnalysis.LanguageServer.dll`
+Or, in VSCode settings (`Ctrl+,`):
 
-depending on which configuration is built.  Then, launch the extension here and change the VSCode setting `dotnet.server.path` to point to the Roslyn dll path you built above and restart the language server.
+1. Search for `dotnet server`.
+2. Set `dotnet.server.path` to the path of your Roslyn DLL.
+3. Enable `dotnet.server.waitForDebugger`.
 
-If you need to debug the server, you can set the VSCode setting `dotnet.server.waitForDebugger` to true.  This will trigger a `Debugger.Launch()` on the server side as it starts.
+#### Configuring Razor Language Server
 
-### Using a locally developed Razor server
+In your workspace settings.json file, add the following lines:
 
-https://github.com/dotnet/razor contains the server implementation.  Follow the instructions there to build the repo as normal.  Once built, the server will be located in the build output directory, typically
+```json
+"razor.languageServer.debug": true,
+"razor.languageServer.directory": "<razorRepoRoot>/artifacts/bin/rzls/Debug/net8.0",
+"razor.server.trace": "Debug"
+```
 
-`$razorRepoRoot/artifacts/bin/rzls/Debug/net7.0`
+Replace `$razorRepoRoot` with your actual values.
 
-depending on which configuration is built.  Then, launch the extension here and change the VSCode setting `razor.languageServer.directory` to point to the Razor executable path you built above and reload the window.
+Or, in VSCode settings (`Ctrl+,`):
 
-If you need to debug the server, you can set the VSCode setting `razor.languageServer.debug` to true.  This will trigger a `Debugger.Launch()` on the server side as it starts. You can also set `razor.trace` to `Verbose` to get more log messages in the output window
+1. Search for `Razor`.
+2. Set `razor.languageServer.directory` to the path of your Razor DLL.
+3. Enable `razor.languageServer.debug`.
+4. Set `razor.server.trace` to `Debug`. This gives you more detailed log messages in the output window.
 
-### Creating VSIXs
+## Creating VSIX Packages for the Extension
 
-VSIXs can be created using the gulp command `gulp vsix:release:package`.  This will create all the platform specific VSIXs that you can then install manually in VSCode.
+To package this extension, we need to create VSIX Packages. The VSIX packages can be created using the gulp command `gulp vsix:release:package`. This will create all the platform specific VSIXs that you can then install manually in VSCode.
 
-## Updating the Roslyn server version
+## Updating the `Roslyn` Language Server Version
 
 To update the version of the roslyn server used by the extension do the following:
 1.  Find the the Roslyn signed build you want from [here](https://dnceng.visualstudio.com/internal/_build?definitionId=327&_a=summary).  Typically the latest successful build of main is fine.
-2.  In the official build stage, look for the `Publish Assets` step.  In there you will see it publishing the `Microsoft.CodeAnalysis.LanguageServer` package with some version, e.g. `4.6.0-3.23158.4`.  Take note of that version number.
+2.  In the official build stage, look for the `Publish Assets` step.  In there you will see it publishing the `Microsoft.CodeAnalysis.LanguageServer.neutral` package with some version, e.g. `4.6.0-3.23158.4`.  Take note of that version number.
 3.  In the [package.json](package.json) inside the `defaults` section update the `roslyn` key to point to the version number you found above in step 2.
-4.  Build and test the change (make sure to run `gulp installDependencies` to get the new version!).  If everything looks good, submit a PR.
-    * Adding new package versions might require authentication, run with the `--interactive` flag to login.  You may need to install [azure artifacts nuget credential provider](https://github.com/microsoft/artifacts-credprovider#installation-on-windows) to run interactive authentication.
+4.  Ensure that version of the package is in the proper feeds by running `gulp updateRoslynVersion`. Note: you may need to install the [Azure Artifacts NuGet Credential Provider](https://github.com/microsoft/artifacts-credprovider#installation-on-windows) to run interactive authentication.
+5.  Build and test the change. If everything looks good, submit a PR.

CHANGELOG.md

@@ -6,9 +6,9 @@ While it is possible to use the C# extension as a standalone extension, we highl
 
 1. Installing [C# Dev Kit][csdevkitextension] will automatically install this extension as a required dependency.
 2. Open a folder/workspace that contains a C# project (.csproj) and a C# solution (.sln) and the extension will activate.
-3. Whether you install C# Dev Kit or just the C# extension, the [.NET Runtime Installer Tool extension](https://marketplace.visualstudio.com/items?itemName=ms-dotnettools.vscode-dotnet-runtime) will be installed as a dependency.
+3. Whether you install C# Dev Kit or just the C# extension, the [.NET Install Tool](https://marketplace.visualstudio.com/items?itemName=ms-dotnettools.vscode-dotnet-runtime) will be installed as a dependency.
 
-Note: If working on a solution that requires versions prior to .NET 6 or non-solution based projects, install a Full Framework runtime and [MSBuild tooling](https://visualstudio.microsoft.com/downloads/#build-tools-for-visual-studio-2022).
+Note: If working on a solution that requires versions prior to .NET 6 or non-solution based projects, install a .NET Framework runtime and [MSBuild tooling](https://visualstudio.microsoft.com/downloads/#build-tools-for-visual-studio-2022).
   * Set omnisharp.useModernNet to false and set dotnet.server.useOmnisharp to true
   * Uninstall or disable C# Dev Kit
   * Windows: .NET Framework along with [MSBuild Tools](https://visualstudio.microsoft.com/downloads/#build-tools-for-visual-studio-2022)
@@ -29,11 +29,20 @@ For more information you can:
 ## How to use OmniSharp?
 If you don’t want to take advantage of the great Language Server features, you can revert back to using OmniSharp by going to the Extension settings and setting `dotnet.server.useOmnisharp` to true. Next, uninstall or disable C# Dev Kit. Finally, restart VS Code for this to take effect.
 
-
 ## Found a Bug?
-To file a new issue to include all the related config information directly from vscode by entering the command pallette with Ctrl+Shift+P (Cmd+Shift+P on macOS) and running CSharp: Report an issue command. This will open a browser window with all the necessary information related to the installed extensions, dotnet version, mono version, etc. Enter all the remaining information and hit submit. 
-Alternatively you could visit https://github.com/dotnet/vscode-csharp/issues  and file a new one.
-
+To file a new issue:
+
+1. Open the Command Palette with Ctrl+Shift+P (Cmd+Shift+P on macOS), type "Open Settings (UI)", and press Enter.
+2. Search for "trace" in the search bar. Under "Dotnet > Server: Trace" select "Trace" from the drop down. This will provide more output information.
+3. Reload the window by opening the Command Palette with Ctrl+Shift+P (Cmd+Shift+P on macOS), type "Reload Window", and press Enter.
+4. Next, check the C# logs in the Output Window by opening it with Ctrl+Shift+U (Cmd+Shift+U on macOS), and select C# from the dropdown.
+5. Select and copy all the text in the log, and then report the issue through VS Code.
+6. Open the Command Palette with Ctrl+Shift+P (Cmd+Shift+P on macOS), type “CSharp: Report an issue”, and press Enter.
+7. This will open a window with all the necessary information related to the C# extension, dotnet version, mono version, etc.
+8. Paste the previously copied C# log into the “Steps to Reproduce” field. Please also include a description of what you were doing/attempting to do at the time the problem occurred.
+9. Click the “Preview on GitHub” button, and then file the issue.
+
+Alternatively, you could visit https://github.com/dotnet/vscode-csharp/issues and file a new issue there.
 
 ## Contributing