Vihren Atlas

testThemeService.ts ×18

Code frontier

unlabeled · c_4c585a5a4da3

662 tests · 38899 LOC · 238 files · introduces 0 tests · 401 LOC · 7 files

Introduces — evidence that enters the hierarchy at this concept

Code
65 ranges401 lines · 7 files
Tests
0 tests

Contains — complete concept membership

All code (extent)
4478 ranges38899 lines · 238 files · Browse complete extent
All tests (intent)
662 testsBrowse complete intent

Neighbourhood graph

The orange circle is the focus. Violet and green circles are every ancestor and descendant, broader and narrower, at any distance; blue squares and pink diamonds are the introduced files and exact introduced tests of every visible concept, not only the focus's. Arrows point from broader to narrower concepts and bridge only concepts omitted from this view. Undirected links show source or test introduction. Concept and file size follows LOC; exact test nodes use test-count units.

Introduced files, introduced tests, and structurally relevant concept specialization

In the embedded map, ordinary wheel input scrolls the page; use the visible controls to zoom and drag to pan. Open the full-screen map for canvas navigation: wheel pans, Ctrl/Command plus wheel zooms, and arrow keys pan when this region is focused. On touch screens, open the full-screen map to pan or pinch. If JavaScript or WebGL is unavailable, use the native relationship evidence on this page.

Graph controls are ready.

Interactive rendering requires JavaScript and WebGL. Use the native relationship evidence on this page while the interactive map is unavailable.

Native relationship evidence

Every exact file and test below is linked only from the concept that introduces it.

Introduced tests

Every collected test enters the hierarchy at exactly one concept.

No tests are introduced at this concept. Its intent tests are introduced by other concepts.

Introduced code

Every collected source range enters the hierarchy at exactly one concept.

7 files ranked by introduced lines: 401 introduced LOC across 65 ranges. Expand a file to inspect source; the > gutter marks introduced lines.

src/vs/editor/common/services/languageFeatures.ts 81 introduced LOC · 1 range

Open complete file

1 > /*--------------------------------------------------------------------------------------------- languageFeatures.ts
2 > * Copyright (c) Microsoft Corporation. All rights reserved.
3 > * Licensed under the MIT License. See License.txt in the project root for license information.
4 > *--------------------------------------------------------------------------------------------*/
5 >
6 > import { LanguageFeatureRegistry, NotebookInfoResolver } from '../languageFeatureRegistry.js';
7 > import { CodeActionProvider, CodeLensProvider, CompletionItemProvider, DeclarationProvider, DefinitionProvider, DocumentColorProvider, DocumentFormattingEditProvider, DocumentHighlightProvider, DocumentDropEditProvider, DocumentPasteEditProvider, DocumentRangeFormattingEditProvider, DocumentRangeSemanticTokensProvider, DocumentSemanticTokensProvider, DocumentSymbolProvider, EvaluatableExpressionProvider, FoldingRangeProvider, HoverProvider, ImplementationProvider, InlayHintsProvider, InlineCompletionsProvider, InlineValuesProvider, LinkedEditingRangeProvider, LinkProvider, MultiDocumentHighlightProvider, NewSymbolNamesProvider, OnTypeFormattingEditProvider, ReferenceProvider, RenameProvider, SelectionRangeProvider, SignatureHelpProvider, TypeDefinitionProvider } from '../languages.js';
8 > import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
9 >
10 > export const ILanguageFeaturesService = createDecorator<ILanguageFeaturesService>('ILanguageFeaturesService');
11 >
12 > export interface ILanguageFeaturesService {
13 >
14 > readonly _serviceBrand: undefined;
15 >
16 > readonly referenceProvider: LanguageFeatureRegistry<ReferenceProvider>;
17 >
18 > readonly definitionProvider: LanguageFeatureRegistry<DefinitionProvider>;
19 >
20 > readonly typeDefinitionProvider: LanguageFeatureRegistry<TypeDefinitionProvider>;
21 >
22 > readonly declarationProvider: LanguageFeatureRegistry<DeclarationProvider>;
23 >
24 > readonly implementationProvider: LanguageFeatureRegistry<ImplementationProvider>;
25 >
26 > readonly codeActionProvider: LanguageFeatureRegistry<CodeActionProvider>;
27 >
28 > readonly documentPasteEditProvider: LanguageFeatureRegistry<DocumentPasteEditProvider>;
29 >
30 > readonly renameProvider: LanguageFeatureRegistry<RenameProvider>;
31 >
32 > readonly newSymbolNamesProvider: LanguageFeatureRegistry<NewSymbolNamesProvider>;
33 >
34 > readonly documentFormattingEditProvider: LanguageFeatureRegistry<DocumentFormattingEditProvider>;
35 >
36 > readonly documentRangeFormattingEditProvider: LanguageFeatureRegistry<DocumentRangeFormattingEditProvider>;
37 >
38 > readonly onTypeFormattingEditProvider: LanguageFeatureRegistry<OnTypeFormattingEditProvider>;
39 >
40 > readonly documentSymbolProvider: LanguageFeatureRegistry<DocumentSymbolProvider>;
41 >
42 > readonly inlayHintsProvider: LanguageFeatureRegistry<InlayHintsProvider>;
43 >
44 > readonly colorProvider: LanguageFeatureRegistry<DocumentColorProvider>;
45 >
46 > readonly codeLensProvider: LanguageFeatureRegistry<CodeLensProvider>;
47 >
48 > readonly signatureHelpProvider: LanguageFeatureRegistry<SignatureHelpProvider>;
49 >
50 > readonly hoverProvider: LanguageFeatureRegistry<HoverProvider>;
51 >
52 > readonly documentHighlightProvider: LanguageFeatureRegistry<DocumentHighlightProvider>;
53 >
54 > readonly multiDocumentHighlightProvider: LanguageFeatureRegistry<MultiDocumentHighlightProvider>;
55 >
56 > readonly documentRangeSemanticTokensProvider: LanguageFeatureRegistry<DocumentRangeSemanticTokensProvider>;
57 >
58 > readonly documentSemanticTokensProvider: LanguageFeatureRegistry<DocumentSemanticTokensProvider>;
59 >
60 > readonly selectionRangeProvider: LanguageFeatureRegistry<SelectionRangeProvider>;
61 >
62 > readonly foldingRangeProvider: LanguageFeatureRegistry<FoldingRangeProvider>;
63 >
64 > readonly linkProvider: LanguageFeatureRegistry<LinkProvider>;
65 >
66 > readonly inlineCompletionsProvider: LanguageFeatureRegistry<InlineCompletionsProvider>;
67 >
68 > readonly completionProvider: LanguageFeatureRegistry<CompletionItemProvider>;
69 >
70 > readonly linkedEditingRangeProvider: LanguageFeatureRegistry<LinkedEditingRangeProvider>;
71 >
72 > readonly inlineValuesProvider: LanguageFeatureRegistry<InlineValuesProvider>;
73 >
74 > readonly evaluatableExpressionProvider: LanguageFeatureRegistry<EvaluatableExpressionProvider>;
75 >
76 > readonly documentDropEditProvider: LanguageFeatureRegistry<DocumentDropEditProvider>;
77 >
78 > // --
79 >
80 > setNotebookTypeResolver(resolver: NotebookInfoResolver | undefined): void;
81 > }
src/vs/editor/common/services/languageFeatureDebounce.ts 80 introduced LOC · 14 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- languageFeatureDebounce.ts
2 > * Copyright (c) Microsoft Corporation. All rights reserved.
3 > * Licensed under the MIT License. See License.txt in the project root for license information.
4 > *--------------------------------------------------------------------------------------------*/
5 >
6 > import { doHash } from '../../../base/common/hash.js';
7 > import { LRUCache } from '../../../base/common/map.js';
8 > import { clamp, MovingAverage, SlidingWindowAverage } from '../../../base/common/numbers.js';
9 > import { LanguageFeatureRegistry } from '../languageFeatureRegistry.js';
10 > import { ITextModel } from '../model.js';
11 > import { IEnvironmentService } from '../../../platform/environment/common/environment.js';
12 > import { InstantiationType, registerSingleton } from '../../../platform/instantiation/common/extensions.js';
13 > import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
14 > import { ILogService } from '../../../platform/log/common/log.js';
15 > import { matchesScheme } from '../../../base/common/network.js';
16 >
17 >
18 > export const ILanguageFeatureDebounceService = createDecorator<ILanguageFeatureDebounceService>('ILanguageFeatureDebounceService');
19 >
20 > export interface ILanguageFeatureDebounceService {
21 >
22 > readonly _serviceBrand: undefined;
23 >
24 > for(feature: LanguageFeatureRegistry<object>, debugName: string, config?: { min?: number; max?: number; salt?: string }): IFeatureDebounceInformation;
25 > }
26 >
27 > export interface IFeatureDebounceInformation {
28 > get(model: ITextModel): number;
29 > update(model: ITextModel, value: number): number;
30 > default(): number;
31 > }
32 >
33 > namespace IdentityHash {
34 > const _hashes = new WeakMap<object, number>();
35 > let pool = 0;
36 > export function of(obj: object): number {
37 let value = _hashes.get(obj);
38 if (value === undefined) {
42 return value;
43 }
44 > } languageFeatureDebounce.ts
45 >
46 > class NullDebounceInformation implements IFeatureDebounceInformation {
47 >
48 > constructor(private readonly _default: number) { }
49 >
50 > get(_model: ITextModel): number {
51 return this._default;
52 }
53 > update(_model: ITextModel, _value: number): number { languageFeatureDebounce.ts
54 return this._default;
55 }
56 > default(): number { languageFeatureDebounce.ts
57 return this._default;
58 }
59 > } languageFeatureDebounce.ts
60 >
61 > class FeatureDebounceInformation implements IFeatureDebounceInformation {
62 >
63 > private readonly _cache = new LRUCache<string, SlidingWindowAverage>(50, 0.7);
64 >
65 > constructor(
66 private readonly _logService: ILogService,
67 private readonly _name: string,
71 private readonly _max: number,
72 ) { }
73 > languageFeatureDebounce.ts
74 > private _key(model: ITextModel): string {
75 return model.id + this._registry.all(model).reduce((hashVal, obj) => doHash(IdentityHash.of(obj), hashVal), 0);
76 }
77 > languageFeatureDebounce.ts
78 > get(model: ITextModel): number {
79 const key = this._key(model);
80 const avg = this._cache.get(key);
83 : this.default();
84 }
85 > languageFeatureDebounce.ts
86 > update(model: ITextModel, value: number): number {
87 const key = this._key(model);
88 let avg = this._cache.get(key);
97 return newValue;
98 }
99 > languageFeatureDebounce.ts
100 > private _overall(): number {
101 const result = new MovingAverage();
102 for (const [, avg] of this._cache) {
105 return result.value;
106 }
107 > languageFeatureDebounce.ts
108 > default() {
109 const value = (this._overall() | 0) || this._default;
110 return clamp(value, this._min, this._max);
111 }
112 > } languageFeatureDebounce.ts
113 >
114 >
115 > export class LanguageFeatureDebounceService implements ILanguageFeatureDebounceService {
116 >
117 > declare _serviceBrand: undefined;
118 >
119 > private readonly _data = new Map<string, IFeatureDebounceInformation>();
120 > private readonly _isDev: boolean;
121 >
122 > constructor(
123 @ILogService private readonly _logService: ILogService,
124 @IEnvironmentService envService: IEnvironmentService,
127 this._isDev = envService.isExtensionDevelopment || !envService.isBuilt;
128 }
129 > languageFeatureDebounce.ts
130 > for(feature: LanguageFeatureRegistry<object>, name: string, config?: { min?: number; max?: number; key?: string }): IFeatureDebounceInformation {
131 const min = config?.min ?? 50;
132 const max = config?.max ?? min ** 2;
152 return info;
153 }
154 > languageFeatureDebounce.ts
155 > private _overallAverage(): number {
156 // Average of all language features. Not a great value but an approximation
157 const result = new MovingAverage();
161 return result.value;
162 }
163 > } languageFeatureDebounce.ts
164 >
165 > registerSingleton(ILanguageFeatureDebounceService, LanguageFeatureDebounceService, InstantiationType.Delayed);
src/vs/editor/common/languageFeatureRegistry.ts 67 introduced LOC · 14 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- languageFeatureRegistry.ts
2 > * Copyright (c) Microsoft Corporation. All rights reserved.
3 > * Licensed under the MIT License. See License.txt in the project root for license information.
4 > *--------------------------------------------------------------------------------------------*/
5 >
6 > import { Emitter } from '../../base/common/event.js';
7 > import { IDisposable, toDisposable } from '../../base/common/lifecycle.js';
8 > import { ITextModel, shouldSynchronizeModel } from './model.js';
9 > import { LanguageFilter, LanguageSelector, score, selectLanguageIds } from './languageSelector.js';
10 > import { URI } from '../../base/common/uri.js';
11 >
12 > interface Entry<T> {
13 > readonly selector: LanguageSelector;
14 > readonly provider: T;
15 > _score: number;
16 > readonly _time: number;
17 > }
18 >
19 function isExclusive(selector: LanguageSelector): boolean {
20 if (typeof selector === 'string') {
26 }
27 }
28 > languageFeatureRegistry.ts
29 > export interface NotebookInfo {
30 > readonly uri: URI;
31 > readonly type: string;
32 > }
33 >
34 > export interface NotebookInfoResolver {
35 > (uri: URI): NotebookInfo | undefined;
36 > }
37 >
38 > class MatchCandidate {
39 > constructor(
40 readonly uri: URI,
41 readonly languageId: string,
44 readonly recursive: boolean,
45 ) { }
46 > languageFeatureRegistry.ts
47 > equals(other: MatchCandidate): boolean {
48 return this.notebookType === other.notebookType
49 && this.languageId === other.languageId
52 && this.recursive === other.recursive;
53 }
54 > } languageFeatureRegistry.ts
55 >
56 > export class LanguageFeatureRegistry<T> {
57 >
58 > private _clock: number = 0;
59 > private readonly _entries: Entry<T>[] = [];
60 >
61 > private readonly _onDidChange = new Emitter<number>();
62 > get onDidChange() { return this._onDidChange.event; }
63 >
64 > constructor(private readonly _notebookInfoResolver?: NotebookInfoResolver) { }
65 >
66 > register(selector: LanguageSelector, provider: T): IDisposable {
67
68 let entry: Entry<T> | undefined = {
111 return result;
112 }
113 > languageFeatureRegistry.ts
114 > allNoModel(): T[] {
115 return this._entries.map(entry => entry.provider);
116 }
117 > languageFeatureRegistry.ts
118 > get registeredLanguageIds(): ReadonlySet<string> {
119 const result = new Set<string>();
120 for (const entry of this._entries) {
123 return result;
124 }
125 > languageFeatureRegistry.ts
126 > ordered(model: ITextModel, recursive = false): T[] {
127 const result: T[] = [];
128 this._orderedForEach(model, recursive, entry => result.push(entry.provider));
129 return result;
130 }
131 > languageFeatureRegistry.ts
132 > orderedGroups(model: ITextModel): T[][] {
133 const result: T[][] = [];
134 let lastBucket: T[];
147 return result;
148 }
149 > languageFeatureRegistry.ts
150 > private _orderedForEach(model: ITextModel, recursive: boolean, callback: (provider: Entry<T>) => void): void {
151
152 this._updateScores(model, recursive);
158 }
159 }
160 > languageFeatureRegistry.ts
161 > private _lastCandidate: MatchCandidate | undefined;
162 >
163 > private _updateScores(model: ITextModel, recursive: boolean): void {
164
165 const notebookInfo = this._notebookInfoResolver?.(model.uri);
199 this._entries.sort(LanguageFeatureRegistry._compareByScoreAndTime);
200 }
201 > languageFeatureRegistry.ts
202 > private static _compareByScoreAndTime(a: Entry<unknown>, b: Entry<unknown>): number {
203 if (a._score < b._score) {
204 return 1;
222 }
223 }
224 > } languageFeatureRegistry.ts
225 >
226 function isBuiltinSelector(selector: LanguageSelector): boolean {
227 if (typeof selector === 'string') {
src/vs/editor/test/common/testTextModel.ts 63 introduced LOC · 6 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- testTextModel.ts
2 > * Copyright (c) Microsoft Corporation. All rights reserved.
3 > * Licensed under the MIT License. See License.txt in the project root for license information.
4 > *--------------------------------------------------------------------------------------------*/
5 >
6 > import { DisposableStore, IDisposable } from '../../../base/common/lifecycle.js';
7 > import { URI } from '../../../base/common/uri.js';
8 > import { BracketPairColorizationOptions, DefaultEndOfLine, ITextBufferFactory, ITextModelCreationOptions } from '../../common/model.js';
9 > import { TextModel } from '../../common/model/textModel.js';
10 > import { ILanguageConfigurationService } from '../../common/languages/languageConfigurationRegistry.js';
11 > import { ILanguageService } from '../../common/languages/language.js';
12 > import { LanguageService } from '../../common/services/languageService.js';
13 > import { ITextResourcePropertiesService } from '../../common/services/textResourceConfiguration.js';
14 > import { TestLanguageConfigurationService } from './modes/testLanguageConfigurationService.js';
15 > import { IConfigurationService } from '../../../platform/configuration/common/configuration.js';
16 > import { TestConfigurationService } from '../../../platform/configuration/test/common/testConfigurationService.js';
17 > import { IDialogService } from '../../../platform/dialogs/common/dialogs.js';
18 > import { TestDialogService } from '../../../platform/dialogs/test/common/testDialogService.js';
19 > import { IInstantiationService } from '../../../platform/instantiation/common/instantiation.js';
20 > import { ILogService, NullLogService } from '../../../platform/log/common/log.js';
21 > import { INotificationService } from '../../../platform/notification/common/notification.js';
22 > import { TestNotificationService } from '../../../platform/notification/test/common/testNotificationService.js';
23 > import { IThemeService } from '../../../platform/theme/common/themeService.js';
24 > import { TestThemeService } from '../../../platform/theme/test/common/testThemeService.js';
25 > import { IUndoRedoService } from '../../../platform/undoRedo/common/undoRedo.js';
26 > import { UndoRedoService } from '../../../platform/undoRedo/common/undoRedoService.js';
27 > import { TestTextResourcePropertiesService } from './services/testTextResourcePropertiesService.js';
28 > import { IModelService } from '../../common/services/model.js';
29 > import { ModelService } from '../../common/services/modelService.js';
30 > import { createServices, ServiceIdCtorPair, TestInstantiationService } from '../../../platform/instantiation/test/common/instantiationServiceMock.js';
31 > import { PLAINTEXT_LANGUAGE_ID } from '../../common/languages/modesRegistry.js';
32 > import { ILanguageFeatureDebounceService, LanguageFeatureDebounceService } from '../../common/services/languageFeatureDebounce.js';
33 > import { ILanguageFeaturesService } from '../../common/services/languageFeatures.js';
34 > import { LanguageFeaturesService } from '../../common/services/languageFeaturesService.js';
35 > import { IEnvironmentService } from '../../../platform/environment/common/environment.js';
36 > import { mock } from '../../../base/test/common/mock.js';
37 > import { ITreeSitterLibraryService } from '../../common/services/treeSitter/treeSitterLibraryService.js';
38 > import { TestTreeSitterLibraryService } from './services/testTreeSitterLibraryService.js';
39 >
40 > class TestTextModel extends TextModel {
41 > public registerDisposable(disposable: IDisposable): void {
42 this._register(disposable);
43 }
44 > } testTextModel.ts
45 >
46 > export function withEditorModel(text: string[], callback: (model: TextModel) => void): void {
47 const model = createTextModel(text.join('\n'));
48 callback(model);
49 model.dispose();
50 }
51 > testTextModel.ts
52 > export interface IRelaxedTextModelCreationOptions {
53 > tabSize?: number;
54 > indentSize?: number | 'tabSize';
55 > insertSpaces?: boolean;
56 > detectIndentation?: boolean;
57 > trimAutoWhitespace?: boolean;
58 > defaultEOL?: DefaultEndOfLine;
59 > isForSimpleWidget?: boolean;
60 > largeFileOptimizations?: boolean;
61 > bracketColorizationOptions?: BracketPairColorizationOptions;
62 > }
63 >
64 function resolveOptions(_options: IRelaxedTextModelCreationOptions): ITextModelCreationOptions {
65 const defaultOptions = TextModel.DEFAULT_CREATION_OPTIONS;
76 };
77 }
78 > testTextModel.ts
79 > export function createTextModel(text: string | ITextBufferFactory, languageId: string | null = null, options: IRelaxedTextModelCreationOptions = TextModel.DEFAULT_CREATION_OPTIONS, uri: URI | null = null): TextModel {
80 const disposables = new DisposableStore();
81 const instantiationService = createModelServices(disposables);
84 return model;
85 }
86 > testTextModel.ts
87 > export function instantiateTextModel(instantiationService: IInstantiationService, text: string | ITextBufferFactory, languageId: string | null = null, _options: IRelaxedTextModelCreationOptions = TextModel.DEFAULT_CREATION_OPTIONS, uri: URI | null = null): TestTextModel {
88 const options = resolveOptions(_options);
89 return instantiationService.createInstance(TestTextModel, text, languageId || PLAINTEXT_LANGUAGE_ID, options, uri);
90 }
91 > testTextModel.ts
92 > export function createModelServices(disposables: DisposableStore, services: ServiceIdCtorPair<any>[] = []): TestInstantiationService {
93 return createServices(disposables, services.concat([
94 [INotificationService, TestNotificationService],
src/vs/platform/theme/test/common/testThemeService.ts 62 introduced LOC · 18 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- testThemeService.ts
2 > * Copyright (c) Microsoft Corporation. All rights reserved.
3 > * Licensed under the MIT License. See License.txt in the project root for license information.
4 > *--------------------------------------------------------------------------------------------*/
5 >
6 > import { Color } from '../../../../base/common/color.js';
7 > import { Emitter, Event } from '../../../../base/common/event.js';
8 > import { IconContribution } from '../../common/iconRegistry.js';
9 > import { ColorScheme } from '../../common/theme.js';
10 > import { IColorTheme, IFileIconTheme, IProductIconTheme, IThemeService, IFontTokenOptions, ITokenStyle } from '../../common/themeService.js';
11 >
12 > export class TestColorTheme implements IColorTheme {
13 >
14 > public readonly label = 'test';
15 >
16 > constructor(
17 private colors: { [id: string]: string | undefined } = {},
18 public type = ColorScheme.DARK,
19 public readonly semanticHighlighting = false
20 ) { }
21 > testThemeService.ts
22 > getColor(color: string, useDefault?: boolean): Color | undefined {
23 const value = this.colors[color];
24 if (value) {
27 return undefined;
28 }
29 > testThemeService.ts
30 > defines(color: string): boolean {
31 throw new Error('Method not implemented.');
32 }
33 > testThemeService.ts
34 > getTokenStyleMetadata(type: string, modifiers: string[], modelLanguage: string): ITokenStyle | undefined {
35 return undefined;
36 }
37 > testThemeService.ts
38 > get tokenColorMap(): string[] {
39 return [];
40 }
41 > testThemeService.ts
42 > get tokenFontMap(): IFontTokenOptions[] {
43 return [];
44 }
45 > } testThemeService.ts
46 >
47 class TestFileIconTheme implements IFileIconTheme {
48 hasFileIcons = false;
49 hasFolderIcons = false;
50 hidesExplorerArrows = false;
51 > } testThemeService.ts
52 >
53 > class UnthemedProductIconTheme implements IProductIconTheme {
54 > getIcon(contribution: IconContribution) {
55 return undefined;
56 }
57 > } testThemeService.ts
58 >
59 > export class TestThemeService implements IThemeService {
60 >
61 > declare readonly _serviceBrand: undefined;
62 > _colorTheme: IColorTheme;
63 > _fileIconTheme: IFileIconTheme;
64 > _productIconTheme: IProductIconTheme;
65 > _onThemeChange = new Emitter<IColorTheme>();
66 > _onFileIconThemeChange = new Emitter<IFileIconTheme>();
67 > _onProductIconThemeChange = new Emitter<IProductIconTheme>();
68 >
69 > constructor(theme: IColorTheme = new TestColorTheme(), fileIconTheme: IFileIconTheme = new TestFileIconTheme(), productIconTheme: IProductIconTheme = new UnthemedProductIconTheme()) {
70 this._colorTheme = theme;
71 this._fileIconTheme = fileIconTheme;
72 this._productIconTheme = productIconTheme;
73 }
74 > testThemeService.ts
75 > getColorTheme(): IColorTheme {
76 return this._colorTheme;
77 }
78 > testThemeService.ts
79 > setTheme(theme: IColorTheme) {
80 this._colorTheme = theme;
81 this.fireThemeChange();
82 }
83 > testThemeService.ts
84 > fireThemeChange() {
85 this._onThemeChange.fire(this._colorTheme);
86 }
87 > testThemeService.ts
88 > public get onDidColorThemeChange(): Event<IColorTheme> {
89 return this._onThemeChange.event;
90 }
91 > testThemeService.ts
92 > getFileIconTheme(): IFileIconTheme {
93 return this._fileIconTheme;
94 }
95 > testThemeService.ts
96 > public get onDidFileIconThemeChange(): Event<IFileIconTheme> {
97 return this._onFileIconThemeChange.event;
98 }
99 > testThemeService.ts
100 > getProductIconTheme(): IProductIconTheme {
101 return this._productIconTheme;
102 }
103 > testThemeService.ts
104 > public get onDidProductIconThemeChange(): Event<IProductIconTheme> {
105 return this._onProductIconThemeChange.event;
106 }
107 > } testThemeService.ts
src/vs/editor/test/common/services/testTreeSitterLibraryService.ts 26 introduced LOC · 8 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- testTreeSitterLibraryService.ts
2 > * Copyright (c) Microsoft Corporation. All rights reserved.
3 > * Licensed under the MIT License. See License.txt in the project root for license information.
4 > *--------------------------------------------------------------------------------------------*/
5 >
6 > import type { Parser, Language, Query } from '@vscode/tree-sitter-wasm';
7 > import { IReader } from '../../../../base/common/observable.js';
8 > import { ITreeSitterLibraryService } from '../../../../editor/common/services/treeSitter/treeSitterLibraryService.js';
9 >
10 > export class TestTreeSitterLibraryService implements ITreeSitterLibraryService {
11 > readonly _serviceBrand: undefined;
12 >
13 > getParserClass(): Promise<typeof Parser> {
14 throw new Error('not implemented in TestTreeSitterLibraryService');
15 }
16 > testTreeSitterLibraryService.ts
17 > supportsLanguage(languageId: string, reader: IReader | undefined): boolean {
18 return false;
19 }
20 > testTreeSitterLibraryService.ts
21 > getLanguage(languageId: string, ignoreSupportsCheck: boolean, reader: IReader | undefined): Language | undefined {
22 return undefined;
23 }
24 > testTreeSitterLibraryService.ts
25 > async getLanguagePromise(languageId: string): Promise<Language | undefined> {
26 return undefined;
27 }
28 > testTreeSitterLibraryService.ts
29 > getInjectionQueries(languageId: string, reader: IReader | undefined): Query | null | undefined {
30 return null;
31 }
32 > testTreeSitterLibraryService.ts
33 > getHighlightingQueries(languageId: string, reader: IReader | undefined): Query | null | undefined {
34 return null;
35 }
36 > testTreeSitterLibraryService.ts
37 > async createQuery(language: Language, querySource: string): Promise<Query> {
38 throw new Error('not implemented in TestTreeSitterLibraryService');
39 }
40 > } testTreeSitterLibraryService.ts
src/vs/editor/common/services/languageFeaturesService.ts 22 introduced LOC · 4 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- languageFeaturesService.ts
2 > * Copyright (c) Microsoft Corporation. All rights reserved.
3 > * Licensed under the MIT License. See License.txt in the project root for license information.
4 > *--------------------------------------------------------------------------------------------*/
5 >
6 > import { URI } from '../../../base/common/uri.js';
7 > import { LanguageFeatureRegistry, NotebookInfo, NotebookInfoResolver } from '../languageFeatureRegistry.js';
8 > import { CodeActionProvider, CodeLensProvider, CompletionItemProvider, DocumentPasteEditProvider, DeclarationProvider, DefinitionProvider, DocumentColorProvider, DocumentFormattingEditProvider, MultiDocumentHighlightProvider, DocumentHighlightProvider, DocumentDropEditProvider, DocumentRangeFormattingEditProvider, DocumentRangeSemanticTokensProvider, DocumentSemanticTokensProvider, DocumentSymbolProvider, EvaluatableExpressionProvider, FoldingRangeProvider, HoverProvider, ImplementationProvider, InlayHintsProvider, InlineCompletionsProvider, InlineValuesProvider, LinkedEditingRangeProvider, LinkProvider, OnTypeFormattingEditProvider, ReferenceProvider, RenameProvider, SelectionRangeProvider, SignatureHelpProvider, TypeDefinitionProvider, NewSymbolNamesProvider } from '../languages.js';
9 > import { ILanguageFeaturesService } from './languageFeatures.js';
10 > import { InstantiationType, registerSingleton } from '../../../platform/instantiation/common/extensions.js';
11 >
12 > export class LanguageFeaturesService implements ILanguageFeaturesService {
13
14 declare _serviceBrand: undefined;
45 readonly documentDropEditProvider = new LanguageFeatureRegistry<DocumentDropEditProvider>(this._score.bind(this));
46 readonly documentPasteEditProvider = new LanguageFeatureRegistry<DocumentPasteEditProvider>(this._score.bind(this));
47 > languageFeaturesService.ts
48 > private _notebookTypeResolver?: NotebookInfoResolver;
49 >
50 > setNotebookTypeResolver(resolver: NotebookInfoResolver | undefined) {
51 this._notebookTypeResolver = resolver;
52 }
53 > languageFeaturesService.ts
54 > private _score(uri: URI): NotebookInfo | undefined {
55 return this._notebookTypeResolver?.(uri);
56 }
57 > languageFeaturesService.ts
58 > }
59 >
60 > registerSingleton(ILanguageFeaturesService, LanguageFeaturesService, InstantiationType.Delayed);

Direct hierarchy

Parents

Children