Rework capability registration and handler setup (#1327)

This PR changes how capability registration works such that:
- Dynamic registrations are honored on a per-capability basis rather
than only when the client supports several capabilities being
dynamically registered
- Most capabilities are registered _once_ after project discovery and
only re-registered after a server restart
- The completion capability will not re-register itself if trigger
characters have not changed

This should, in most cases, mean that *all* supported capabilities are
dynamically registered once at startup. Trigger characters only change
for projects where the variant separator is customizable, has been
customized, and includes a character that is not already considered a
trigger character (v4 does *not* allow customizing the variant separator
but v3 did)

Fixes #1319

- [x] Need to look into creating a reproduction w/ 500-ish v3 config
files in it to see if I can repro the original issue. We call
`updateCapabilities` after a build finishes and its likely that this
is/was slow enough with IntelliSense trying to handle 500 separate v3
projects at once

Author: thecrypticace

packages/tailwindcss-language-server/src/projects.ts

@@ -1086,6 +1086,11 @@ export async function createProjectService(
     refreshDiagnostics()
 
     updateCapabilities()
+
+    let isTestMode = params.initializationOptions?.testMode ?? false
+    if (!isTestMode) return
+
+    connection.sendNotification('@/tailwindCSS/projectReloaded')
   }
 
   for (let entry of projectConfig.config.entries) {

packages/tailwindcss-language-server/src/tw.ts

@@ -21,6 +21,8 @@ import type {
   WorkspaceFolder,
   CodeLensParams,
   CodeLens,
+  ServerCapabilities,
+  ClientCapabilities,
 } from 'vscode-languageserver/node'
 import {
   CompletionRequest,
@@ -624,6 +626,8 @@ export class TW {
 
     console.log(`[Global] Initializing projects...`)
 
+    await this.updateCommonCapabilities()
+
     // init projects for documents that are _already_ open
     let readyDocuments: string[] = []
     let enabledProjectCount = 0
@@ -640,8 +644,6 @@ export class TW {
 
     console.log(`[Global] Initialized ${enabledProjectCount} projects`)
 
-    this.setupLSPHandlers()
-
     this.disposables.push(
       this.connection.onDidChangeConfiguration(async ({ settings }) => {
         let previousExclude = globalSettings.tailwindCSS.files.exclude
@@ -763,7 +765,7 @@ export class TW {
       this.connection,
       params,
       this.documentService,
-      () => this.updateCapabilities(),
+      () => this.updateProjectCapabilities(),
       () => {
         for (let document of this.documentService.getAllDocuments()) {
           let project = this.getProject(document)
@@ -810,9 +812,7 @@ export class TW {
   }
 
   setupLSPHandlers() {
-    if (this.lspHandlersAdded) {
-      return
-    }
+    if (this.lspHandlersAdded) return
     this.lspHandlersAdded = true
 
     this.connection.onHover(this.onHover.bind(this))
@@ -858,43 +858,84 @@ export class TW {
     }
   }
 
-  private updateCapabilities() {
-    if (!supportsDynamicRegistration(this.initializeParams)) {
-      this.connection.client.register(DidChangeConfigurationNotification.type, undefined)
-      return
+  // Common capabilities are always supported by the language server and do not
+  // require any project-specific information to know how to configure them.
+  //
+  // These capabilities will stay valid until/unless the server has to restart
+  // in which case they'll be unregistered and then re-registered once project
+  // discovery has completed
+  private commonRegistrations: BulkUnregistration | undefined
+  private async updateCommonCapabilities() {
+    let capabilities = BulkRegistration.create()
+
+    let client = this.initializeParams.capabilities
+
+    if (client.textDocument?.hover?.dynamicRegistration) {
+      capabilities.add(HoverRequest.type, { documentSelector: null })
     }
 
-    if (this.registrations) {
-      this.registrations.then((r) => r.dispose())
+    if (client.textDocument?.colorProvider?.dynamicRegistration) {
+      capabilities.add(DocumentColorRequest.type, { documentSelector: null })
     }
 
-    let projects = Array.from(this.projects.values())
+    if (client.textDocument?.codeAction?.dynamicRegistration) {
+      capabilities.add(CodeActionRequest.type, { documentSelector: null })
+    }
 
-    let capabilities = BulkRegistration.create()
+    if (client.textDocument?.codeLens?.dynamicRegistration) {
+      capabilities.add(CodeLensRequest.type, { documentSelector: null })
+    }
+
+    if (client.textDocument?.documentLink?.dynamicRegistration) {
+      capabilities.add(DocumentLinkRequest.type, { documentSelector: null })
+    }
+
+    if (client.workspace?.didChangeConfiguration?.dynamicRegistration) {
+      capabilities.add(DidChangeConfigurationNotification.type, undefined)
+    }
 
-    // TODO: We should *not* be re-registering these capabilities
-    // IDEA: These should probably be static registrations up front
-    capabilities.add(HoverRequest.type, { documentSelector: null })
-    capabilities.add(DocumentColorRequest.type, { documentSelector: null })
-    capabilities.add(CodeActionRequest.type, { documentSelector: null })
-    capabilities.add(CodeLensRequest.type, { documentSelector: null })
-    capabilities.add(DocumentLinkRequest.type, { documentSelector: null })
-    capabilities.add(DidChangeConfigurationNotification.type, undefined)
-
-    // TODO: Only re-register this if trigger characters change
-    capabilities.add(CompletionRequest.type, {
+    this.commonRegistrations = await this.connection.client.register(capabilities)
+  }
+
+  // These capabilities depend on the projects we've found to appropriately
+  // configure them. This may mean collecting information from all discovered
+  // projects to determine what we can do and how
+  private updateProjectCapabilities() {
+    this.updateTriggerCharacters()
+  }
+
+  private lastTriggerCharacters: Set<string> | undefined
+  private completionRegistration: Disposable | undefined
+  private async updateTriggerCharacters() {
+    // If the client does not suppory dynamic registration of completions then
+    // we cannot update the set of trigger characters
+    let client = this.initializeParams.capabilities
+    if (!client.textDocument?.completion?.dynamicRegistration) return
+
+    // The new set of trigger characters is all the static ones plus
+    // any characters from any separator in v3 config
+    let chars = new Set<string>(TRIGGER_CHARACTERS)
+
+    for (let project of this.projects.values()) {
+      let sep = project.state.separator
+      if (typeof sep !== 'string') continue
+
+      sep = sep.slice(-1)
+      if (!sep) continue
+
+      chars.add(sep)
+    }
+
+    // If the trigger characters haven't changed then we don't need to do anything
+    if (equal(Array.from(chars), Array.from(this.lastTriggerCharacters ?? []))) return
+    this.lastTriggerCharacters = chars
+
+    this.completionRegistration?.dispose()
+    this.completionRegistration = await this.connection.client.register(CompletionRequest.type, {
       documentSelector: null,
       resolveProvider: true,
-      triggerCharacters: [
-        ...TRIGGER_CHARACTERS,
-        ...projects
-          .map((project) => project.state.separator)
-          .filter((sep) => typeof sep === 'string')
-          .map((sep) => sep.slice(-1)),
-      ].filter(Boolean),
+      triggerCharacters: Array.from(chars),
     })
-
-    this.registrations = this.connection.client.register(capabilities)
   }
 
   private getProject(document: TextDocumentIdentifier): ProjectService {
@@ -1016,47 +1057,58 @@ export class TW {
     this.connection.onInitialize(async (params: InitializeParams): Promise<InitializeResult> => {
       this.initializeParams = params
 
-      if (supportsDynamicRegistration(params)) {
-        return {
-          capabilities: {
-            textDocumentSync: TextDocumentSyncKind.Full,
-            workspace: {
-              workspaceFolders: {
-                changeNotifications: true,
-              },
-            },
-          },
-        }
-      }
-
       this.setupLSPHandlers()
 
       return {
-        capabilities: {
-          textDocumentSync: TextDocumentSyncKind.Full,
-          hoverProvider: true,
-          colorProvider: true,
-          codeActionProvider: true,
-          codeLensProvider: {
-            resolveProvider: false,
-          },
-          documentLinkProvider: {},
-          completionProvider: {
-            resolveProvider: true,
-            triggerCharacters: [...TRIGGER_CHARACTERS, ':'],
-          },
-          workspace: {
-            workspaceFolders: {
-              changeNotifications: true,
-            },
-          },
-        },
+        capabilities: this.computeServerCapabilities(params.capabilities),
       }
     })
 
     this.connection.onInitialized(() => this.init())
   }
 
+  computeServerCapabilities(client: ClientCapabilities) {
+    let capabilities: ServerCapabilities = {
+      textDocumentSync: TextDocumentSyncKind.Full,
+      workspace: {
+        workspaceFolders: {
+          changeNotifications: true,
+        },
+      },
+    }
+
+    if (!client.textDocument?.hover?.dynamicRegistration) {
+      capabilities.hoverProvider = true
+    }
+
+    if (!client.textDocument?.colorProvider?.dynamicRegistration) {
+      capabilities.colorProvider = true
+    }
+
+    if (!client.textDocument?.codeAction?.dynamicRegistration) {
+      capabilities.codeActionProvider = true
+    }
+
+    if (!client.textDocument?.codeLens?.dynamicRegistration) {
+      capabilities.codeLensProvider = {
+        resolveProvider: false,
+      }
+    }
+
+    if (!client.textDocument?.completion?.dynamicRegistration) {
+      capabilities.completionProvider = {
+        resolveProvider: true,
+        triggerCharacters: [...TRIGGER_CHARACTERS, ':'],
+      }
+    }
+
+    if (!client.textDocument?.documentLink?.dynamicRegistration) {
+      capabilities.documentLinkProvider = {}
+    }
+
+    return capabilities
+  }
+
   listen() {
     this.connection.listen()
   }
@@ -1070,10 +1122,11 @@ export class TW {
 
     this.refreshDiagnostics()
 
-    if (this.registrations) {
-      this.registrations.then((r) => r.dispose())
-      this.registrations = undefined
-    }
+    this.commonRegistrations?.dispose()
+    this.commonRegistrations = undefined
+
+    this.completionRegistration?.dispose()
+    this.completionRegistration = undefined
 
     this.disposables.forEach((d) => d.dispose())
     this.disposables.length = 0
@@ -1106,13 +1159,3 @@ export class TW {
     }
   }
 }
-
-function supportsDynamicRegistration(params: InitializeParams): boolean {
-  return (
-    params.capabilities.textDocument?.hover?.dynamicRegistration &&
-    params.capabilities.textDocument?.colorProvider?.dynamicRegistration &&
-    params.capabilities.textDocument?.codeAction?.dynamicRegistration &&
-    params.capabilities.textDocument?.completion?.dynamicRegistration &&
-    params.capabilities.textDocument?.documentLink?.dynamicRegistration
-  )
-}