fix: provide backcompat for extensions written before the root removal

Also sends dynamic capabilities equivalent to the default static capabilities.

Author: sqs

src/client/client.ts

@@ -225,6 +225,15 @@ export class Client implements Unsubscribable {
                 connection.onRequest(RegistrationRequest.type, params => this.handleRegistrationRequest(params))
                 connection.onRequest(UnregistrationRequest.type, params => this.handleUnregistrationRequest(params))
 
+                // Initialize static features.
+                for (const feature of this.features) {
+                    if (!DynamicFeature.is(feature)) {
+                        if (feature.initialize) {
+                            feature.initialize()
+                        }
+                    }
+                }
+
                 connection.sendNotification(InitializedNotification.type, {})
 
                 this._state.next(ClientState.Active)

src/client/features/common.test.ts

@@ -26,9 +26,6 @@ class TextDocumentFeature extends AbstractTextDocumentFeature<TextDocumentRegist
     public fillClientCapabilities(): void {
         /* noop */
     }
-    public initialize(): void {
-        /* noop */
-    }
 }
 
 const FIXTURE_REGISTER_OPTIONS: TextDocumentRegistrationOptions = { documentSelector: ['*'], extensionID: 'test' }

src/client/features/decoration.ts

@@ -1,27 +1,29 @@
-import { BehaviorSubject, Observable, Unsubscribable } from 'rxjs'
-import uuidv4 from 'uuid/v4'
+import { BehaviorSubject, Observable } from 'rxjs'
 import { TextDocumentIdentifier } from 'vscode-languageserver-types'
 import { ProvideTextDocumentDecorationSignature } from '../../environment/providers/decoration'
 import { FeatureProviderRegistry } from '../../environment/providers/registry'
 import { ClientCapabilities } from '../../protocol'
 import { TextDocumentDecoration, TextDocumentPublishDecorationsNotification } from '../../protocol/decoration'
 import { Client } from '../client'
-import { ensure, Feature } from './common'
+import { ensure, StaticFeature } from './common'
 
 /**
  * Support for text document decorations published by the server (textDocument/publishDecorations notifications
  * from the server).
  */
-export class TextDocumentDecorationFeature extends Feature<undefined> {
+export class TextDocumentDecorationFeature implements StaticFeature {
     /** Map of document URI to its decorations (last published by the server). */
     private decorations = new Map<string, BehaviorSubject<TextDocumentDecoration[] | null>>()
 
     constructor(
-        client: Client,
+        private client: Client,
         private registry: FeatureProviderRegistry<undefined, ProvideTextDocumentDecorationSignature>
     ) {
-        super(client)
-        this.register(this.messages, { id: uuidv4(), registerOptions: undefined })
+        this.registry.registerProvider(
+            undefined,
+            (textDocument: TextDocumentIdentifier): Observable<TextDocumentDecoration[] | null> =>
+                this.getDecorationsSubject(textDocument)
+        )
     }
 
     public readonly messages = TextDocumentPublishDecorationsNotification.type
@@ -31,24 +33,21 @@ export class TextDocumentDecorationFeature extends Feature<undefined> {
     }
 
     public initialize(): void {
+        // TODO(sqs): no way to unregister this
         this.client.onNotification(TextDocumentPublishDecorationsNotification.type, params => {
             this.getDecorationsSubject(params.textDocument, params.decorations)
         })
     }
 
-    protected registerProvider(): Unsubscribable {
-        return this.registry.registerProvider(
-            undefined,
-            (textDocument: TextDocumentIdentifier): Observable<TextDocumentDecoration[] | null> =>
-                this.getDecorationsSubject(textDocument)
-        )
+    public deinitialize(): void {
+        // Clear decorations;
+        for (const subject of Object.values(this.decorations)) {
+            subject.next(null)
+        }
     }
 
-    protected validateRegistrationOptions(data: any): undefined {
-        if (data) {
-            throw new Error('TextDocumentDecorationFeature registration options should be undefined')
-        }
-        return data
+    protected validateRegistrationOptions(_data: any): undefined {
+        return
     }
 
     private getDecorationsSubject(

src/extension/extension.test.ts

@@ -1,6 +1,12 @@
 import * as assert from 'assert'
 import { createConnection as createClientConnection } from '../client/connection'
-import { InitializedNotification, InitializeParams, InitializeRequest, InitializeResult } from '../protocol'
+import {
+    InitializedNotification,
+    InitializeParams,
+    InitializeRequest,
+    InitializeResult,
+    RegistrationRequest,
+} from '../protocol'
 import { createMessageTransports } from '../test/integration/helpers'
 import { activateExtension } from './extension'
 
@@ -16,6 +22,8 @@ describe('activateExtension', () => {
         }
         const initResult: InitializeResult = {}
 
+        clientConnection.onRequest(RegistrationRequest.type, () => void 0)
+
         const [, result] = await Promise.all([
             activateExtension<{}>(serverTransports, sourcegraph => {
                 assert.deepStrictEqual(sourcegraph.initializeParams, initParams)

src/extension/extension.ts

@@ -6,6 +6,8 @@ import {
     InitializeParams,
     InitializeRequest,
     InitializeResult,
+    RegistrationParams,
+    RegistrationRequest,
 } from '../protocol'
 import { Commands, Configuration, ExtensionContext, Observable, SourcegraphExtensionAPI, Window, Windows } from './api'
 import { createExtCommands } from './features/commands'
@@ -81,8 +83,33 @@ export function activateExtension<C>(
             return {} as InitializeResult
         })
         connection.onNotification(InitializedNotification.type, () => {
-            run(new ExtensionHandle<C>(connection, initializationParams))
-            resolve()
+            const handle = new ExtensionHandle<C>(connection, initializationParams)
+
+            // Register some capabilities that used to be implicit, for backcompat.
+            connection
+                .sendRequest(RegistrationRequest.type, {
+                    registrations: [
+                        {
+                            id: '__backcompat_1',
+                            method: 'textDocument/didOpen',
+                            registerOptions: { documentSelector: ['*'] },
+                        },
+                        {
+                            id: '__backcompat_2',
+                            method: 'textDocument/didClose',
+                            registerOptions: { documentSelector: ['*'] },
+                        },
+                        {
+                            id: '__backcompat_3',
+                            method: 'workspace/didChangeConfiguration',
+                        },
+                    ],
+                } as RegistrationParams)
+                .then(() => {
+                    run(handle)
+                    resolve()
+                })
+                .catch(err => console.error(err))
         })
 
         connection.listen()