Skip to content

Commit a180933

Browse files
aeschliaeschli
committed
[html] make mode services async
1 parent f591492 commit a180933

16 files changed

Lines changed: 320 additions & 305 deletions

‎extensions/html-language-features/server/extension-browser.webpack.config.js‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -25,6 +25,11 @@ const serverConfig = withDefaults({
2525
performance: {
2626
hints: false
2727
},
28+
optimization: {
29+
splitChunks: {
30+
chunks: "async"
31+
}
32+
},
2833
resolve: {
2934
alias: {
3035
'vscode-nls': path.resolve(__dirname, '../../../build/polyfills/vscode-nls.js')

‎extensions/html-language-features/server/src/htmlServer.ts‎

Lines changed: 32 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -18,7 +18,7 @@ import { format } from './modes/formatting';
1818
import { pushAll } from './utils/arrays';
1919
import { getDocumentContext } from './utils/documentContext';
2020
import { URI } from 'vscode-uri';
21-
import { formatError, runSafe, runSafeAsync } from './utils/runner';
21+
import { formatError, runSafe } from './utils/runner';
2222

2323
import { getFoldingRanges } from './modes/htmlFolding';
2424
import { fetchHTMLDataProviders } from './customData';
@@ -261,11 +261,11 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)
261261
const settings = await getDocumentSettings(textDocument, () => modes.some(m => !!m.doValidation));
262262
const latestTextDocument = documents.get(textDocument.uri);
263263
if (latestTextDocument && latestTextDocument.version === version) { // check no new version has come in after in after the async op
264-
modes.forEach(mode => {
264+
for (const mode of modes) {
265265
if (mode.doValidation && isValidationEnabled(mode.getId(), settings)) {
266-
pushAll(diagnostics, mode.doValidation(latestTextDocument, settings));
266+
pushAll(diagnostics, await mode.doValidation(latestTextDocument, settings));
267267
}
268-
});
268+
}
269269
connection.sendDiagnostics({ uri: latestTextDocument.uri, diagnostics });
270270
}
271271
}
@@ -275,7 +275,7 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)
275275
}
276276

277277
connection.onCompletion(async (textDocumentPosition, token) => {
278-
return runSafeAsync(async () => {
278+
return runSafe(async () => {
279279
const document = documents.get(textDocumentPosition.textDocument.uri);
280280
if (!document) {
281281
return null;
@@ -303,7 +303,7 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)
303303
});
304304

305305
connection.onCompletionResolve((item, token) => {
306-
return runSafe(() => {
306+
return runSafe(async () => {
307307
const data = item.data;
308308
if (data && data.languageId && data.uri) {
309309
const mode = languageModes.getMode(data.languageId);
@@ -317,7 +317,7 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)
317317
});
318318

319319
connection.onHover((textDocumentPosition, token) => {
320-
return runSafe(() => {
320+
return runSafe(async () => {
321321
const document = documents.get(textDocumentPosition.textDocument.uri);
322322
if (document) {
323323
const mode = languageModes.getModeAtPosition(document, textDocumentPosition.position);
@@ -330,7 +330,7 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)
330330
});
331331

332332
connection.onDocumentHighlight((documentHighlightParams, token) => {
333-
return runSafe(() => {
333+
return runSafe(async () => {
334334
const document = documents.get(documentHighlightParams.textDocument.uri);
335335
if (document) {
336336
const mode = languageModes.getModeAtPosition(document, documentHighlightParams.position);
@@ -343,7 +343,7 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)
343343
});
344344

345345
connection.onDefinition((definitionParams, token) => {
346-
return runSafe(() => {
346+
return runSafe(async () => {
347347
const document = documents.get(definitionParams.textDocument.uri);
348348
if (document) {
349349
const mode = languageModes.getModeAtPosition(document, definitionParams.position);
@@ -356,7 +356,7 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)
356356
});
357357

358358
connection.onReferences((referenceParams, token) => {
359-
return runSafe(() => {
359+
return runSafe(async () => {
360360
const document = documents.get(referenceParams.textDocument.uri);
361361
if (document) {
362362
const mode = languageModes.getModeAtPosition(document, referenceParams.position);
@@ -369,7 +369,7 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)
369369
});
370370

371371
connection.onSignatureHelp((signatureHelpParms, token) => {
372-
return runSafe(() => {
372+
return runSafe(async () => {
373373
const document = documents.get(signatureHelpParms.textDocument.uri);
374374
if (document) {
375375
const mode = languageModes.getModeAtPosition(document, signatureHelpParms.position);
@@ -382,7 +382,7 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)
382382
});
383383

384384
connection.onDocumentRangeFormatting(async (formatParams, token) => {
385-
return runSafeAsync(async () => {
385+
return runSafe(async () => {
386386
const document = documents.get(formatParams.textDocument.uri);
387387
if (document) {
388388
let settings = await getDocumentSettings(document, () => true);
@@ -399,53 +399,53 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)
399399
});
400400

401401
connection.onDocumentLinks((documentLinkParam, token) => {
402-
return runSafe(() => {
402+
return runSafe(async () => {
403403
const document = documents.get(documentLinkParam.textDocument.uri);
404404
const links: DocumentLink[] = [];
405405
if (document) {
406406
const documentContext = getDocumentContext(document.uri, workspaceFolders);
407-
languageModes.getAllModesInDocument(document).forEach(m => {
407+
for (const m of languageModes.getAllModesInDocument(document)) {
408408
if (m.findDocumentLinks) {
409-
pushAll(links, m.findDocumentLinks(document, documentContext));
409+
pushAll(links, await m.findDocumentLinks(document, documentContext));
410410
}
411-
});
411+
}
412412
}
413413
return links;
414414
}, [], `Error while document links for ${documentLinkParam.textDocument.uri}`, token);
415415
});
416416

417417
connection.onDocumentSymbol((documentSymbolParms, token) => {
418-
return runSafe(() => {
418+
return runSafe(async () => {
419419
const document = documents.get(documentSymbolParms.textDocument.uri);
420420
const symbols: SymbolInformation[] = [];
421421
if (document) {
422-
languageModes.getAllModesInDocument(document).forEach(m => {
422+
for (const m of languageModes.getAllModesInDocument(document)) {
423423
if (m.findDocumentSymbols) {
424-
pushAll(symbols, m.findDocumentSymbols(document));
424+
pushAll(symbols, await m.findDocumentSymbols(document));
425425
}
426-
});
426+
}
427427
}
428428
return symbols;
429429
}, [], `Error while computing document symbols for ${documentSymbolParms.textDocument.uri}`, token);
430430
});
431431

432432
connection.onRequest(DocumentColorRequest.type, (params, token) => {
433-
return runSafe(() => {
433+
return runSafe(async () => {
434434
const infos: ColorInformation[] = [];
435435
const document = documents.get(params.textDocument.uri);
436436
if (document) {
437-
languageModes.getAllModesInDocument(document).forEach(m => {
437+
for (const m of languageModes.getAllModesInDocument(document)) {
438438
if (m.findDocumentColors) {
439-
pushAll(infos, m.findDocumentColors(document));
439+
pushAll(infos, await m.findDocumentColors(document));
440440
}
441-
});
441+
}
442442
}
443443
return infos;
444444
}, [], `Error while computing document colors for ${params.textDocument.uri}`, token);
445445
});
446446

447447
connection.onRequest(ColorPresentationRequest.type, (params, token) => {
448-
return runSafe(() => {
448+
return runSafe(async () => {
449449
const document = documents.get(params.textDocument.uri);
450450
if (document) {
451451
const mode = languageModes.getModeAtPosition(document, params.range.start);
@@ -458,7 +458,7 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)
458458
});
459459

460460
connection.onRequest(TagCloseRequest.type, (params, token) => {
461-
return runSafe(() => {
461+
return runSafe(async () => {
462462
const document = documents.get(params.textDocument.uri);
463463
if (document) {
464464
const pos = params.position;
@@ -474,7 +474,7 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)
474474
});
475475

476476
connection.onFoldingRanges((params, token) => {
477-
return runSafe(() => {
477+
return runSafe(async () => {
478478
const document = documents.get(params.textDocument.uri);
479479
if (document) {
480480
return getFoldingRanges(languageModes, document, foldingRangeLimit, token);
@@ -484,7 +484,7 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)
484484
});
485485

486486
connection.onSelectionRanges((params, token) => {
487-
return runSafe(() => {
487+
return runSafe(async () => {
488488
const document = documents.get(params.textDocument.uri);
489489
if (document) {
490490
return getSelectionRanges(languageModes, document, params.positions);
@@ -494,7 +494,7 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)
494494
});
495495

496496
connection.onRenameRequest((params, token) => {
497-
return runSafe(() => {
497+
return runSafe(async () => {
498498
const document = documents.get(params.textDocument.uri);
499499
const position: Position = params.position;
500500

@@ -509,7 +509,7 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)
509509
});
510510

511511
connection.onRequest(OnTypeRenameRequest.type, (params, token) => {
512-
return runSafe(() => {
512+
return runSafe(async () => {
513513
const document = documents.get(params.textDocument.uri);
514514
if (document) {
515515
const pos = params.position;
@@ -533,7 +533,7 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)
533533
}
534534

535535
connection.onRequest(SemanticTokenRequest.type, (params, token) => {
536-
return runSafe(() => {
536+
return runSafe(async () => {
537537
const document = documents.get(params.textDocument.uri);
538538
if (document) {
539539
return getSemanticTokenProvider().getSemanticTokens(document, params.ranges);
@@ -543,7 +543,7 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)
543543
});
544544

545545
connection.onRequest(SemanticTokenLegendRequest.type, (_params, token) => {
546-
return runSafe(() => {
546+
return runSafe(async () => {
547547
return getSemanticTokenProvider().legend;
548548
}, null, `Error while computing semantic tokens legend`, token);
549549
});

‎extensions/html-language-features/server/src/modes/cssMode.ts‎

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@
55

66
import { LanguageModelCache, getLanguageModelCache } from '../languageModelCache';
77
import { Stylesheet, LanguageService as CSSLanguageService } from 'vscode-css-languageservice';
8-
import { FoldingRange, LanguageMode, Workspace, Color, TextDocument, Position, Range, CompletionList, DocumentContext } from './languageModes';
8+
import { LanguageMode, Workspace, Color, TextDocument, Position, Range, CompletionList, DocumentContext } from './languageModes';
99
import { HTMLDocumentRegions, CSS_STYLE_RULE } from './embeddedSupport';
1010

1111
export function getCSSMode(cssLanguageService: CSSLanguageService, documentRegions: LanguageModelCache<HTMLDocumentRegions>, workspace: Workspace): LanguageMode {
@@ -16,48 +16,48 @@ export function getCSSMode(cssLanguageService: CSSLanguageService, documentRegio
1616
getId() {
1717
return 'css';
1818
},
19-
doValidation(document: TextDocument, settings = workspace.settings) {
19+
async doValidation(document: TextDocument, settings = workspace.settings) {
2020
let embedded = embeddedCSSDocuments.get(document);
2121
return cssLanguageService.doValidation(embedded, cssStylesheets.get(embedded), settings && settings.css);
2222
},
23-
doComplete(document: TextDocument, position: Position, documentContext: DocumentContext, _settings = workspace.settings) {
23+
async doComplete(document: TextDocument, position: Position, documentContext: DocumentContext, _settings = workspace.settings) {
2424
let embedded = embeddedCSSDocuments.get(document);
2525
const stylesheet = cssStylesheets.get(embedded);
2626
return cssLanguageService.doComplete2(embedded, position, stylesheet, documentContext) || CompletionList.create();
2727
},
28-
doHover(document: TextDocument, position: Position) {
28+
async doHover(document: TextDocument, position: Position) {
2929
let embedded = embeddedCSSDocuments.get(document);
3030
return cssLanguageService.doHover(embedded, position, cssStylesheets.get(embedded));
3131
},
32-
findDocumentHighlight(document: TextDocument, position: Position) {
32+
async findDocumentHighlight(document: TextDocument, position: Position) {
3333
let embedded = embeddedCSSDocuments.get(document);
3434
return cssLanguageService.findDocumentHighlights(embedded, position, cssStylesheets.get(embedded));
3535
},
36-
findDocumentSymbols(document: TextDocument) {
36+
async findDocumentSymbols(document: TextDocument) {
3737
let embedded = embeddedCSSDocuments.get(document);
3838
return cssLanguageService.findDocumentSymbols(embedded, cssStylesheets.get(embedded)).filter(s => s.name !== CSS_STYLE_RULE);
3939
},
40-
findDefinition(document: TextDocument, position: Position) {
40+
async findDefinition(document: TextDocument, position: Position) {
4141
let embedded = embeddedCSSDocuments.get(document);
4242
return cssLanguageService.findDefinition(embedded, position, cssStylesheets.get(embedded));
4343
},
44-
findReferences(document: TextDocument, position: Position) {
44+
async findReferences(document: TextDocument, position: Position) {
4545
let embedded = embeddedCSSDocuments.get(document);
4646
return cssLanguageService.findReferences(embedded, position, cssStylesheets.get(embedded));
4747
},
48-
findDocumentColors(document: TextDocument) {
48+
async findDocumentColors(document: TextDocument) {
4949
let embedded = embeddedCSSDocuments.get(document);
5050
return cssLanguageService.findDocumentColors(embedded, cssStylesheets.get(embedded));
5151
},
52-
getColorPresentations(document: TextDocument, color: Color, range: Range) {
52+
async getColorPresentations(document: TextDocument, color: Color, range: Range) {
5353
let embedded = embeddedCSSDocuments.get(document);
5454
return cssLanguageService.getColorPresentations(embedded, cssStylesheets.get(embedded), color, range);
5555
},
56-
getFoldingRanges(document: TextDocument): FoldingRange[] {
56+
async getFoldingRanges(document: TextDocument) {
5757
let embedded = embeddedCSSDocuments.get(document);
5858
return cssLanguageService.getFoldingRanges(embedded, {});
5959
},
60-
getSelectionRange(document: TextDocument, position: Position) {
60+
async getSelectionRange(document: TextDocument, position: Position) {
6161
let embedded = embeddedCSSDocuments.get(document);
6262
return cssLanguageService.getSelectionRanges(embedded, [position], cssStylesheets.get(embedded))[0];
6363
},

‎extensions/html-language-features/server/src/modes/formatting.ts‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@ import { LanguageModes, Settings, LanguageModeRange, TextDocument, Range, TextEd
77
import { pushAll } from '../utils/arrays';
88
import { isEOL } from '../utils/strings';
99

10-
export function format(languageModes: LanguageModes, document: TextDocument, formatRange: Range, formattingOptions: FormattingOptions, settings: Settings | undefined, enabledModes: { [mode: string]: boolean }) {
10+
export async function format(languageModes: LanguageModes, document: TextDocument, formatRange: Range, formattingOptions: FormattingOptions, settings: Settings | undefined, enabledModes: { [mode: string]: boolean }) {
1111
let result: TextEdit[] = [];
1212

1313
let endPos = formatRange.end;
@@ -39,7 +39,7 @@ export function format(languageModes: LanguageModes, document: TextDocument, for
3939
while (i < allRanges.length && !isHTML(allRanges[i])) {
4040
let range = allRanges[i];
4141
if (!range.attributeValue && range.mode && range.mode.format) {
42-
let edits = range.mode.format(document, Range.create(startPos, range.end), formattingOptions, settings);
42+
let edits = await range.mode.format(document, Range.create(startPos, range.end), formattingOptions, settings);
4343
pushAll(result, edits);
4444
}
4545
startPos = range.end;
@@ -53,7 +53,7 @@ export function format(languageModes: LanguageModes, document: TextDocument, for
5353

5454
// perform a html format and apply changes to a new document
5555
let htmlMode = languageModes.getMode('html')!;
56-
let htmlEdits = htmlMode.format!(document, formatRange, formattingOptions, settings);
56+
let htmlEdits = await htmlMode.format!(document, formatRange, formattingOptions, settings);
5757
let htmlFormattedContent = TextDocument.applyEdits(document, htmlEdits);
5858
let newDocument = TextDocument.create(document.uri + '.tmp', document.languageId, document.version, htmlFormattedContent);
5959
try {
@@ -67,7 +67,7 @@ export function format(languageModes: LanguageModes, document: TextDocument, for
6767
for (let r of embeddedRanges) {
6868
let mode = r.mode;
6969
if (mode && mode.format && enabledModes[mode.getId()] && !r.attributeValue) {
70-
let edits = mode.format(newDocument, r, formattingOptions, settings);
70+
let edits = await mode.format(newDocument, r, formattingOptions, settings);
7171
for (let edit of edits) {
7272
embeddedEdits.push(edit);
7373
}

‎extensions/html-language-features/server/src/modes/htmlFolding.ts‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -6,21 +6,21 @@
66
import { TextDocument, FoldingRange, Position, Range, LanguageModes, LanguageMode } from './languageModes';
77
import { CancellationToken } from 'vscode-languageserver';
88

9-
export function getFoldingRanges(languageModes: LanguageModes, document: TextDocument, maxRanges: number | undefined, _cancellationToken: CancellationToken | null): FoldingRange[] {
9+
export async function getFoldingRanges(languageModes: LanguageModes, document: TextDocument, maxRanges: number | undefined, _cancellationToken: CancellationToken | null): Promise<FoldingRange[]> {
1010
let htmlMode = languageModes.getMode('html');
1111
let range = Range.create(Position.create(0, 0), Position.create(document.lineCount, 0));
1212
let result: FoldingRange[] = [];
1313
if (htmlMode && htmlMode.getFoldingRanges) {
14-
result.push(...htmlMode.getFoldingRanges(document));
14+
result.push(... await htmlMode.getFoldingRanges(document));
1515
}
1616

1717
// cache folding ranges per mode
1818
let rangesPerMode: { [mode: string]: FoldingRange[] } = Object.create(null);
19-
let getRangesForMode = (mode: LanguageMode) => {
19+
let getRangesForMode = async (mode: LanguageMode) => {
2020
if (mode.getFoldingRanges) {
2121
let ranges = rangesPerMode[mode.getId()];
2222
if (!Array.isArray(ranges)) {
23-
ranges = mode.getFoldingRanges(document) || [];
23+
ranges = await mode.getFoldingRanges(document) || [];
2424
rangesPerMode[mode.getId()] = ranges;
2525
}
2626
return ranges;
@@ -32,7 +32,7 @@ export function getFoldingRanges(languageModes: LanguageModes, document: TextDoc
3232
for (let modeRange of modeRanges) {
3333
let mode = modeRange.mode;
3434
if (mode && mode !== htmlMode && !modeRange.attributeValue) {
35-
const ranges = getRangesForMode(mode);
35+
const ranges = await getRangesForMode(mode);
3636
result.push(...ranges.filter(r => r.startLine >= modeRange.start.line && r.endLine < modeRange.end.line));
3737
}
3838
}

0 commit comments

Comments
 (0)