Merge branch 'main' into multiProjectImpl

Author: sheetalkamat

_extension/package.json

@@ -13,7 +13,7 @@
         "url": "https://github.com/microsoft/typescript-go"
     },
     "engines": {
-        "vscode": "^1.100.0"
+        "vscode": "^1.106.0"
     },
     "capabilities": {
         "untrustedWorkspaces": {
@@ -119,10 +119,10 @@
         "bundle": "esbuild src/extension.ts --bundle --external:vscode --platform=node --format=cjs --outfile=dist/extension.bundle.js --minify"
     },
     "dependencies": {
-        "vscode-languageclient": "^9.0.1"
+        "vscode-languageclient": "^10.0.0-next.18"
     },
     "devDependencies": {
-        "@types/vscode": "^1.100.0",
+        "@types/vscode": "^1.106.0",
         "@vscode/vsce": "^3.7.0",
         "esbuild": "^0.27.0"
     }

_extension/src/client.ts

@@ -20,14 +20,14 @@ import { getLanguageForUri } from "./util";
 const codeLensShowLocationsCommandName = "typescript.native-preview.codeLens.showLocations";
 
 export class Client {
-    private outputChannel: vscode.OutputChannel;
-    private traceOutputChannel: vscode.OutputChannel;
+    private outputChannel: vscode.LogOutputChannel;
+    private traceOutputChannel: vscode.LogOutputChannel;
     private clientOptions: LanguageClientOptions;
     private client?: LanguageClient;
     private exe: ExeInfo | undefined;
     private onStartedCallbacks: Set<() => void> = new Set();
 
-    constructor(outputChannel: vscode.OutputChannel, traceOutputChannel: vscode.OutputChannel) {
+    constructor(outputChannel: vscode.LogOutputChannel, traceOutputChannel: vscode.LogOutputChannel) {
         this.outputChannel = outputChannel;
         this.traceOutputChannel = traceOutputChannel;
         this.clientOptions = {
@@ -128,6 +128,10 @@ export class Client {
         vscode.commands.executeCommand("setContext", "typescript.native-preview.serverRunning", true);
         this.onStartedCallbacks.forEach(callback => callback());
 
+        if (this.traceOutputChannel.logLevel !== vscode.LogLevel.Trace) {
+            this.traceOutputChannel.appendLine(`To see LSP trace output, set this output's log level to "Trace" (gear icon next to the dropdown).`);
+        }
+
         const codeLensLocationsCommand = vscode.commands.registerCommand(codeLensShowLocationsCommandName, (...args: unknown[]) => {
             if (args.length !== 3) {
                 throw new Error("Unexpected number of arguments.");

_extension/src/extension.ts

@@ -12,8 +12,8 @@ import { setupVersionStatusItem } from "./versionStatusItem";
 export async function activate(context: vscode.ExtensionContext) {
     await vscode.commands.executeCommand("setContext", "typescript.native-preview.serverRunning", false);
     registerEnablementCommands(context);
-    const output = vscode.window.createOutputChannel("typescript-native-preview", "log");
-    const traceOutput = vscode.window.createOutputChannel("typescript-native-preview (LSP)");
+    const output = vscode.window.createOutputChannel("typescript-native-preview", { log: true });
+    const traceOutput = vscode.window.createOutputChannel("typescript-native-preview (LSP)", { log: true });
     context.subscriptions.push(output, traceOutput);
 
     let disposeLanguageFeatures: vscode.Disposable | undefined;
@@ -77,7 +77,7 @@ export async function activate(context: vscode.ExtensionContext) {
     context.subscriptions.push(disposeLanguageFeatures);
 }
 
-async function activateLanguageFeatures(context: vscode.ExtensionContext, output: vscode.OutputChannel, traceOutput: vscode.OutputChannel): Promise<vscode.Disposable> {
+async function activateLanguageFeatures(context: vscode.ExtensionContext, output: vscode.LogOutputChannel, traceOutput: vscode.LogOutputChannel): Promise<vscode.Disposable> {
     const disposables: vscode.Disposable[] = [];
 
     const client = new Client(output, traceOutput);

internal/lsp/logger.go

@@ -0,0 +1,126 @@
+package lsp
+
+import (
+	"fmt"
+	"sync"
+
+	"github.com/microsoft/typescript-go/internal/lsp/lsproto"
+	"github.com/microsoft/typescript-go/internal/project/logging"
+)
+
+var _ logging.Logger = (*logger)(nil)
+
+type logger struct {
+	server  *Server
+	mu      sync.Mutex
+	verbose bool
+}
+
+func newLogger(server *Server) *logger {
+	return &logger{
+		server: server,
+	}
+}
+
+func (l *logger) sendLogMessage(msgType lsproto.MessageType, message string) {
+	if l == nil {
+		return
+	}
+
+	if !l.server.initStarted.Load() {
+		fmt.Fprintln(l.server.stderr, message)
+		return
+	}
+
+	notification := lsproto.WindowLogMessageInfo.NewNotificationMessage(&lsproto.LogMessageParams{
+		Type:    msgType,
+		Message: message,
+	})
+	l.server.outgoingQueue <- notification.Message()
+}
+
+func (l *logger) Log(msg ...any) {
+	if l == nil {
+		return
+	}
+	l.sendLogMessage(lsproto.MessageTypeLog, fmt.Sprint(msg...))
+}
+
+func (l *logger) Logf(format string, args ...any) {
+	if l == nil {
+		return
+	}
+	l.sendLogMessage(lsproto.MessageTypeLog, fmt.Sprintf(format, args...))
+}
+
+func (l *logger) Verbose() logging.Logger {
+	if l == nil {
+		return nil
+	}
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	if !l.verbose {
+		return nil
+	}
+	return l
+}
+
+func (l *logger) IsVerbose() bool {
+	if l == nil {
+		return false
+	}
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	return l.verbose
+}
+
+func (l *logger) SetVerbose(verbose bool) {
+	if l == nil {
+		return
+	}
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.verbose = verbose
+}
+
+func (l *logger) Error(msg ...any) {
+	if l == nil {
+		return
+	}
+	l.sendLogMessage(lsproto.MessageTypeError, fmt.Sprint(msg...))
+}
+
+func (l *logger) Errorf(format string, args ...any) {
+	if l == nil {
+		return
+	}
+	l.sendLogMessage(lsproto.MessageTypeError, fmt.Sprintf(format, args...))
+}
+
+func (l *logger) Warn(msg ...any) {
+	if l == nil {
+		return
+	}
+	l.sendLogMessage(lsproto.MessageTypeWarning, fmt.Sprint(msg...))
+}
+
+func (l *logger) Warnf(format string, args ...any) {
+	if l == nil {
+		return
+	}
+	l.sendLogMessage(lsproto.MessageTypeWarning, fmt.Sprintf(format, args...))
+}
+
+func (l *logger) Info(msg ...any) {
+	if l == nil {
+		return
+	}
+	l.sendLogMessage(lsproto.MessageTypeInfo, fmt.Sprint(msg...))
+}
+
+func (l *logger) Infof(format string, args ...any) {
+	if l == nil {
+		return
+	}
+	l.sendLogMessage(lsproto.MessageTypeInfo, fmt.Sprintf(format, args...))
+}

internal/lsp/lsproto/_generate/fetchModel.mts

@@ -8,7 +8,7 @@ const __dirname = path.dirname(__filename);
 const metaModelPath = path.join(__dirname, "metaModel.json");
 const metaModelSchemaPath = path.join(__dirname, "metaModelSchema.mts");
 
-const hash = "dadd73f7fc283b4d0adb602adadcf4be16ef3a7b";
+const hash = "2abd2d977aa36e8c6b242ff048bdbf5df71e3088";
 
 const metaModelURL = `https://raw.githubusercontent.com/microsoft/vscode-languageserver-node/${hash}/protocol/metaModel.json`;
 const metaModelSchemaURL = `https://raw.githubusercontent.com/microsoft/vscode-languageserver-node/${hash}/tools/src/metaModel.ts`;

internal/lsp/lsproto/_generate/metaModelSchema.mts

@@ -202,6 +202,16 @@ export type Request = {
 	 * the property contains the deprecation message.
 	 */
 	deprecated?: string;
+
+	/**
+	 * The client capability property path if any.
+	 */
+	clientCapability?: string;
+
+	/**
+	 * The server capability property path if any.
+	 */
+	serverCapability?: string;
 };
 
 /**
@@ -269,6 +279,16 @@ export type Notification = {
 	 * the property contains the deprecation message.
 	 */
 	deprecated?: string;
+
+	/**
+	 * The client capability property path if any.
+	 */
+	clientCapability?: string;
+
+	/**
+	 * The server capability property path if any.
+	 */
+	serverCapability?: string;
 };
 
 /**

internal/lsp/server.go

@@ -23,7 +23,6 @@ import (
 	"github.com/microsoft/typescript-go/internal/lsp/lsproto"
 	"github.com/microsoft/typescript-go/internal/project"
 	"github.com/microsoft/typescript-go/internal/project/ata"
-	"github.com/microsoft/typescript-go/internal/project/logging"
 	"github.com/microsoft/typescript-go/internal/tspath"
 	"github.com/microsoft/typescript-go/internal/vfs"
 	"golang.org/x/sync/errgroup"
@@ -40,27 +39,17 @@ type ServerOptions struct {
 	TypingsLocation    string
 	ParseCache         *project.ParseCache
 	NpmInstall         func(cwd string, args []string) ([]byte, error)
-
-	// Test options
-	Client project.Client
-	Logger logging.Logger
 }
 
 func NewServer(opts *ServerOptions) *Server {
 	if opts.Cwd == "" {
 		panic("Cwd is required")
 	}
-	var logger logging.Logger
-	if opts.Logger != nil {
-		logger = opts.Logger
-	} else {
-		logger = logging.NewLogger(opts.Err)
-	}
-	return &Server{
+
+	s := &Server{
 		r:                     opts.In,
 		w:                     opts.Out,
 		stderr:                opts.Err,
-		logger:                logger,
 		requestQueue:          make(chan *lsproto.RequestMessage, 100),
 		outgoingQueue:         make(chan *lsproto.Message, 100),
 		pendingClientRequests: make(map[lsproto.ID]pendingClientRequest),
@@ -71,9 +60,11 @@ func NewServer(opts *ServerOptions) *Server {
 		typingsLocation:       opts.TypingsLocation,
 		parseCache:            opts.ParseCache,
 		npmInstall:            opts.NpmInstall,
-		client:                opts.Client,
 		initComplete:          make(chan struct{}),
 	}
+	s.logger = newLogger(s)
+
+	return s
 }
 
 var (
@@ -143,7 +134,8 @@ type Server struct {
 
 	stderr io.Writer
 
-	logger                  logging.Logger
+	logger                  *logger
+	initStarted             atomic.Bool
 	clientSeq               atomic.Int32
 	requestQueue            chan *lsproto.RequestMessage
 	outgoingQueue           chan *lsproto.Message
@@ -293,7 +285,7 @@ func (s *Server) RequestConfiguration(ctx context.Context) (*lsutil.UserPreferen
 	if err != nil {
 		return nil, fmt.Errorf("configure request failed: %w", err)
 	}
-	s.Log(fmt.Sprintf("\n\nconfiguration: %+v, %T\n\n", configs, configs))
+	s.logger.Infof("configuration: %+v, %T", configs, configs)
 	userPreferences := s.session.NewUserPreferences()
 	for _, item := range configs {
 		if parsed := userPreferences.Parse(item); parsed != nil {
@@ -508,7 +500,7 @@ func (s *Server) handleRequestOrNotification(ctx context.Context, req *lsproto.R
 	if handler := handlers()[req.Method]; handler != nil {
 		return handler(s, ctx, req)
 	}
-	s.Log("unknown method", req.Method)
+	s.logger.Warn("unknown method", req.Method)
 	if req.ID != nil {
 		s.sendError(req.ID, lsproto.ErrorCodeInvalidRequest)
 	}
@@ -701,11 +693,11 @@ func (c *crossProjectOrchestrator) RecoverWith(r any) {
 
 func (s *Server) recoverWith(req *lsproto.RequestMessage, r any) {
 	stack := debug.Stack()
-	s.Log("panic handling request", req.Method, r, string(stack))
+	s.logger.Error("panic handling request", req.Method, r, string(stack))
 	if req.ID != nil {
 		s.sendError(req.ID, fmt.Errorf("%w: panic handling request %s: %v", lsproto.ErrorCodeInternalError, req.Method, r))
 	} else {
-		s.Log("unhandled panic in notification", req.Method, r)
+		s.logger.Error("unhandled panic in notification", req.Method, r)
 	}
 }
 
@@ -720,15 +712,16 @@ func (s *Server) handleInitialize(ctx context.Context, params *lsproto.Initializ
 		return nil, lsproto.ErrorCodeInvalidRequest
 	}
 
+	s.initStarted.Store(true)
+
 	s.initializeParams = params
-	s.clientCapabilities = resolveClientCapabilities(params.Capabilities)
+	s.clientCapabilities = lsproto.ResolveClientCapabilities(params.Capabilities)
 
-	if _, err := fmt.Fprint(s.stderr, "Resolved client capabilities: "); err != nil {
-		return nil, err
-	}
-	if err := jsonutil.MarshalIndentWrite(s.stderr, &s.clientCapabilities, "", "\t"); err != nil {
+	capabilitiesJSON, err := jsonutil.MarshalIndent(&s.clientCapabilities, "", "\t")
+	if err != nil {
 		return nil, err
 	}
+	s.logger.Info("Resolved client capabilities: " + string(capabilitiesJSON))
 
 	s.positionEncoding = lsproto.PositionEncodingKindUTF16
 	if slices.Contains(s.clientCapabilities.General.PositionEncodings, lsproto.PositionEncodingKindUTF8) {
@@ -1160,10 +1153,6 @@ func (s *Server) handleCallHierarchyOutgoingCalls(
 	return languageService.ProvideCallHierarchyOutgoingCalls(ctx, params.Item)
 }
 
-func (s *Server) Log(msg ...any) {
-	fmt.Fprintln(s.stderr, msg...)
-}
-
 // !!! temporary; remove when we have `handleDidChangeConfiguration`/implicit project config support
 func (s *Server) SetCompilerOptionsForInferredProjects(ctx context.Context, options *core.CompilerOptions) {
 	s.compilerOptionsForInferredProjects = options
@@ -1196,29 +1185,3 @@ func isBlockingMethod(method lsproto.Method) bool {
 func ptrTo[T any](v T) *T {
 	return &v
 }
-
-func resolveClientCapabilities(caps *lsproto.ClientCapabilities) lsproto.ResolvedClientCapabilities {
-	resolved := lsproto.ResolveClientCapabilities(caps)
-
-	// Some clients claim that push and pull diagnostics have different capabilities,
-	// including vscode-languageclient v9. Work around this by defaulting any missing
-	// pull diagnostic caps with the pull diagnostic equivalents.
-	//
-	// TODO: remove when we upgrade to vscode-languageclient v10, which fixes this issue.
-	publish := resolved.TextDocument.PublishDiagnostics
-	diagnostic := &resolved.TextDocument.Diagnostic
-	if !diagnostic.RelatedInformation && publish.RelatedInformation {
-		diagnostic.RelatedInformation = true
-	}
-	if !diagnostic.CodeDescriptionSupport && publish.CodeDescriptionSupport {
-		diagnostic.CodeDescriptionSupport = true
-	}
-	if !diagnostic.DataSupport && publish.DataSupport {
-		diagnostic.DataSupport = true
-	}
-	if len(diagnostic.TagSupport.ValueSet) == 0 && len(publish.TagSupport.ValueSet) > 0 {
-		diagnostic.TagSupport.ValueSet = publish.TagSupport.ValueSet
-	}
-
-	return resolved
-}