mirror of https://github.com/coder/code-server.git
374 lines
14 KiB
TypeScript
374 lines
14 KiB
TypeScript
/*---------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
*--------------------------------------------------------------------------------------------*/
|
|
|
|
import {
|
|
Connection, TextDocuments, InitializeParams, InitializeResult, ServerCapabilities, ConfigurationRequest, WorkspaceFolder, TextDocumentSyncKind, NotificationType
|
|
} from 'vscode-languageserver';
|
|
import { URI } from 'vscode-uri';
|
|
import { getCSSLanguageService, getSCSSLanguageService, getLESSLanguageService, LanguageSettings, LanguageService, Stylesheet, TextDocument, Position } from 'vscode-css-languageservice';
|
|
import { getLanguageModelCache } from './languageModelCache';
|
|
import { formatError, runSafeAsync } from './utils/runner';
|
|
import { getDocumentContext } from './utils/documentContext';
|
|
import { fetchDataProviders } from './customData';
|
|
import { RequestService, getRequestService } from './requests';
|
|
|
|
namespace CustomDataChangedNotification {
|
|
export const type: NotificationType<string[]> = new NotificationType('css/customDataChanged');
|
|
}
|
|
|
|
export interface Settings {
|
|
css: LanguageSettings;
|
|
less: LanguageSettings;
|
|
scss: LanguageSettings;
|
|
}
|
|
|
|
export interface RuntimeEnvironment {
|
|
file?: RequestService;
|
|
http?: RequestService
|
|
}
|
|
|
|
export function startServer(connection: Connection, runtime: RuntimeEnvironment) {
|
|
|
|
// Create a text document manager.
|
|
const documents = new TextDocuments(TextDocument);
|
|
// Make the text document manager listen on the connection
|
|
// for open, change and close text document events
|
|
documents.listen(connection);
|
|
|
|
const stylesheets = getLanguageModelCache<Stylesheet>(10, 60, document => getLanguageService(document).parseStylesheet(document));
|
|
documents.onDidClose(e => {
|
|
stylesheets.onDocumentRemoved(e.document);
|
|
});
|
|
connection.onShutdown(() => {
|
|
stylesheets.dispose();
|
|
});
|
|
|
|
let scopedSettingsSupport = false;
|
|
let foldingRangeLimit = Number.MAX_VALUE;
|
|
let workspaceFolders: WorkspaceFolder[];
|
|
|
|
let dataProvidersReady: Promise<any> = Promise.resolve();
|
|
|
|
const languageServices: { [id: string]: LanguageService } = {};
|
|
|
|
const notReady = () => Promise.reject('Not Ready');
|
|
let requestService: RequestService = { getContent: notReady, stat: notReady, readDirectory: notReady };
|
|
|
|
// After the server has started the client sends an initialize request. The server receives
|
|
// in the passed params the rootPath of the workspace plus the client capabilities.
|
|
connection.onInitialize((params: InitializeParams): InitializeResult => {
|
|
workspaceFolders = (<any>params).workspaceFolders;
|
|
if (!Array.isArray(workspaceFolders)) {
|
|
workspaceFolders = [];
|
|
if (params.rootPath) {
|
|
workspaceFolders.push({ name: '', uri: URI.file(params.rootPath).toString() });
|
|
}
|
|
}
|
|
|
|
requestService = getRequestService(params.initializationOptions?.handledSchemas || ['file'], connection, runtime);
|
|
|
|
function getClientCapability<T>(name: string, def: T) {
|
|
const keys = name.split('.');
|
|
let c: any = params.capabilities;
|
|
for (let i = 0; c && i < keys.length; i++) {
|
|
if (!c.hasOwnProperty(keys[i])) {
|
|
return def;
|
|
}
|
|
c = c[keys[i]];
|
|
}
|
|
return c;
|
|
}
|
|
const snippetSupport = !!getClientCapability('textDocument.completion.completionItem.snippetSupport', false);
|
|
scopedSettingsSupport = !!getClientCapability('workspace.configuration', false);
|
|
foldingRangeLimit = getClientCapability('textDocument.foldingRange.rangeLimit', Number.MAX_VALUE);
|
|
|
|
languageServices.css = getCSSLanguageService({ fileSystemProvider: requestService, clientCapabilities: params.capabilities });
|
|
languageServices.scss = getSCSSLanguageService({ fileSystemProvider: requestService, clientCapabilities: params.capabilities });
|
|
languageServices.less = getLESSLanguageService({ fileSystemProvider: requestService, clientCapabilities: params.capabilities });
|
|
|
|
const capabilities: ServerCapabilities = {
|
|
textDocumentSync: TextDocumentSyncKind.Incremental,
|
|
completionProvider: snippetSupport ? { resolveProvider: false, triggerCharacters: ['/', '-', ':'] } : undefined,
|
|
hoverProvider: true,
|
|
documentSymbolProvider: true,
|
|
referencesProvider: true,
|
|
definitionProvider: true,
|
|
documentHighlightProvider: true,
|
|
documentLinkProvider: {
|
|
resolveProvider: false
|
|
},
|
|
codeActionProvider: true,
|
|
renameProvider: true,
|
|
colorProvider: {},
|
|
foldingRangeProvider: true,
|
|
selectionRangeProvider: true
|
|
};
|
|
return { capabilities };
|
|
});
|
|
|
|
function getLanguageService(document: TextDocument) {
|
|
let service = languageServices[document.languageId];
|
|
if (!service) {
|
|
connection.console.log('Document type is ' + document.languageId + ', using css instead.');
|
|
service = languageServices['css'];
|
|
}
|
|
return service;
|
|
}
|
|
|
|
let documentSettings: { [key: string]: Thenable<LanguageSettings | undefined> } = {};
|
|
// remove document settings on close
|
|
documents.onDidClose(e => {
|
|
delete documentSettings[e.document.uri];
|
|
});
|
|
function getDocumentSettings(textDocument: TextDocument): Thenable<LanguageSettings | undefined> {
|
|
if (scopedSettingsSupport) {
|
|
let promise = documentSettings[textDocument.uri];
|
|
if (!promise) {
|
|
const configRequestParam = { items: [{ scopeUri: textDocument.uri, section: textDocument.languageId }] };
|
|
promise = connection.sendRequest(ConfigurationRequest.type, configRequestParam).then(s => s[0]);
|
|
documentSettings[textDocument.uri] = promise;
|
|
}
|
|
return promise;
|
|
}
|
|
return Promise.resolve(undefined);
|
|
}
|
|
|
|
// The settings have changed. Is send on server activation as well.
|
|
connection.onDidChangeConfiguration(change => {
|
|
updateConfiguration(<Settings>change.settings);
|
|
});
|
|
|
|
function updateConfiguration(settings: Settings) {
|
|
for (const languageId in languageServices) {
|
|
languageServices[languageId].configure((settings as any)[languageId]);
|
|
}
|
|
// reset all document settings
|
|
documentSettings = {};
|
|
// Revalidate any open text documents
|
|
documents.all().forEach(triggerValidation);
|
|
}
|
|
|
|
const pendingValidationRequests: { [uri: string]: NodeJS.Timer } = {};
|
|
const validationDelayMs = 500;
|
|
|
|
// The content of a text document has changed. This event is emitted
|
|
// when the text document first opened or when its content has changed.
|
|
documents.onDidChangeContent(change => {
|
|
triggerValidation(change.document);
|
|
});
|
|
|
|
// a document has closed: clear all diagnostics
|
|
documents.onDidClose(event => {
|
|
cleanPendingValidation(event.document);
|
|
connection.sendDiagnostics({ uri: event.document.uri, diagnostics: [] });
|
|
});
|
|
|
|
function cleanPendingValidation(textDocument: TextDocument): void {
|
|
const request = pendingValidationRequests[textDocument.uri];
|
|
if (request) {
|
|
clearTimeout(request);
|
|
delete pendingValidationRequests[textDocument.uri];
|
|
}
|
|
}
|
|
|
|
function triggerValidation(textDocument: TextDocument): void {
|
|
cleanPendingValidation(textDocument);
|
|
pendingValidationRequests[textDocument.uri] = setTimeout(() => {
|
|
delete pendingValidationRequests[textDocument.uri];
|
|
validateTextDocument(textDocument);
|
|
}, validationDelayMs);
|
|
}
|
|
|
|
function validateTextDocument(textDocument: TextDocument): void {
|
|
const settingsPromise = getDocumentSettings(textDocument);
|
|
Promise.all([settingsPromise, dataProvidersReady]).then(async ([settings]) => {
|
|
const stylesheet = stylesheets.get(textDocument);
|
|
const diagnostics = getLanguageService(textDocument).doValidation(textDocument, stylesheet, settings);
|
|
// Send the computed diagnostics to VSCode.
|
|
connection.sendDiagnostics({ uri: textDocument.uri, diagnostics });
|
|
}, e => {
|
|
connection.console.error(formatError(`Error while validating ${textDocument.uri}`, e));
|
|
});
|
|
}
|
|
|
|
|
|
function updateDataProviders(dataPaths: string[]) {
|
|
dataProvidersReady = fetchDataProviders(dataPaths, requestService).then(customDataProviders => {
|
|
for (const lang in languageServices) {
|
|
languageServices[lang].setDataProviders(true, customDataProviders);
|
|
}
|
|
});
|
|
}
|
|
|
|
connection.onCompletion((textDocumentPosition, token) => {
|
|
return runSafeAsync(async () => {
|
|
const document = documents.get(textDocumentPosition.textDocument.uri);
|
|
if (document) {
|
|
await dataProvidersReady;
|
|
const styleSheet = stylesheets.get(document);
|
|
const documentContext = getDocumentContext(document.uri, workspaceFolders);
|
|
return getLanguageService(document).doComplete2(document, textDocumentPosition.position, styleSheet, documentContext);
|
|
}
|
|
return null;
|
|
}, null, `Error while computing completions for ${textDocumentPosition.textDocument.uri}`, token);
|
|
});
|
|
|
|
connection.onHover((textDocumentPosition, token) => {
|
|
return runSafeAsync(async () => {
|
|
const document = documents.get(textDocumentPosition.textDocument.uri);
|
|
if (document) {
|
|
await dataProvidersReady;
|
|
const styleSheet = stylesheets.get(document);
|
|
return getLanguageService(document).doHover(document, textDocumentPosition.position, styleSheet);
|
|
}
|
|
return null;
|
|
}, null, `Error while computing hover for ${textDocumentPosition.textDocument.uri}`, token);
|
|
});
|
|
|
|
connection.onDocumentSymbol((documentSymbolParams, token) => {
|
|
return runSafeAsync(async () => {
|
|
const document = documents.get(documentSymbolParams.textDocument.uri);
|
|
if (document) {
|
|
await dataProvidersReady;
|
|
const stylesheet = stylesheets.get(document);
|
|
return getLanguageService(document).findDocumentSymbols(document, stylesheet);
|
|
}
|
|
return [];
|
|
}, [], `Error while computing document symbols for ${documentSymbolParams.textDocument.uri}`, token);
|
|
});
|
|
|
|
connection.onDefinition((documentDefinitionParams, token) => {
|
|
return runSafeAsync(async () => {
|
|
const document = documents.get(documentDefinitionParams.textDocument.uri);
|
|
if (document) {
|
|
await dataProvidersReady;
|
|
const stylesheet = stylesheets.get(document);
|
|
return getLanguageService(document).findDefinition(document, documentDefinitionParams.position, stylesheet);
|
|
}
|
|
return null;
|
|
}, null, `Error while computing definitions for ${documentDefinitionParams.textDocument.uri}`, token);
|
|
});
|
|
|
|
connection.onDocumentHighlight((documentHighlightParams, token) => {
|
|
return runSafeAsync(async () => {
|
|
const document = documents.get(documentHighlightParams.textDocument.uri);
|
|
if (document) {
|
|
await dataProvidersReady;
|
|
const stylesheet = stylesheets.get(document);
|
|
return getLanguageService(document).findDocumentHighlights(document, documentHighlightParams.position, stylesheet);
|
|
}
|
|
return [];
|
|
}, [], `Error while computing document highlights for ${documentHighlightParams.textDocument.uri}`, token);
|
|
});
|
|
|
|
|
|
connection.onDocumentLinks(async (documentLinkParams, token) => {
|
|
return runSafeAsync(async () => {
|
|
const document = documents.get(documentLinkParams.textDocument.uri);
|
|
if (document) {
|
|
await dataProvidersReady;
|
|
const documentContext = getDocumentContext(document.uri, workspaceFolders);
|
|
const stylesheet = stylesheets.get(document);
|
|
return getLanguageService(document).findDocumentLinks2(document, stylesheet, documentContext);
|
|
}
|
|
return [];
|
|
}, [], `Error while computing document links for ${documentLinkParams.textDocument.uri}`, token);
|
|
});
|
|
|
|
|
|
connection.onReferences((referenceParams, token) => {
|
|
return runSafeAsync(async () => {
|
|
const document = documents.get(referenceParams.textDocument.uri);
|
|
if (document) {
|
|
await dataProvidersReady;
|
|
const stylesheet = stylesheets.get(document);
|
|
return getLanguageService(document).findReferences(document, referenceParams.position, stylesheet);
|
|
}
|
|
return [];
|
|
}, [], `Error while computing references for ${referenceParams.textDocument.uri}`, token);
|
|
});
|
|
|
|
connection.onCodeAction((codeActionParams, token) => {
|
|
return runSafeAsync(async () => {
|
|
const document = documents.get(codeActionParams.textDocument.uri);
|
|
if (document) {
|
|
await dataProvidersReady;
|
|
const stylesheet = stylesheets.get(document);
|
|
return getLanguageService(document).doCodeActions(document, codeActionParams.range, codeActionParams.context, stylesheet);
|
|
}
|
|
return [];
|
|
}, [], `Error while computing code actions for ${codeActionParams.textDocument.uri}`, token);
|
|
});
|
|
|
|
connection.onDocumentColor((params, token) => {
|
|
return runSafeAsync(async () => {
|
|
const document = documents.get(params.textDocument.uri);
|
|
if (document) {
|
|
await dataProvidersReady;
|
|
const stylesheet = stylesheets.get(document);
|
|
return getLanguageService(document).findDocumentColors(document, stylesheet);
|
|
}
|
|
return [];
|
|
}, [], `Error while computing document colors for ${params.textDocument.uri}`, token);
|
|
});
|
|
|
|
connection.onColorPresentation((params, token) => {
|
|
return runSafeAsync(async () => {
|
|
const document = documents.get(params.textDocument.uri);
|
|
if (document) {
|
|
await dataProvidersReady;
|
|
const stylesheet = stylesheets.get(document);
|
|
return getLanguageService(document).getColorPresentations(document, stylesheet, params.color, params.range);
|
|
}
|
|
return [];
|
|
}, [], `Error while computing color presentations for ${params.textDocument.uri}`, token);
|
|
});
|
|
|
|
connection.onRenameRequest((renameParameters, token) => {
|
|
return runSafeAsync(async () => {
|
|
const document = documents.get(renameParameters.textDocument.uri);
|
|
if (document) {
|
|
await dataProvidersReady;
|
|
const stylesheet = stylesheets.get(document);
|
|
return getLanguageService(document).doRename(document, renameParameters.position, renameParameters.newName, stylesheet);
|
|
}
|
|
return null;
|
|
}, null, `Error while computing renames for ${renameParameters.textDocument.uri}`, token);
|
|
});
|
|
|
|
connection.onFoldingRanges((params, token) => {
|
|
return runSafeAsync(async () => {
|
|
const document = documents.get(params.textDocument.uri);
|
|
if (document) {
|
|
await dataProvidersReady;
|
|
return getLanguageService(document).getFoldingRanges(document, { rangeLimit: foldingRangeLimit });
|
|
}
|
|
return null;
|
|
}, null, `Error while computing folding ranges for ${params.textDocument.uri}`, token);
|
|
});
|
|
|
|
connection.onSelectionRanges((params, token) => {
|
|
return runSafeAsync(async () => {
|
|
const document = documents.get(params.textDocument.uri);
|
|
const positions: Position[] = params.positions;
|
|
|
|
if (document) {
|
|
await dataProvidersReady;
|
|
const stylesheet = stylesheets.get(document);
|
|
return getLanguageService(document).getSelectionRanges(document, positions, stylesheet);
|
|
}
|
|
return [];
|
|
}, [], `Error while computing selection ranges for ${params.textDocument.uri}`, token);
|
|
});
|
|
|
|
connection.onNotification(CustomDataChangedNotification.type, updateDataProviders);
|
|
|
|
// Listen on the connection
|
|
connection.listen();
|
|
|
|
}
|
|
|
|
|