[clangd] Added a skeleton for a semantic highlighting feature to the vscode extension.

[jvikstrom]

Summary

This adds a SemanticHighlighting feature to the vscode extension that does not do anything. It adds the notification handler to the clangd client and registers the feature by type intersection on the vscode lsp client capabilities.
The notification handler does not currently do anything if/when clangd sends a semantic highlighting notification.

[jvikstrom]

Removed the experimental capability and added it to the normal capabilites using type intersection.

[hokein]

The skeleton looks good, but apparently it does nothing (only enable the feature), do you have a small working prototype?

[jvikstrom]

Added check that clangd server actually supports semantic highlighting.

[jvikstrom]

In D65395#1607889, @hokein wrote:

The skeleton looks good, but apparently it does nothing (only enable the feature), do you have a small working prototype?

I've got a prototype that colors all the highlightings red, but it would make the CL become quite big if I added that as well. This felt like a reasonable place to divide it. Do you want me to add that as well or should I keep it as 2-3 CLs? (i.e. this -> TM scopes -> highlighting rendering)

clang-tools-extra/clangd/clients/clangd-vscode/.gitignore

 out
 node_modules
+.vscode-test

clang-tools-extra/clangd/clients/clangd-vscode/src/SemanticHighlighting.ts

+import * as vscodelc from 'vscode-languageclient';
+import { DocumentSelector } from 'vscode-languageclient';
+
+export namespace SemanticHighlighting {
+    interface HighlightingInformation {
+        textDocument: {
+            uri: String,
+        },
+        lines: [{
+            line: number,
+            tokens: string,
+        }],
+    }
+
+    export const NotificationType = new vscodelc.NotificationType<{}, void>('textDocument/semanticHighlighting');
+
+    // The feature that should be registered in the vscode lsp for enabling experimental semantic highlighting.
+    export class Feature implements vscodelc.StaticFeature {
+        scopes: string[];
+        fillClientCapabilities(capabilities: vscodelc.ClientCapabilities) {
+            const textDocumentCapabilities: vscodelc.TextDocumentClientCapabilities & { semanticHighlightingCapabilities?: { semanticHighlighting: boolean } } = capabilities.textDocument;
+            textDocumentCapabilities.semanticHighlightingCapabilities = { semanticHighlighting: true };
+
+        }
+
+        initialize(capabilities: vscodelc.ServerCapabilities, documentSelector: DocumentSelector | undefined) {
+            // Use type intersection to be able to read the semanticHighlighting capability the clangd server added in the response.
+            const serverCapabilities: vscodelc.ServerCapabilities & { semanticHighlighting?: { scopes: string[] } } = capabilities;
+            if(!serverCapabilities.semanticHighlighting)
+                return;
+            this.scopes = serverCapabilities.semanticHighlighting.scopes;
+        }
+
+        handleNotification(params: HighlightingInformation) { }
+    }
+};

clang-tools-extra/clangd/clients/clangd-vscode/src/extension.ts

 import * as vscode from 'vscode';
 import * as vscodelc from 'vscode-languageclient';
+import { SemanticHighlighting } from './SemanticHighlighting';
 
 /**
  * Method to get workspace configuration option
  * @param option name of the option (e.g. for clangd.path should be path)
  * @param defaultValue default value to return if option is not set
  */
 function getConfig<T>(option: string, defaultValue?: any): T {
     const config = vscode.workspace.getConfiguration('clangd');
     return config.get<T>(option, defaultValue);
 }
 
 namespace SwitchSourceHeaderRequest {
     export const type =
-    new vscodelc.RequestType<vscodelc.TextDocumentIdentifier, string|undefined,
-                             void, void>('textDocument/switchSourceHeader');
+        new vscodelc.RequestType<vscodelc.TextDocumentIdentifier, string | undefined,
 }
 
 class FileStatus {
     private statuses = new Map<string, any>();
     private readonly statusBarItem =
         vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left, 10);
 
     onFileUpdated(fileStatus: any) {
         const filePath = vscode.Uri.parse(fileStatus.uri);
         this.statuses.set(filePath.fsPath, fileStatus);
         this.updateStatus();
     }
 
     updateStatus() {
         const path = vscode.window.activeTextEditor.document.fileName;
         const status = this.statuses.get(path);
         if (!status) {
             this.statusBarItem.hide();
             return;
         }
         this.statusBarItem.text = `clangd: ` + status.state;
         this.statusBarItem.show();
     }
 
     clear() {
         this.statuses.clear();
         this.statusBarItem.hide();
export function activate(context: vscode.ExtensionContext) {
     const serverOptions: vscodelc.ServerOptions = clangd;
 
     // Note that CUDA ('.cu') files are special. When opening files of all other
     // extensions, VSCode would load clangd automatically. This is achieved by
     // having a corresponding 'onLanguage:...' activation event in package.json.
     // However, VSCode does not have CUDA as a supported language yet, so we
     // cannot add a corresponding activationEvent for CUDA files and clangd will
     // *not* load itself automatically on '.cu' files.
-    const cudaFilePattern: string = '**/*.{' +['cu'].join()+ '}';
+    const cudaFilePattern: string = '**/*.{' + ['cu'].join() + '}';
     const clientOptions: vscodelc.LanguageClientOptions = {
         // Register the server for c-family and cuda files.
         documentSelector: [
             { scheme: 'file', language: 'c' },
             { scheme: 'file', language: 'cpp' },
-            { scheme: 'file', language: 'objective-c'},
-            { scheme: 'file', language: 'objective-cpp'},
+            { scheme: 'file', language: 'objective-c' },
+            { scheme: 'file', language: 'objective-cpp' },
             { scheme: 'file', pattern: cudaFilePattern },
         ],
         synchronize: !syncFileEvents ? undefined : {
             // FIXME: send sync file events when clangd provides implemenatations.
         },
         initializationOptions: { clangdFileStatus: true },
         // Do not switch to output window when clangd returns output
         revealOutputChannelOn: vscodelc.RevealOutputChannelOn.Never
     };
 
-    const clangdClient = new vscodelc.LanguageClient('Clang Language Server',serverOptions, clientOptions);
+    const clangdClient = new vscodelc.LanguageClient('Clang Language Server', serverOptions, clientOptions);
+    const semanticHighlightingFeature = new SemanticHighlighting.Feature();
+    clangdClient.registerFeature(semanticHighlightingFeature);
+    // The notification handler must be registered after the client is ready or the client will crash.
+    clangdClient.onReady().then(() => clangdClient.onNotification(SemanticHighlighting.NotificationType, semanticHighlightingFeature.handleNotification));
+
     console.log('Clang Language Server is now active!');
     context.subscriptions.push(clangdClient.start());
     context.subscriptions.push(vscode.commands.registerCommand(
         'clangd-vscode.switchheadersource', async () => {
             const uri =
                 vscode.Uri.file(vscode.window.activeTextEditor.document.fileName);
             if (!uri) {
                 return;
clangdClient.onDidChangeState(
             } else if (newState == vscodelc.State.Stopped) {
                 // Clear all cached statuses when clangd crashes.
                 status.clear();
             }
         })
     // An empty place holder for the activate command, otherwise we'll get an
     // "command is not registered" error.
     context.subscriptions.push(vscode.commands.registerCommand(
-            'clangd-vscode.activate', async () => {}));
+        'clangd-vscode.activate', async () => { }));
 }