Merge branch 'main' into fix-typedef-export

Author: sandersn

.github/ls-screenshot.png

@@ -55,6 +55,8 @@ const { values: options } = parseArgs({
         fix: { type: "boolean" },
         debug: { type: "boolean" },
 
+        insiders: { type: "boolean" },
+
         race: { type: "boolean", default: parseEnvBoolean("RACE") },
         noembed: { type: "boolean", default: parseEnvBoolean("NOEMBED") },
         concurrentTestPrograms: { type: "boolean", default: parseEnvBoolean("CONCURRENT_TEST_PROGRAMS") },
@@ -348,6 +350,17 @@ export const testAll = task({
     },
 });
 
+export const installExtension = task({
+    name: "install-extension",
+    run: async () => {
+        await $({ cwd: path.join(__dirname, "_extension") })`npm run package`;
+        await $({ cwd: path.join(__dirname, "_extension") })`${options.insiders ? "code-insiders" : "code"} --install-extension typescript-lsp.vsix`;
+        console.log(pc.yellowBright("\nExtension installed. ") + "Add the following to your workspace or user settings.json:\n");
+        console.log(pc.whiteBright(`    "typescript-go.executablePath": "${path.join(__dirname, "built", "local", process.platform === "win32" ? "tsgo.exe" : "tsgo")}"\n`));
+        console.log("Select 'TypeScript: Use TypeScript Go (Experimental)' in the command palette to enable the extension and disable built-in TypeScript support.\n");
+    },
+});
+
 const customLinterPath = "./_tools/custom-gcl";
 const customLinterHashPath = customLinterPath + ".hash";
 

Herebyfile.mjs

@@ -45,13 +45,18 @@ This is mainly a testing entry point; for higher fidelity with regular `tsc`, ru
 
 ### Running LSP Prototype
 
-To try the prototype LSP experience:
+* Run `hereby build` to build the LSP server
+* Run `hereby install-extension` to build and install the VS Code extension. (Use `--insiders` to target `code-insiders` instead of `code`.)
+* Copy the `"typescript-go.executablePath"` setting printed by `hereby install-extension` to your VS Code settings.
+* Select "TypeScript: Use TypeScript Go (Experimental)" from the VS Code command palette (or set `"typescript.experimental.useTsgo"` in your VS Code settings).
+
+Alternatively, to debug and run the VS Code extension without installing it globally:
 
 * Run VS Code in the repo workspace (`code .`)
 * Copy `.vscode/launch.template.json` to `.vscode/launch.json`
 * <kbd>F5</kbd> (or `Debug: Start Debugging` from the command palette)
 
-This will launch a new VS Code instance which uses the Corsa LS as the backend. If correctly set up, you should see "typescript-go" as an option in the Output pane:
+This will launch a new VS Code instance which uses the Corsa LS as the backend. If correctly set up, you should see "tsgo" in the status bar when a TypeScript or JavaScript file is open:
 
 ![LSP Prototype Screenshot](.github/ls-screenshot.png)
 

README.md

@@ -7,6 +7,10 @@
     "private": true,
     "version": "0.0.0",
     "type": "commonjs",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/microsoft/typescript-go"
+    },
     "engines": {
         "vscode": "^1.91.0"
     },
@@ -34,33 +38,48 @@
                     "typescript-go.pprofDir": {
                         "type": "string",
                         "description": "Directory to write pprof profiles to."
+                    },
+                    "typescript-go.executablePath": {
+                        "type": "string",
+                        "description": "Path to the tsgo binary. If not specified, the extension will look for it in the default location."
                     }
                 }
             }
         ],
         "commands": [
             {
                 "command": "typescript-go.restart",
-                "title": "TypeScript Go: Restart Language Server"
+                "title": "TypeScript Go: Restart Language Server",
+                "enablement": "typescript-go.serverRunning"
             }
         ],
         "menus": {
             "commandPalette": [
                 {
-                    "command": "typescript-go.restart"
+                    "command": "typescript-go.restart",
+                    "when": "typescript-go.serverRunning"
                 }
             ]
         }
     },
     "main": "./dist/extension.js",
+    "files": [
+        "dist"
+    ],
     "scripts": {
         "build": "tsc",
-        "watch": "tsc --watch"
+        "watch": "tsc --watch",
+        "build:prod": "esbuild src/extension.ts --bundle --external:vscode --platform=node --format=cjs --outfile=dist/extension.js --minify",
+        "package": "vsce package --skip-license --no-dependencies --out typescript-lsp.vsix",
+        "install-extension": "code --install-extension typescript-lsp.vsix",
+        "vscode:prepublish": "npm run build:prod"
     },
     "dependencies": {
         "vscode-languageclient": "^9.0.1"
     },
     "devDependencies": {
-        "@types/vscode": "^1.96.0"
+        "@types/vscode": "^1.91.0",
+        "@vscode/vsce": "^3.3.2",
+        "esbuild": "^0.25.2"
     }
 }

_extension/package.json

@@ -11,23 +11,30 @@ import {
 } from "vscode-languageclient/node";
 
 let client: LanguageClient;
+let statusBarItem: vscode.StatusBarItem;
+
+const BUILTIN_TS_EXTENSION_ID = "vscode.typescript-language-features";
 
 export function activate(context: vscode.ExtensionContext) {
-    context.subscriptions.push(vscode.commands.registerCommand("typescript-go.restart", () => {
-        client.restart();
-    }));
+    const tsExtension = vscode.extensions.getExtension(BUILTIN_TS_EXTENSION_ID);
+    if (tsExtension?.isActive && !vscode.workspace.getConfiguration("typescript").get<boolean>("experimental.useTsgo")) {
+        return;
+    }
 
     const output = vscode.window.createOutputChannel("typescript-go", "log");
     const traceOutput = vscode.window.createOutputChannel("typescript-go (LSP)");
 
-    const exe = context.asAbsolutePath(
+    setupStatusBar(context);
+    registerCommands(context, output, traceOutput);
+
+    const config = vscode.workspace.getConfiguration("typescript-go");
+
+    const exe = config.get<string>("executablePath") || context.asAbsolutePath(
         path.join("../", "built", "local", `tsgo${process.platform === "win32" ? ".exe" : ""}`),
     );
 
     output.appendLine(`Resolved to ${exe}`);
 
-    const config = vscode.workspace.getConfiguration("typescript-go");
-
     // Get pprofDir
     const pprofDir = config.get<string>("pprofDir");
     const pprofArgs = pprofDir ? ["-pprofDir", pprofDir] : [];
@@ -115,13 +122,86 @@ export function activate(context: vscode.ExtensionContext) {
 
     output.appendLine(`Starting language server...`);
     client.start();
+    vscode.commands.executeCommand("setContext", "typescript-go.serverRunning", true);
+}
+
+/**
+ * Sets up the status bar item for TypeScript Go
+ * @param context Extension context
+ */
+function setupStatusBar(context: vscode.ExtensionContext): void {
+    statusBarItem = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 100);
+    statusBarItem.text = "$(beaker) tsgo";
+    statusBarItem.tooltip = "TypeScript Go Language Server";
+    statusBarItem.command = "typescript-go.showMenu";
+    statusBarItem.backgroundColor = new vscode.ThemeColor("statusBarItem.warningBackground");
+    statusBarItem.show();
+    context.subscriptions.push(statusBarItem);
+}
+
+/**
+ * Registers all commands for the extension
+ * @param context Extension context
+ */
+function registerCommands(context: vscode.ExtensionContext, outputChannel: vscode.OutputChannel, traceOutputChannel: vscode.OutputChannel): void {
+    context.subscriptions.push(vscode.commands.registerCommand("typescript-go.restart", async () => {
+        await client.restart();
+    }));
+
+    context.subscriptions.push(vscode.commands.registerCommand("typescript-go.output.focus", () => {
+        outputChannel.show();
+    }));
+
+    context.subscriptions.push(vscode.commands.registerCommand("typescript-go.lsp-trace.focus", () => {
+        traceOutputChannel.show();
+    }));
+
+    context.subscriptions.push(vscode.commands.registerCommand("typescript-go.showMenu", showQuickPickMenu));
 }
 
-export function deactivate(): Thenable<void> | undefined {
+/**
+ * Shows the quick pick menu for TypeScript Go options
+ */
+async function showQuickPickMenu(): Promise<void> {
+    const selected = await vscode.window.showQuickPick([
+        { label: "$(refresh) Restart Server", description: "Restart the TypeScript Go language server" },
+        { label: "$(output) Show TS Server Log", description: "Show the TypeScript Go server log" },
+        { label: "$(debug-console) Show LSP Messages", description: "Show the LSP communication trace" },
+        { label: "$(stop-circle) Disable TypeScript Go", description: "Switch back to the built-in TypeScript extension" },
+    ], {
+        placeHolder: "TypeScript Go Options",
+    });
+
+    if (selected) {
+        if (selected.label.includes("Restart Server")) {
+            await vscode.commands.executeCommand("typescript-go.restart");
+        }
+        else if (selected.label.includes("Show TS Server Log")) {
+            await vscode.commands.executeCommand("typescript-go.output.focus");
+        }
+        else if (selected.label.includes("Show LSP Messages")) {
+            await vscode.commands.executeCommand("typescript-go.lsp-trace.focus");
+        }
+        else if (selected.label.includes("Disable TypeScript Go")) {
+            // Fire and forget, because this command will restart the whole extension host
+            // and awaiting it shows a weird cancellation error.
+            vscode.commands.executeCommand("typescript.experimental.disableTsgo");
+        }
+    }
+}
+
+export async function deactivate(): Promise<void> {
+    // Dispose of status bar item
+    if (statusBarItem) {
+        statusBarItem.dispose();
+    }
+
     if (!client) {
-        return undefined;
+        return;
     }
-    return client.stop();
+
+    await client.stop();
+    return vscode.commands.executeCommand("setContext", "typescript-go.serverRunning", false);
 }
 
 function getLanguageForUri(uri: vscode.Uri): string | undefined {

_extension/src/extension.ts

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"os"
 	"runtime"
+	"runtime/debug"
 	"slices"
 	"strconv"
 	"strings"
@@ -59,6 +60,7 @@ type cliOptions struct {
 		listFiles     tristateFlag
 		listFilesOnly tristateFlag
 		showConfig    tristateFlag
+		version       bool
 	}
 
 	devel struct {
@@ -103,6 +105,7 @@ func parseArgs() *cliOptions {
 	flag.Var(&opts.tsc.listFiles, "listFiles", diagnostics.Print_all_of_the_files_read_during_the_compilation.Format())
 	flag.Var(&opts.tsc.listFilesOnly, "listFilesOnly", diagnostics.Print_names_of_files_that_are_part_of_the_compilation_and_then_stop_processing.Format())
 	flag.Var(&opts.tsc.showConfig, "showConfig", diagnostics.Print_the_final_configuration_instead_of_building.Format())
+	flag.BoolVar(&opts.tsc.version, "version", false, diagnostics.Print_the_compiler_s_version.Format())
 
 	flag.BoolVar(&opts.devel.quiet, "q", false, "Do not print diagnostics.")
 	flag.BoolVar(&opts.devel.quiet, "quiet", false, "Do not print diagnostics.")
@@ -144,6 +147,21 @@ func runMain() int {
 		defer profileSession.Stop()
 	}
 
+	if opts.tsc.version {
+		// Get build info to extract the commit SHA
+		buildInfo, _ := debug.ReadBuildInfo()
+		version := core.Version
+		for _, setting := range buildInfo.Settings {
+			if setting.Key == "vcs.revision" {
+				version += "-" + setting.Value
+				break
+			}
+		}
+
+		fmt.Println(diagnostics.Version_0.Format(version))
+		return 0
+	}
+
 	startTime := time.Now()
 
 	currentDirectory, err := os.Getwd()

cmd/tsgo/main.go

@@ -2792,3 +2792,12 @@ func IsClassMemberModifier(token Kind) bool {
 func IsParameterPropertyModifier(kind Kind) bool {
 	return ModifierToFlag(kind)&ModifierFlagsParameterPropertyModifier != 0
 }
+
+func ForEachChildAndJSDoc(node *Node, sourceFile *SourceFile, v Visitor) bool {
+	if node.Flags&NodeFlagsHasJSDoc != 0 {
+		if visitNodes(v, node.JSDoc(sourceFile)) {
+			return true
+		}
+	}
+	return node.ForEachChild(v)
+}

internal/ast/utilities.go

@@ -418,8 +418,8 @@ func findRightmostValidToken(endPos int, sourceFile *ast.SourceFile, containingN
 	if position == -1 {
 		position = containingNode.End()
 	}
-	var find func(n *ast.Node) *ast.Node
-	find = func(n *ast.Node) *ast.Node {
+	var find func(n *ast.Node, endPos int) *ast.Node
+	find = func(n *ast.Node, endPos int) *ast.Node {
 		if n == nil {
 			return nil
 		}
@@ -555,10 +555,13 @@ func findRightmostValidToken(endPos int, sourceFile *ast.SourceFile, containingN
 			return n
 		}
 		// Case 1: recur on rightmostValidNode.
-		return find(rightmostValidNode)
+		if rightmostValidNode != nil {
+			endPos = rightmostValidNode.End()
+		}
+		return find(rightmostValidNode, endPos)
 	}
 
-	return find(containingNode)
+	return find(containingNode, endPos)
 }
 
 // !!!

internal/astnav/tokens.go

@@ -354,7 +354,15 @@ func TestFindPrecedingToken(t *testing.T) {
 
 func TestUnitFindPrecedingToken(t *testing.T) {
 	t.Parallel()
-	fileContent := `import {
+	testCases := []struct {
+		name         string
+		fileContent  string
+		position     int
+		expectedKind ast.Kind
+	}{
+		{
+			name: "after dot in jsdoc",
+			fileContent: `import {
     CharacterCodes,
     compareStringsCaseInsensitive,
     compareStringsCaseSensitive,
@@ -399,11 +407,25 @@ backslashRegExp.
  */
 export function isAnyDirectorySeparator(charCode: number): boolean {
     return charCode === CharacterCodes.slash || charCode === CharacterCodes.backslash;
-}`
-	file := parser.ParseSourceFile("/file.ts", "/file.ts", fileContent, core.ScriptTargetLatest, scanner.JSDocParsingModeParseAll)
-	position := 839
-	token := astnav.FindPrecedingToken(file, position)
-	assert.Equal(t, token.Kind, ast.KindDotToken)
+}`,
+			position:     839,
+			expectedKind: ast.KindDotToken,
+		},
+		{
+			name:         "after comma in parameter list",
+			fileContent:  `takesCb((n, s, ))`,
+			position:     15,
+			expectedKind: ast.KindCommaToken,
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			t.Parallel()
+			file := parser.ParseSourceFile("/file.ts", "/file.ts", testCase.fileContent, core.ScriptTargetLatest, scanner.JSDocParsingModeParseAll)
+			token := astnav.FindPrecedingToken(file, testCase.position)
+			assert.Equal(t, token.Kind, testCase.expectedKind)
+		})
+	}
 }
 
 func tsFindPrecedingTokens(t *testing.T, fileText string, positions []int) []*tokenInfo {

internal/astnav/tokens_test.go

@@ -17,6 +17,11 @@ func CommandLineTestWatch(sys System, cb cbType, commandLineArgs []string) (*tso
 	return parsedCommandLine, w
 }
 
+func StartForTest(w *watcher) {
+	// this function should perform any initializations before w.doCycle() in `start(watcher)`
+	w.initialize()
+}
+
 func RunWatchCycle(w *watcher) {
 	// this function should perform the same stuff as w.doCycle() without printing time-related output
 	if w.hasErrorsInTsConfig() {