SystemSh0cker/monaco-editor
1
0
Fork 0
mirror of https://github.com/microsoft/monaco-editor.git synced 2025-12-22 11:35:40 +01:00
Code Issues Projects Releases Packages Activity

Stop using Thenable

Browse source
This commit is contained in:
Alex Dima 2020-09-07 14:44:01 +02:00
parent cbf1d6a12b
commit ff1c7a5a5c
No known key found for this signature in database
GPG key ID: 6E58D7B045760DA0
2 changed files with 24 additions and 26 deletions
Download patch file Download diff file Expand all files Collapse all files

27
src/cssWorker.ts
View file

@ -4,7 +4,6 @@
*--------------------------------------------------------------------------------------------*/
'use strict';
import Thenable = monaco.Thenable;
import IWorkerContext = monaco.worker.IWorkerContext;
import * as cssService from 'vscode-css-languageservice';
@ -40,7 +39,7 @@ export class CSSWorker {
// --- language service host ---------------
doValidation(uri: string): Thenable<cssService.Diagnostic[]> {
async doValidation(uri: string): Promise<cssService.Diagnostic[]> {
let document = this._getTextDocument(uri);
if (document) {
let stylesheet = this._languageService.parseStylesheet(document);
@ -49,72 +48,72 @@ export class CSSWorker {
}
return Promise.resolve([]);
}
doComplete(uri: string, position: cssService.Position): Thenable<cssService.CompletionList> {
async doComplete(uri: string, position: cssService.Position): Promise<cssService.CompletionList> {
let document = this._getTextDocument(uri);
let stylesheet = this._languageService.parseStylesheet(document);
let completions = this._languageService.doComplete(document, position, stylesheet);
return Promise.resolve(completions);
}
doHover(uri: string, position: cssService.Position): Thenable<cssService.Hover> {
async doHover(uri: string, position: cssService.Position): Promise<cssService.Hover> {
let document = this._getTextDocument(uri);
let stylesheet = this._languageService.parseStylesheet(document);
let hover = this._languageService.doHover(document, position, stylesheet);
return Promise.resolve(hover);
}
findDefinition(uri: string, position: cssService.Position): Thenable<cssService.Location> {
async findDefinition(uri: string, position: cssService.Position): Promise<cssService.Location> {
let document = this._getTextDocument(uri);
let stylesheet = this._languageService.parseStylesheet(document);
let definition = this._languageService.findDefinition(document, position, stylesheet);
return Promise.resolve(definition);
}
findReferences(uri: string, position: cssService.Position): Thenable<cssService.Location[]> {
async findReferences(uri: string, position: cssService.Position): Promise<cssService.Location[]> {
let document = this._getTextDocument(uri);
let stylesheet = this._languageService.parseStylesheet(document);
let references = this._languageService.findReferences(document, position, stylesheet);
return Promise.resolve(references);
}
findDocumentHighlights(uri: string, position: cssService.Position): Thenable<cssService.DocumentHighlight[]> {
async findDocumentHighlights(uri: string, position: cssService.Position): Promise<cssService.DocumentHighlight[]> {
let document = this._getTextDocument(uri);
let stylesheet = this._languageService.parseStylesheet(document);
let highlights = this._languageService.findDocumentHighlights(document, position, stylesheet);
return Promise.resolve(highlights);
}
findDocumentSymbols(uri: string): Thenable<cssService.SymbolInformation[]> {
async findDocumentSymbols(uri: string): Promise<cssService.SymbolInformation[]> {
let document = this._getTextDocument(uri);
let stylesheet = this._languageService.parseStylesheet(document);
let symbols = this._languageService.findDocumentSymbols(document, stylesheet);
return Promise.resolve(symbols);
}
doCodeActions(uri: string, range: cssService.Range, context: cssService.CodeActionContext): Thenable<cssService.Command[]> {
async doCodeActions(uri: string, range: cssService.Range, context: cssService.CodeActionContext): Promise<cssService.Command[]> {
let document = this._getTextDocument(uri);
let stylesheet = this._languageService.parseStylesheet(document);
let actions = this._languageService.doCodeActions(document, range, context, stylesheet);
return Promise.resolve(actions);
}
findDocumentColors(uri: string): Thenable<cssService.ColorInformation[]> {
async findDocumentColors(uri: string): Promise<cssService.ColorInformation[]> {
let document = this._getTextDocument(uri);
let stylesheet = this._languageService.parseStylesheet(document);
let colorSymbols = this._languageService.findDocumentColors(document, stylesheet);
return Promise.resolve(colorSymbols);
}
getColorPresentations(uri: string, color: cssService.Color, range: cssService.Range): Thenable<cssService.ColorPresentation[]> {
async getColorPresentations(uri: string, color: cssService.Color, range: cssService.Range): Promise<cssService.ColorPresentation[]> {
let document = this._getTextDocument(uri);
let stylesheet = this._languageService.parseStylesheet(document);
let colorPresentations = this._languageService.getColorPresentations(document, stylesheet, color, range);
return Promise.resolve(colorPresentations);
}
getFoldingRanges(uri: string, context?: { rangeLimit?: number; }): Thenable<cssService.FoldingRange[]> {
async getFoldingRanges(uri: string, context?: { rangeLimit?: number; }): Promise<cssService.FoldingRange[]> {
let document = this._getTextDocument(uri);
let ranges = this._languageService.getFoldingRanges(document, context);
return Promise.resolve(ranges);
}
getSelectionRanges(uri: string, positions: cssService.Position[]): Thenable<cssService.SelectionRange[]> {
async getSelectionRanges(uri: string, positions: cssService.Position[]): Promise<cssService.SelectionRange[]> {
let document = this._getTextDocument(uri);
let stylesheet = this._languageService.parseStylesheet(document);
let ranges = this._languageService.getSelectionRanges(document, positions, stylesheet);
return Promise.resolve(ranges);
}
doRename(uri: string, position: cssService.Position, newName: string): Thenable<cssService.WorkspaceEdit> {
async doRename(uri: string, position: cssService.Position, newName: string): Promise<cssService.WorkspaceEdit> {
let document = this._getTextDocument(uri);
let stylesheet = this._languageService.parseStylesheet(document);
let renames = this._languageService.doRename(document, position, newName, stylesheet);

23
src/languageFeatures.ts
View file

@ -13,7 +13,6 @@ import Uri = monaco.Uri;
import Position = monaco.Position;
import IRange = monaco.IRange;
import Range = monaco.Range;
import Thenable = monaco.Thenable;
import CancellationToken = monaco.CancellationToken;
import IDisposable = monaco.IDisposable;
@ -198,7 +197,7 @@ export class CompletionAdapter implements monaco.languages.CompletionItemProvide
return [' ', ':'];
}
provideCompletionItems(model: monaco.editor.IReadOnlyModel, position: Position, context: monaco.languages.CompletionContext, token: CancellationToken): Thenable<monaco.languages.CompletionList> {
provideCompletionItems(model: monaco.editor.IReadOnlyModel, position: Position, context: monaco.languages.CompletionContext, token: CancellationToken): Promise<monaco.languages.CompletionList> {
const resource = model.uri;
return this._worker(resource).then(worker => {
@ -285,7 +284,7 @@ export class HoverAdapter implements monaco.languages.HoverProvider {
constructor(private _worker: WorkerAccessor) {
}
provideHover(model: monaco.editor.IReadOnlyModel, position: Position, token: CancellationToken): Thenable<monaco.languages.Hover> {
provideHover(model: monaco.editor.IReadOnlyModel, position: Position, token: CancellationToken): Promise<monaco.languages.Hover> {
let resource = model.uri;
return this._worker(resource).then(worker => {
@ -319,7 +318,7 @@ export class DocumentHighlightAdapter implements monaco.languages.DocumentHighli
constructor(private _worker: WorkerAccessor) {
}
public provideDocumentHighlights(model: monaco.editor.IReadOnlyModel, position: Position, token: CancellationToken): Thenable<monaco.languages.DocumentHighlight[]> {
public provideDocumentHighlights(model: monaco.editor.IReadOnlyModel, position: Position, token: CancellationToken): Promise<monaco.languages.DocumentHighlight[]> {
const resource = model.uri;
return this._worker(resource).then(worker => {
@ -352,7 +351,7 @@ export class DefinitionAdapter {
constructor(private _worker: WorkerAccessor) {
}
public provideDefinition(model: monaco.editor.IReadOnlyModel, position: Position, token: CancellationToken): Thenable<monaco.languages.Definition> {
public provideDefinition(model: monaco.editor.IReadOnlyModel, position: Position, token: CancellationToken): Promise<monaco.languages.Definition> {
const resource = model.uri;
return this._worker(resource).then(worker => {
@ -373,7 +372,7 @@ export class ReferenceAdapter implements monaco.languages.ReferenceProvider {
constructor(private _worker: WorkerAccessor) {
}
provideReferences(model: monaco.editor.IReadOnlyModel, position: Position, context: monaco.languages.ReferenceContext, token: CancellationToken): Thenable<monaco.languages.Location[]> {
provideReferences(model: monaco.editor.IReadOnlyModel, position: Position, context: monaco.languages.ReferenceContext, token: CancellationToken): Promise<monaco.languages.Location[]> {
const resource = model.uri;
return this._worker(resource).then(worker => {
@ -418,7 +417,7 @@ export class RenameAdapter implements monaco.languages.RenameProvider {
constructor(private _worker: WorkerAccessor) {
}
provideRenameEdits(model: monaco.editor.IReadOnlyModel, position: Position, newName: string, token: CancellationToken): Thenable<monaco.languages.WorkspaceEdit> {
provideRenameEdits(model: monaco.editor.IReadOnlyModel, position: Position, newName: string, token: CancellationToken): Promise<monaco.languages.WorkspaceEdit> {
const resource = model.uri;
return this._worker(resource).then(worker => {
@ -463,7 +462,7 @@ export class DocumentSymbolAdapter implements monaco.languages.DocumentSymbolPro
constructor(private _worker: WorkerAccessor) {
}
public provideDocumentSymbols(model: monaco.editor.IReadOnlyModel, token: CancellationToken): Thenable<monaco.languages.DocumentSymbol[]> {
public provideDocumentSymbols(model: monaco.editor.IReadOnlyModel, token: CancellationToken): Promise<monaco.languages.DocumentSymbol[]> {
const resource = model.uri;
return this._worker(resource).then(worker => worker.findDocumentSymbols(resource.toString())).then(items => {
@ -488,7 +487,7 @@ export class DocumentColorAdapter implements monaco.languages.DocumentColorProvi
constructor(private _worker: WorkerAccessor) {
}
public provideDocumentColors(model: monaco.editor.IReadOnlyModel, token: CancellationToken): Thenable<monaco.languages.IColorInformation[]> {
public provideDocumentColors(model: monaco.editor.IReadOnlyModel, token: CancellationToken): Promise<monaco.languages.IColorInformation[]> {
const resource = model.uri;
return this._worker(resource).then(worker => worker.findDocumentColors(resource.toString())).then(infos => {
@ -502,7 +501,7 @@ export class DocumentColorAdapter implements monaco.languages.DocumentColorProvi
});
}
public provideColorPresentations(model: monaco.editor.IReadOnlyModel, info: monaco.languages.IColorInformation, token: CancellationToken): Thenable<monaco.languages.IColorPresentation[]> {
public provideColorPresentations(model: monaco.editor.IReadOnlyModel, info: monaco.languages.IColorInformation, token: CancellationToken): Promise<monaco.languages.IColorPresentation[]> {
const resource = model.uri;
return this._worker(resource).then(worker => worker.getColorPresentations(resource.toString(), info.color, fromRange(info.range))).then(presentations => {
@ -530,7 +529,7 @@ export class FoldingRangeAdapter implements monaco.languages.FoldingRangeProvide
constructor(private _worker: WorkerAccessor) {
}
public provideFoldingRanges(model: monaco.editor.IReadOnlyModel, context: monaco.languages.FoldingContext, token: CancellationToken): Thenable<monaco.languages.FoldingRange[]> {
public provideFoldingRanges(model: monaco.editor.IReadOnlyModel, context: monaco.languages.FoldingContext, token: CancellationToken): Promise<monaco.languages.FoldingRange[]> {
const resource = model.uri;
return this._worker(resource).then(worker => worker.getFoldingRanges(resource.toString(), context)).then(ranges => {
@ -565,7 +564,7 @@ export class SelectionRangeAdapter implements monaco.languages.SelectionRangePro
constructor(private _worker: WorkerAccessor) {
}
public provideSelectionRanges(model: monaco.editor.IReadOnlyModel, positions: Position[], token: CancellationToken): Thenable<monaco.languages.SelectionRange[][]> {
public provideSelectionRanges(model: monaco.editor.IReadOnlyModel, positions: Position[], token: CancellationToken): Promise<monaco.languages.SelectionRange[][]> {
const resource = model.uri;
return this._worker(resource).then(worker => worker.getSelectionRanges(resource.toString(), positions.map(fromPosition))).then(selectionRanges => {