maxmustermann/vscode
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

debt - provideCompletionItems should not return an array

Browse source
This commit is contained in:
Johannes Rieken 2016-08-05 14:00:16 +02:00
parent 263cb2c3e6
commit 9312aa5fe7
16 changed files with 43 additions and 57 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
src/vs/editor/browser/standalone/standaloneLanguages.ts
View file

@ -197,7 +197,7 @@ export function registerCompletionItemProvider(languageId:string, provider:Compl
let adapter = new SuggestAdapter(provider);
return modes.SuggestRegistry.register(languageId, {
triggerCharacters: provider.triggerCharacters,
provideCompletionItems: (model:editorCommon.IReadOnlyModel, position:Position, token:CancellationToken): Thenable<modes.ISuggestResult[]> => {
provideCompletionItems: (model:editorCommon.IReadOnlyModel, position:Position, token:CancellationToken): Thenable<modes.ISuggestResult> => {
return adapter.provideCompletionItems(model, position, token);
},
resolveCompletionItem: (model:editorCommon.IReadOnlyModel, position:Position, suggestion: modes.ISuggestion, token: CancellationToken): Thenable<modes.ISuggestion> => {
@ -394,7 +394,7 @@ class SuggestAdapter {
};
}
provideCompletionItems(model:editorCommon.IReadOnlyModel, position:Position, token:CancellationToken): Thenable<modes.ISuggestResult[]> {
provideCompletionItems(model:editorCommon.IReadOnlyModel, position:Position, token:CancellationToken): Thenable<modes.ISuggestResult> {
return toThenable<CompletionItem[]|CompletionList>(this._provider.provideCompletionItems(model, position, token)).then(value => {
const result: modes.ISuggestResult = {
@ -457,7 +457,7 @@ class SuggestAdapter {
result.suggestions.push(suggestion);
}
return [result];
return result;
});
}

2
src/vs/editor/common/modes.ts
View file

@ -399,7 +399,7 @@ export interface ISuggestSupport {
filter?: IFilter;
provideCompletionItems(model:editorCommon.IReadOnlyModel, position:Position, token:CancellationToken): ISuggestResult[] | Thenable<ISuggestResult[]>;
provideCompletionItems(model:editorCommon.IReadOnlyModel, position:Position, token:CancellationToken): ISuggestResult | Thenable<ISuggestResult>;
resolveCompletionItem?(model:editorCommon.IReadOnlyModel, position:Position, item: ISuggestion, token: CancellationToken): ISuggestion | Thenable<ISuggestion>;
}

16
src/vs/editor/common/modes/supports/suggestSupport.ts
View file

@ -31,28 +31,22 @@ export class TextualSuggestSupport implements ISuggestSupport {
this._configurationService = configurationService;
}
public provideCompletionItems(model:IReadOnlyModel, position:Position, token:CancellationToken): ISuggestResult[] | Thenable<ISuggestResult[]> {
public provideCompletionItems(model:IReadOnlyModel, position:Position, token:CancellationToken): Thenable<ISuggestResult> {
let config = this._configurationService.getConfiguration<{ wordBasedSuggestions: boolean }>('editor');
if (!config || config.wordBasedSuggestions) {
return wireCancellationToken(token, this._editorWorkerService.textualSuggest(model.uri, position));
}
return <ISuggestResult[]>[];
}
}
export function filterSuggestions(value: ISuggestResult): ISuggestResult[] {
export function filterSuggestions(value: ISuggestResult): ISuggestResult {
if (!value) {
return;
}
// filter suggestions
var accept = fuzzyContiguousFilter,
result: ISuggestResult[] = [];
result.push({
return {
currentWord: value.currentWord,
suggestions: value.suggestions.filter((element) => !!accept(value.currentWord, element.label)),
suggestions: value.suggestions.filter((element) => !!fuzzyContiguousFilter(value.currentWord, element.label)),
incomplete: value.incomplete
});
return result;
};
}

8
src/vs/editor/common/services/editorSimpleWorker.ts
View file

@ -234,7 +234,7 @@ export abstract class BaseEditorSimpleWorker {
// ---- BEGIN suggest --------------------------------------------------------------------------
public textualSuggest(modelUrl:string, position: editorCommon.IPosition, wordDef:string, wordDefFlags:string): TPromise<ISuggestResult[]> {
public textualSuggest(modelUrl:string, position: editorCommon.IPosition, wordDef:string, wordDefFlags:string): TPromise<ISuggestResult> {
let model = this._getModel(modelUrl);
if (!model) {
return null;
@ -243,15 +243,15 @@ export abstract class BaseEditorSimpleWorker {
return TPromise.as(this._suggestFiltered(model, position, new RegExp(wordDef, wordDefFlags)));
}
private _suggestFiltered(model:ICommonModel, position: editorCommon.IPosition, wordDefRegExp: RegExp): ISuggestResult[] {
private _suggestFiltered(model:ICommonModel, position: editorCommon.IPosition, wordDefRegExp: RegExp): ISuggestResult {
let value = this._suggestUnfiltered(model, position, wordDefRegExp);
// filter suggestions
return [{
return {
currentWord: value.currentWord,
suggestions: value.suggestions.filter((element) => !!fuzzyContiguousFilter(value.currentWord, element.label)),
incomplete: value.incomplete
}];
};
}
private _suggestUnfiltered(model:ICommonModel, position:editorCommon.IPosition, wordDefRegExp: RegExp): ISuggestResult {

2
src/vs/editor/common/services/editorWorkerService.ts
View file

@ -18,6 +18,6 @@ export interface IEditorWorkerService {
computeDiff(original:URI, modified:URI, ignoreTrimWhitespace:boolean):TPromise<ILineChange[]>;
computeDirtyDiff(original:URI, modified:URI, ignoreTrimWhitespace:boolean):TPromise<IChange[]>;
textualSuggest(resource: URI, position: IPosition): TPromise<ISuggestResult[]>;
textualSuggest(resource: URI, position: IPosition): TPromise<ISuggestResult>;
navigateValueSet(resource: URI, range:IRange, up:boolean): TPromise<IInplaceReplaceSupportResult>;
}

4
src/vs/editor/common/services/editorWorkerServiceImpl.ts
View file

@ -58,7 +58,7 @@ export class EditorWorkerServiceImpl implements IEditorWorkerService {
return this._workerManager.withWorker().then(client => client.computeDirtyDiff(original, modified, ignoreTrimWhitespace));
}
public textualSuggest(resource: URI, position: editorCommon.IPosition): TPromise<ISuggestResult[]> {
public textualSuggest(resource: URI, position: editorCommon.IPosition): TPromise<ISuggestResult> {
return this._workerManager.withWorker().then(client => client.textualSuggest(resource, position));
}
@ -316,7 +316,7 @@ export class EditorWorkerClient extends Disposable {
});
}
public textualSuggest(resource: URI, position: editorCommon.IPosition): TPromise<ISuggestResult[]> {
public textualSuggest(resource: URI, position: editorCommon.IPosition): TPromise<ISuggestResult> {
return this._withSyncedResources([resource]).then(proxy => {
let model = this._modelService.getModel(resource);
if (!model) {

32
src/vs/editor/contrib/suggest/common/suggest.ts
View file

@ -44,11 +44,11 @@ const snippetSuggestSupport: ISuggestSupport = {
triggerCharacters: [],
provideCompletionItems(model: IReadOnlyModel, position: Position): ISuggestResult[] {
provideCompletionItems(model: IReadOnlyModel, position: Position): ISuggestResult {
// currentWord is irrelevant, all suggestion use overwriteBefore
const result: ISuggestResult = { suggestions: [], currentWord: '' };
Registry.as<ISnippetsRegistry>(Extensions.Snippets).getSnippetCompletions(model, position, result.suggestions);
return [result];
return result;
}
};
@ -71,28 +71,22 @@ export function provideSuggestionItems(model: IReadOnlyModel, position: Position
return;
}
// for each support in the group ask for suggestions
return TPromise.join(supports.map(support => asWinJsPromise(token => support.provideCompletionItems(model, position, token)).then(values => {
if (isFalsyOrEmpty(values)) {
return;
}
return TPromise.join(supports.map(support => asWinJsPromise(token => support.provideCompletionItems(model, position, token)).then(container => {
const len = result.length;
for (let container of values) {
if (container && !isFalsyOrEmpty(container.suggestions)) {
for (let suggestion of container.suggestions) {
if (acceptSuggestion(suggestion)) {
if (container && !isFalsyOrEmpty(container.suggestions)) {
for (let suggestion of container.suggestions) {
if (acceptSuggestion(suggestion)) {
fixOverwriteBeforeAfter(suggestion, container);
fixOverwriteBeforeAfter(suggestion, container);
result.push({
container,
suggestion,
support,
resolve: createSuggestionResolver(support, suggestion, model, position)
});
}
result.push({
container,
suggestion,
support,
resolve: createSuggestionResolver(support, suggestion, model, position)
});
}
}
}

4
src/vs/editor/contrib/suggest/test/common/suggest.test.ts
View file

@ -24,7 +24,7 @@ suite('Suggest', function () {
registration = SuggestRegistry.register({ pattern: 'bar/path' }, {
triggerCharacters: [],
provideCompletionItems() {
return [{
return {
currentWord: '',
incomplete: false,
suggestions: [{
@ -40,7 +40,7 @@ suite('Suggest', function () {
type: 'property',
codeSnippet: 'fff'
}]
}];
};
}
});
});

2
src/vs/languages/handlebars/common/handlebars.ts
View file

@ -164,7 +164,7 @@ export class HandlebarsMode extends htmlMode.HTMLMode<htmlWorker.HTMLWorker> {
protected _registerSupports(): void {
modes.SuggestRegistry.register(this.getId(), {
triggerCharacters: ['.', ':', '<', '"', '=', '/'],
provideCompletionItems: (model, position, token): Thenable<modes.ISuggestResult[]> => {
provideCompletionItems: (model, position, token): Thenable<modes.ISuggestResult> => {
return wireCancellationToken(token, this._provideCompletionItems(model.uri, position));
}
}, true);

4
src/vs/languages/html/common/html.ts
View file

@ -358,7 +358,7 @@ export class HTMLMode<W extends htmlWorker.HTMLWorker> extends CompatMode implem
modes.SuggestRegistry.register(this.getId(), {
triggerCharacters: ['.', ':', '<', '"', '=', '/'],
provideCompletionItems: (model, position, token): Thenable<modes.ISuggestResult[]> => {
provideCompletionItems: (model, position, token): Thenable<modes.ISuggestResult> => {
return wireCancellationToken(token, this._provideCompletionItems(model.uri, position));
}
}, true);
@ -486,7 +486,7 @@ export class HTMLMode<W extends htmlWorker.HTMLWorker> extends CompatMode implem
}
static $_provideCompletionItems = CompatWorkerAttr(HTMLMode, HTMLMode.prototype._provideCompletionItems);
protected _provideCompletionItems(resource:URI, position:editorCommon.IPosition):winjs.TPromise<modes.ISuggestResult[]> {
protected _provideCompletionItems(resource:URI, position:editorCommon.IPosition):winjs.TPromise<modes.ISuggestResult> {
return this._worker((w) => w.provideCompletionItems(resource, position));
}

6
src/vs/languages/html/common/htmlWorker.ts
View file

@ -267,17 +267,15 @@ export class HTMLWorker {
});
}
public provideCompletionItems(resource:URI, position:editorCommon.IPosition):winjs.TPromise<modes.ISuggestResult[]> {
public provideCompletionItems(resource:URI, position:editorCommon.IPosition):winjs.TPromise<modes.ISuggestResult> {
let model = this.resourceService.get(resource);
let modeIdAtPosition = model.getModeIdAtPosition(position.lineNumber, position.column);
if (modeIdAtPosition === this._modeId) {
return this.suggestHTML(resource, position);
} else {
return winjs.TPromise.as([]);
}
}
private suggestHTML(resource:URI, position:editorCommon.IPosition):winjs.TPromise<modes.ISuggestResult[]> {
private suggestHTML(resource:URI, position:editorCommon.IPosition):winjs.TPromise<modes.ISuggestResult> {
return this.doSuggest(resource, position).then(value => filterSuggestions(value));
}

2
src/vs/languages/html/test/common/html-worker.test.ts
View file

@ -48,7 +48,7 @@ suite('HTML - worker', () => {
var env = mockHtmlWorkerEnv(url, content);
var position = env.model.getPositionFromOffset(idx);
return env.worker.provideCompletionItems(url, position).then(result => result[0]);
return env.worker.provideCompletionItems(url, position);
};
var assertSuggestion = function(completion: Modes.ISuggestResult, label: string, type?: string, codeSnippet?: string) {

2
src/vs/languages/razor/common/razor.ts
View file

@ -112,7 +112,7 @@ export class RAZORMode extends htmlMode.HTMLMode<RAZORWorker> {
protected _registerSupports(): void {
modes.SuggestRegistry.register(this.getId(), {
triggerCharacters: ['.', ':', '<', '"', '=', '/'],
provideCompletionItems: (model, position, token): Thenable<modes.ISuggestResult[]> => {
provideCompletionItems: (model, position, token): Thenable<modes.ISuggestResult> => {
return wireCancellationToken(token, this._provideCompletionItems(model.uri, position));
}
}, true);

2
src/vs/workbench/api/node/extHost.protocol.ts
View file

@ -266,7 +266,7 @@ export abstract class ExtHostLanguageFeaturesShape {
$provideWorkspaceSymbols(handle: number, search: string): TPromise<IWorkspaceSymbol[]> { throw ni(); }
$resolveWorkspaceSymbol(handle: number, symbol: IWorkspaceSymbol): TPromise<IWorkspaceSymbol> { throw ni(); }
$provideRenameEdits(handle: number, resource: URI, position: editorCommon.IPosition, newName: string): TPromise<modes.WorkspaceEdit> { throw ni(); }
$provideCompletionItems(handle: number, resource: URI, position: editorCommon.IPosition): TPromise<modes.ISuggestResult[]> { throw ni(); }
$provideCompletionItems(handle: number, resource: URI, position: editorCommon.IPosition): TPromise<modes.ISuggestResult> { throw ni(); }
$resolveCompletionItem(handle: number, resource: URI, position: editorCommon.IPosition, suggestion: modes.ISuggestion): TPromise<modes.ISuggestion> { throw ni(); }
$provideSignatureHelp(handle: number, resource: URI, position: editorCommon.IPosition): TPromise<modes.SignatureHelp> { throw ni(); }
$provideDocumentLinks(handle: number, resource: URI): TPromise<modes.ILink[]> { throw ni(); }

6
src/vs/workbench/api/node/extHostLanguageFeatures.ts
View file

@ -503,7 +503,7 @@ class SuggestAdapter {
this._provider = provider;
}
provideCompletionItems(resource: URI, position: IPosition): TPromise<modes.ISuggestResult[]> {
provideCompletionItems(resource: URI, position: IPosition): TPromise<modes.ISuggestResult> {
const doc = this._documents.getDocumentData(resource).document;
const pos = TypeConverters.toPosition(position);
@ -574,7 +574,7 @@ class SuggestAdapter {
// cache for details call
this._cache[key] = list;
return [result];
return result;
});
}
@ -866,7 +866,7 @@ export class ExtHostLanguageFeatures extends ExtHostLanguageFeaturesShape {
return this._createDisposable(handle);
}
$provideCompletionItems(handle: number, resource: URI, position: IPosition): TPromise<modes.ISuggestResult[]> {
$provideCompletionItems(handle: number, resource: URI, position: IPosition): TPromise<modes.ISuggestResult> {
return this._withAdapter(handle, SuggestAdapter, adapter => adapter.provideCompletionItems(resource, position));
}

2
src/vs/workbench/api/node/mainThreadLanguageFeatures.ts
View file

@ -179,7 +179,7 @@ export class MainThreadLanguageFeatures extends MainThreadLanguageFeaturesShape
$registerSuggestSupport(handle: number, selector: vscode.DocumentSelector, triggerCharacters: string[]): TPromise<any> {
this._registrations[handle] = modes.SuggestRegistry.register(selector, <modes.ISuggestSupport>{
triggerCharacters: triggerCharacters,
provideCompletionItems: (model:IReadOnlyModel, position:EditorPosition, token:CancellationToken): Thenable<modes.ISuggestResult[]> => {
provideCompletionItems: (model:IReadOnlyModel, position:EditorPosition, token:CancellationToken): Thenable<modes.ISuggestResult> => {
return wireCancellationToken(token, this._proxy.$provideCompletionItems(handle, model.uri, position));
},
resolveCompletionItem: (model:IReadOnlyModel, position:EditorPosition, suggestion: modes.ISuggestion, token: CancellationToken): Thenable<modes.ISuggestion> => {