ckaczor/azuredatastudio
1
0
Fork 0
mirror of https://github.com/ckaczor/azuredatastudio.git synced 2026-03-22 04:40:30 -04:00
Code Issues Packages Projects Releases Wiki Activity

Merge VS Code 1.31.1 (#4283)

Browse Source
This commit is contained in:
Matt Irvine
2019-03-15 13:09:45 -07:00
committed by GitHub
parent 7d31575149
commit 86bac90001
1716 changed files with 53308 additions and 48375 deletions
Download Patch File Download Diff File Expand all files Collapse all files

108
src/vs/editor/contrib/suggest/suggestMemory.ts
View File

@@ -3,25 +3,28 @@
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { ICompletionItem } from 'vs/editor/contrib/suggest/completionModel';
import { LRUCache, TernarySearchTree } from 'vs/base/common/map';
import { IStorageService, StorageScope } from 'vs/platform/storage/common/storage';
import { ITextModel } from 'vs/editor/common/model';
import { IPosition } from 'vs/editor/common/core/position';
import { CompletionItemKind, completionKindFromLegacyString } from 'vs/editor/common/modes';
import { ICodeEditor } from 'vs/editor/browser/editorBrowser';
import { Disposable } from 'vs/base/common/lifecycle';
import { RunOnceScheduler } from 'vs/base/common/async';
import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
import { CompletionItem } from 'vs/editor/contrib/suggest/suggest';
export abstract class Memory {
select(model: ITextModel, pos: IPosition, items: ICompletionItem[]): number {
select(model: ITextModel, pos: IPosition, items: CompletionItem[]): number {
if (items.length === 0) {
return 0;
}
let topScore = items[0].score;
for (let i = 1; i < items.length; i++) {
const { score, suggestion } = items[i];
const { score, completion: suggestion } = items[i];
if (score !== topScore) {
// stop when leaving the group of top matches
break;
@@ -34,16 +37,16 @@ export abstract class Memory {
return 0;
}
abstract memorize(model: ITextModel, pos: IPosition, item: ICompletionItem): void;
abstract memorize(model: ITextModel, pos: IPosition, item: CompletionItem): void;
abstract toJSON(): object;
abstract toJSON(): object | undefined;
abstract fromJSON(data: object): void;
}
export class NoMemory extends Memory {
memorize(model: ITextModel, pos: IPosition, item: ICompletionItem): void {
memorize(model: ITextModel, pos: IPosition, item: CompletionItem): void {
// no-op
}
@@ -64,20 +67,20 @@ export interface MemItem {
export class LRUMemory extends Memory {
private _cache = new LRUCache<string, MemItem>(300, .66);
private _cache = new LRUCache<string, MemItem>(300, 0.66);
private _seq = 0;
memorize(model: ITextModel, pos: IPosition, item: ICompletionItem): void {
const { label } = item.suggestion;
memorize(model: ITextModel, pos: IPosition, item: CompletionItem): void {
const { label } = item.completion;
const key = `${model.getLanguageIdentifier().language}/${label}`;
this._cache.set(key, {
touch: this._seq++,
type: item.suggestion.kind,
insertText: item.suggestion.insertText
type: item.completion.kind,
insertText: item.completion.insertText
});
}
select(model: ITextModel, pos: IPosition, items: ICompletionItem[]): number {
select(model: ITextModel, pos: IPosition, items: CompletionItem[]): number {
// in order of completions, select the first
// that has been used in the past
let { word } = model.getWordUntilPosition(pos);
@@ -93,7 +96,7 @@ export class LRUMemory extends Memory {
let res = -1;
let seq = -1;
for (let i = 0; i < items.length; i++) {
const { suggestion } = items[i];
const { completion: suggestion } = items[i];
const key = `${model.getLanguageIdentifier().language}/${suggestion.label}`;
const item = this._cache.get(key);
if (item && item.touch > seq && item.type === suggestion.kind && item.insertText === suggestion.insertText) {
@@ -134,17 +137,17 @@ export class PrefixMemory extends Memory {
private _trie = TernarySearchTree.forStrings<MemItem>();
private _seq = 0;
memorize(model: ITextModel, pos: IPosition, item: ICompletionItem): void {
memorize(model: ITextModel, pos: IPosition, item: CompletionItem): void {
const { word } = model.getWordUntilPosition(pos);
const key = `${model.getLanguageIdentifier().language}/${word}`;
this._trie.set(key, {
type: item.suggestion.kind,
insertText: item.suggestion.insertText,
type: item.completion.kind,
insertText: item.completion.insertText,
touch: this._seq++
});
}
select(model: ITextModel, pos: IPosition, items: ICompletionItem[]): number {
select(model: ITextModel, pos: IPosition, items: CompletionItem[]): number {
let { word } = model.getWordUntilPosition(pos);
if (!word) {
return super.select(model, pos, items);
@@ -156,7 +159,7 @@ export class PrefixMemory extends Memory {
}
if (item) {
for (let i = 0; i < items.length; i++) {
let { kind, insertText } = items[i].suggestion;
let { kind, insertText } = items[i].completion;
if (kind === item.type && insertText === item.insertText) {
return i;
}
@@ -194,35 +197,60 @@ export class PrefixMemory extends Memory {
export type MemMode = 'first' | 'recentlyUsed' | 'recentlyUsedByPrefix';
export class SuggestMemories extends Disposable {
export class SuggestMemoryService extends Disposable implements ISuggestMemoryService {
readonly _serviceBrand: any;
private readonly _storagePrefix = 'suggest/memories';
private _mode: MemMode;
private _strategy: Memory;
private readonly _persistSoon: RunOnceScheduler;
private _mode: MemMode;
private _shareMem: boolean;
private _strategy: Memory;
constructor(
editor: ICodeEditor,
@IStorageService private readonly _storageService: IStorageService,
@IConfigurationService private readonly _configService: IConfigurationService,
) {
super();
this._persistSoon = this._register(new RunOnceScheduler(() => this._saveState(editor.getConfiguration().contribInfo.suggest.shareSuggestSelections), 3000));
this._setMode(editor.getConfiguration().contribInfo.suggestSelection, editor.getConfiguration().contribInfo.suggest.shareSuggestSelections);
this._register(editor.onDidChangeConfiguration(e => e.contribInfo && this._setMode(editor.getConfiguration().contribInfo.suggestSelection, editor.getConfiguration().contribInfo.suggest.shareSuggestSelections)));
this._register(_storageService.onWillSaveState(() => this._saveState(editor.getConfiguration().contribInfo.suggest.shareSuggestSelections)));
const update = () => {
const mode = this._configService.getValue<MemMode>('editor.suggestSelection');
const share = this._configService.getValue<boolean>('editor.suggest.shareSuggestSelections');
this._update(mode, share, false);
};
this._persistSoon = this._register(new RunOnceScheduler(() => this._saveState(), 500));
this._register(_storageService.onWillSaveState(() => this._saveState()));
this._register(this._configService.onDidChangeConfiguration(e => {
if (e.affectsConfiguration('editor.suggestSelection') || e.affectsConfiguration('editor.suggest.shareSuggestSelections')) {
update();
}
}));
this._register(this._storageService.onDidChangeStorage(e => {
if (e.scope === StorageScope.GLOBAL && e.key.indexOf(this._storagePrefix) === 0) {
if (!document.hasFocus()) {
// windows that aren't focused have to drop their current
// storage value and accept what's stored now
this._update(this._mode, this._shareMem, true);
}
}
}));
update();
}
private _setMode(mode: MemMode, useGlobalStorageForSuggestions: boolean): void {
if (this._mode === mode) {
private _update(mode: MemMode, shareMem: boolean, force: boolean): void {
if (!force && this._mode === mode && this._shareMem === shareMem) {
return;
}
this._shareMem = shareMem;
this._mode = mode;
this._strategy = mode === 'recentlyUsedByPrefix' ? new PrefixMemory() : mode === 'recentlyUsed' ? new LRUMemory() : new NoMemory();
try {
const raw = useGlobalStorageForSuggestions ? this._storageService.get(`${this._storagePrefix}/${this._mode}`, StorageScope.GLOBAL) : this._storageService.get(`${this._storagePrefix}/${this._mode}`, StorageScope.WORKSPACE);
const scope = shareMem ? StorageScope.GLOBAL : StorageScope.WORKSPACE;
const raw = this._storageService.get(`${this._storagePrefix}/${this._mode}`, scope);
if (raw) {
this._strategy.fromJSON(JSON.parse(raw));
}
@@ -231,17 +259,29 @@ export class SuggestMemories extends Disposable {
}
}
memorize(model: ITextModel, pos: IPosition, item: ICompletionItem): void {
memorize(model: ITextModel, pos: IPosition, item: CompletionItem): void {
this._strategy.memorize(model, pos, item);
this._persistSoon.schedule();
}
select(model: ITextModel, pos: IPosition, items: ICompletionItem[]): number {
select(model: ITextModel, pos: IPosition, items: CompletionItem[]): number {
return this._strategy.select(model, pos, items);
}
private _saveState(useGlobalStorageForSuggestions: boolean) {
private _saveState() {
const raw = JSON.stringify(this._strategy);
this._storageService.store(`${this._storagePrefix}/${this._mode}`, raw, useGlobalStorageForSuggestions ? StorageScope.GLOBAL : StorageScope.WORKSPACE);
const scope = this._shareMem ? StorageScope.GLOBAL : StorageScope.WORKSPACE;
this._storageService.store(`${this._storagePrefix}/${this._mode}`, raw, scope);
}
}
export const ISuggestMemoryService = createDecorator<ISuggestMemoryService>('ISuggestMemories');
export interface ISuggestMemoryService {
_serviceBrand: any;
memorize(model: ITextModel, pos: IPosition, item: CompletionItem): void;
select(model: ITextModel, pos: IPosition, items: CompletionItem[]): number;
}
registerSingleton(ISuggestMemoryService, SuggestMemoryService, true);