@theia/plugin-ext 1.29.0-next.4 → 1.29.0-next.9

package/src/main/browser/languages-main.ts

@@ -66,6 +66,9 @@ import * as MonacoPath from '@theia/monaco-editor-core/esm/vs/base/common/path';
 import { IRelativePattern } from '@theia/monaco-editor-core/esm/vs/base/common/glob';
 import { EditorLanguageStatusService, LanguageStatus as EditorLanguageStatus } from '@theia/editor/lib/browser/language-status/editor-language-status-service';
 import { LanguageSelector, RelativePattern } from '@theia/editor/lib/common/language-selector';
+import { ILanguageFeaturesService } from '@theia/monaco-editor-core/esm/vs/editor/common/services/languageFeatures';
+import { EvaluatableExpression, EvaluatableExpressionProvider } from '@theia/monaco-editor-core/esm/vs/editor/common/languages';
+import { ITextModel } from '@theia/monaco-editor-core/esm/vs/editor/common/model';
 
 /**
  * @monaco-uplift The public API declares these functions as (languageId: string, service).
@@ -338,7 +341,26 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
         return this.proxy.$provideHover(handle, model.uri, position, token);
     }
 
-    $registerDocumentHighlightProvider(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[]): void {
+    $registerEvaluatableExpressionProvider(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[]): void {
+        const languageSelector = this.toLanguageSelector(selector);
+        const evaluatableExpressionProvider = this.createEvaluatableExpressionProvider(handle);
+        this.register(handle,
+            (StandaloneServices.get(ILanguageFeaturesService).evaluatableExpressionProvider.register as RegistrationFunction<EvaluatableExpressionProvider>)
+                (languageSelector, evaluatableExpressionProvider));
+    }
+
+    protected createEvaluatableExpressionProvider(handle: number): EvaluatableExpressionProvider {
+        return {
+            provideEvaluatableExpression: (model, position, token) => this.provideEvaluatableExpression(handle, model, position, token)
+        };
+    }
+
+    protected provideEvaluatableExpression(handle: number, model: ITextModel, position: monaco.Position,
+        token: monaco.CancellationToken): monaco.languages.ProviderResult<EvaluatableExpression | undefined> {
+        return this.proxy.$provideEvaluatableExpression(handle, model.uri, position, token);
+    }
+
+    $registerDocumentHighlightProvider(handle: number, _pluginInfo: PluginInfo, selector: SerializedDocumentFilter[]): void {
         const languageSelector = this.toLanguageSelector(selector);
         const documentHighlightProvider = this.createDocumentHighlightProvider(handle);
         this.register(handle, (monaco.languages.registerDocumentHighlightProvider as RegistrationFunction<monaco.languages.DocumentHighlightProvider>)

package/src/main/browser/preference-registry-main.ts

@@ -70,11 +70,10 @@ export class PreferenceRegistryMainImpl implements PreferenceRegistryMain, Dispo
 
             const roots = workspaceService.tryGetRoots();
             const data = getPreferences(preferenceProviderProvider, roots);
-            const eventData: PreferenceChangeExt[] = [];
-            for (const preferenceName of Object.keys(changes)) {
-                const { newValue } = changes[preferenceName];
-                eventData.push({ preferenceName, newValue });
-            }
+            const eventData = Object.values(changes).map<PreferenceChangeExt>(({ scope, newValue, domain, preferenceName }) => {
+                const extScope = scope === PreferenceScope.User ? undefined : domain?.[0];
+                return { preferenceName, newValue, scope: extScope };
+            });
             this.proxy.$acceptConfigurationChanged(data, eventData);
         }));
     }
@@ -84,17 +83,19 @@ export class PreferenceRegistryMainImpl implements PreferenceRegistryMain, Dispo
     }
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    async $updateConfigurationOption(target: boolean | ConfigurationTarget | undefined, key: string, value: any, resource?: string): Promise<void> {
-        const scope = this.parseConfigurationTarget(target);
-        await this.preferenceService.set(key, value, scope, resource);
+    async $updateConfigurationOption(target: boolean | ConfigurationTarget | undefined, key: string, value: any, resource?: string, withLanguageOverride?: boolean): Promise<void> {
+        const scope = this.parseConfigurationTarget(target, resource);
+        const effectiveKey = this.getEffectiveKey(key, scope, withLanguageOverride, resource);
+        await this.preferenceService.set(effectiveKey, value, scope, resource);
     }
 
-    async $removeConfigurationOption(target: boolean | ConfigurationTarget | undefined, key: string, resource?: string): Promise<void> {
-        const scope = this.parseConfigurationTarget(target);
-        await this.preferenceService.set(key, undefined, scope, resource);
+    async $removeConfigurationOption(target: boolean | ConfigurationTarget | undefined, key: string, resource?: string, withLanguageOverride?: boolean): Promise<void> {
+        const scope = this.parseConfigurationTarget(target, resource);
+        const effectiveKey = this.getEffectiveKey(key, scope, withLanguageOverride, resource);
+        await this.preferenceService.set(effectiveKey, undefined, scope, resource);
     }
 
-    private parseConfigurationTarget(target?: boolean | ConfigurationTarget): PreferenceScope | undefined {
+    private parseConfigurationTarget(target?: boolean | ConfigurationTarget, resource?: string): PreferenceScope {
         if (typeof target === 'boolean') {
             return target ? PreferenceScope.User : PreferenceScope.Workspace;
         }
@@ -106,9 +107,17 @@ export class PreferenceRegistryMainImpl implements PreferenceRegistryMain, Dispo
             case ConfigurationTarget.WorkspaceFolder:
                 return PreferenceScope.Folder;
             default:
-                // PreferenceService knows how to deal with undefined in VS Code compatible way
-                return undefined;
+                return resource ? PreferenceScope.Folder : PreferenceScope.Workspace;
         }
     }
 
+    // If the caller does not set `withLanguageOverride = true`, we have to check whether the setting exists with that override already.
+    protected getEffectiveKey(key: string, scope: PreferenceScope, withLanguageOverride?: boolean, resource?: string): string {
+        if (withLanguageOverride) { return key; }
+        const overridden = this.preferenceService.overriddenPreferenceName(key);
+        if (!overridden) { return key; }
+        const value = this.preferenceService.inspectInScope(key, scope, resource, withLanguageOverride);
+        return value === undefined ? overridden.preferenceName : key;
+    }
+
 }

package/src/plugin/languages/evaluatable-expression.ts

@@ -0,0 +1,47 @@
+// *****************************************************************************
+// Copyright (C) 2022 STMicroelectronics and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { URI } from '@theia/core/shared/vscode-uri';
+import * as theia from '@theia/plugin';
+import { Position } from '../../common/plugin-api-rpc';
+import { EvaluatableExpression } from '../../common/plugin-api-rpc-model';
+import { DocumentsExtImpl } from '../documents';
+import * as Converter from '../type-converters';
+
+export class EvaluatableExpressionAdapter {
+
+    constructor(
+        private readonly provider: theia.EvaluatableExpressionProvider,
+        private readonly documents: DocumentsExtImpl
+    ) { }
+
+    async provideEvaluatableExpression(resource: URI, position: Position, token: theia.CancellationToken): Promise<EvaluatableExpression | undefined> {
+        const documentData = this.documents.getDocumentData(resource);
+        if (!documentData) {
+            return Promise.reject(new Error(`There is no document data for ${resource}`));
+        }
+
+        const document = documentData.document;
+        const pos = Converter.toPosition(position);
+
+        return Promise.resolve(this.provider.provideEvaluatableExpression(document, pos, token)).then(expression => {
+            if (!expression) {
+                return undefined;
+            }
+            return Converter.fromEvaluatableExpression(expression);
+        });
+    }
+}

package/src/plugin/languages.ts

@@ -62,11 +62,13 @@ import {
     CallHierarchyIncomingCall,
     CallHierarchyOutgoingCall,
     LinkedEditingRanges,
+    EvaluatableExpression
 } from '../common/plugin-api-rpc-model';
 import { CompletionAdapter } from './languages/completion';
 import { Diagnostics } from './languages/diagnostics';
 import { SignatureHelpAdapter } from './languages/signature';
 import { HoverAdapter } from './languages/hover';
+import { EvaluatableExpressionAdapter } from './languages/evaluatable-expression';
 import { DocumentHighlightAdapter } from './languages/document-highlight';
 import { DocumentFormattingAdapter } from './languages/document-formatting';
 import { RangeFormattingAdapter } from './languages/range-formatting';
@@ -100,6 +102,7 @@ import { serializeEnterRules, serializeIndentation, serializeRegExp } from './la
 type Adapter = CompletionAdapter |
     SignatureHelpAdapter |
     HoverAdapter |
+    EvaluatableExpressionAdapter |
     DocumentHighlightAdapter |
     DocumentFormattingAdapter |
     RangeFormattingAdapter |
@@ -350,6 +353,18 @@ export class LanguagesExtImpl implements LanguagesExt {
     }
     // ### Hover Provider end
 
+    // ### EvaluatableExpression Provider begin
+    registerEvaluatableExpressionProvider(selector: theia.DocumentSelector, provider: theia.EvaluatableExpressionProvider, pluginInfo: PluginInfo): theia.Disposable {
+        const callId = this.addNewAdapter(new EvaluatableExpressionAdapter(provider, this.documents));
+        this.proxy.$registerEvaluatableExpressionProvider(callId, pluginInfo, this.transformDocumentSelector(selector));
+        return this.createDisposable(callId);
+    }
+
+    $provideEvaluatableExpression(handle: number, resource: UriComponents, position: Position, token: theia.CancellationToken): Promise<EvaluatableExpression | undefined> {
+        return this.withAdapter(handle, EvaluatableExpressionAdapter, adapter => adapter.provideEvaluatableExpression(URI.revive(resource), position, token), undefined);
+    }
+    // ### EvaluatableExpression Provider end
+
     // ### Document Highlight Provider begin
     registerDocumentHighlightProvider(selector: theia.DocumentSelector, provider: theia.DocumentHighlightProvider, pluginInfo: PluginInfo): theia.Disposable {
         const callId = this.addNewAdapter(new DocumentHighlightAdapter(provider, this.documents));

package/src/plugin/plugin-context.ts

@@ -78,6 +78,7 @@ import {
     SignatureHelp,
     SignatureHelpTriggerKind,
     Hover,
+    EvaluatableExpression,
     DocumentHighlightKind,
     DocumentHighlight,
     DocumentLink,
@@ -559,7 +560,7 @@ export function createAPIFactory(
                 extHostFileSystemEvent.getOnWillDeleteFileEvent(plugin)(listener, thisArg, disposables),
             onWillRenameFiles: (listener: (e: theia.FileWillRenameEvent) => any, thisArg?: any, disposables?: theia.Disposable[]) =>
                 extHostFileSystemEvent.getOnWillRenameFileEvent(plugin)(listener, thisArg, disposables),
-            getConfiguration(section?, resource?): theia.WorkspaceConfiguration {
+            getConfiguration(section, resource): theia.WorkspaceConfiguration {
                 return preferenceRegistryExt.getConfiguration(section, resource);
             },
             onDidChangeConfiguration(listener, thisArgs?, disposables?): theia.Disposable {
@@ -731,6 +732,9 @@ export function createAPIFactory(
             registerHoverProvider(selector: theia.DocumentSelector, provider: theia.HoverProvider): theia.Disposable {
                 return languagesExt.registerHoverProvider(selector, provider, pluginToPluginInfo(plugin));
             },
+            registerEvaluatableExpressionProvider(selector: theia.DocumentSelector, provider: theia.EvaluatableExpressionProvider): theia.Disposable {
+                return languagesExt.registerEvaluatableExpressionProvider(selector, provider, pluginToPluginInfo(plugin));
+            },
             registerDocumentHighlightProvider(selector: theia.DocumentSelector, provider: theia.DocumentHighlightProvider): theia.Disposable {
                 return languagesExt.registerDocumentHighlightProvider(selector, provider, pluginToPluginInfo(plugin));
             },
@@ -991,6 +995,7 @@ export function createAPIFactory(
             SignatureHelp,
             SignatureHelpTriggerKind,
             Hover,
+            EvaluatableExpression,
             DocumentHighlightKind,
             DocumentHighlight,
             DocumentLink,

package/src/plugin/plugin-storage.ts

@@ -38,6 +38,10 @@ export class Memento implements theia.Memento {
         }
     }
 
+    keys(): string[] {
+        return Object.entries(this.cache).filter(([, value]) => value !== undefined).map(([key]) => key);
+    }
+
     get<T>(key: string): T | undefined;
     get<T>(key: string, defaultValue: T): T;
     get<T>(key: string, defaultValue?: T): T | undefined {

package/src/plugin/preference-registry.spec.ts

@@ -14,16 +14,17 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { PreferenceRegistryExtImpl } from './preference-registry';
+import { PreferenceRegistryExtImpl, PreferenceScope } from './preference-registry';
 import * as chai from 'chai';
 import { WorkspaceExtImpl } from '../plugin/workspace';
 import { ProxyIdentifier, RPCProtocol } from '../common/rpc-protocol';
+import { URI } from './types-impl';
 
 const expect = chai.expect;
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 describe('PreferenceRegistryExtImpl:', () => {
-
+    const workspaceRoot = URI.parse('/workspace-root');
     let preferenceRegistryExtImpl: PreferenceRegistryExtImpl;
     const getProxy = (proxyId: ProxyIdentifier<unknown>) => { };
     const set = (identifier: ProxyIdentifier<unknown>, instance: unknown) => { };
@@ -34,59 +35,221 @@ describe('PreferenceRegistryExtImpl:', () => {
         set,
         dispose
     } as RPCProtocol;
-    const mockWorkspace: WorkspaceExtImpl = {} as WorkspaceExtImpl;
+    const mockWorkspace: WorkspaceExtImpl = { workspaceFolders: [{ uri: workspaceRoot, name: 'workspace-root', index: 0 }] } as WorkspaceExtImpl;
 
     beforeEach(() => {
         preferenceRegistryExtImpl = new PreferenceRegistryExtImpl(mockRPC, mockWorkspace);
     });
 
-    it('Check parseConfigurationData', () => {
-        const value: { [key: string]: any } = {
+    it('should parse configuration data without overrides', () => {
+        const value: Record<string, any> = {
             'my.key1.foo': 'value1',
             'my.key1.bar': 'value2',
         };
-        const result: { [key: string]: any } = (preferenceRegistryExtImpl as any).parseConfigurationData(value);
-        expect(result.my).to.be.an('object');
-        expect(result.my.key1).to.be.an('object');
+        const result = preferenceRegistryExtImpl['parseConfigurationData'](value);
+        expect(result.contents.my).to.be.an('object');
+        expect(result.contents.my.key1).to.be.an('object');
 
-        expect(result.my.key1.foo).to.be.an('string');
-        expect(result.my.key1.foo).to.equal('value1');
+        expect(result.contents.my.key1.foo).to.be.an('string');
+        expect(result.contents.my.key1.foo).to.equal('value1');
 
-        expect(result.my.key1.bar).to.be.an('string');
-        expect(result.my.key1.bar).to.equal('value2');
+        expect(result.contents.my.key1.bar).to.be.an('string');
+        expect(result.contents.my.key1.bar).to.equal('value2');
+        expect(result.keys).deep.equal(['my.key1.foo', 'my.key1.bar']);
     });
 
-    it('Prototype pollution check', () => {
-        const value: { [key: string]: any } = {
-            'my.key1.foo': 'value1',
-            '__proto__.injectedParsedPrototype': true,
-            'a.__proto__.injectedParsedPrototype': true,
-            '__proto__': {},
+    it('should parse configuration with overrides', () => {
+        const value: Record<string, any> = {
+            'editor.tabSize': 2,
+            '[typescript].editor.tabSize': 4,
         };
-        const result: { [key: string]: any } = (preferenceRegistryExtImpl as any).parseConfigurationData(value);
-        expect(result.my).to.be.an('object');
-        expect(result.__proto__).to.be.an('undefined');
-        expect(result.my.key1.foo).to.equal('value1');
-        const prototypeObject = Object.prototype as any;
-        expect(prototypeObject.injectedParsedPrototype).to.be.an('undefined');
-        const rawObject = {} as any;
-        expect(rawObject.injectedParsedPrototype).to.be.an('undefined');
+        const result = preferenceRegistryExtImpl['parseConfigurationData'](value);
+        expect(result.contents.editor.tabSize).to.equal(2);
+        const tsOverride = result.overrides[0];
+        expect(tsOverride.contents.editor.tabSize).to.equal(4);
+        expect(tsOverride.identifiers).deep.equal(['typescript']);
+        expect(tsOverride.keys).deep.equal(['editor.tabSize']);
     });
 
-    it('Prototype constructor pollution check', () => {
-        const value: { [key: string]: any } = {
-            'my.key1.foo': 'value1',
-            'a.constructor.prototype.injectedParsedConstructorPrototype': true,
-            'constructor.prototype.injectedParsedConstructorPrototype': true,
-        };
-        const result: { [key: string]: any } = (preferenceRegistryExtImpl as any).parseConfigurationData(value);
-        expect(result.my).to.be.an('object');
-        expect(result.__proto__).to.be.an('undefined');
-        expect(result.my.key1.foo).to.equal('value1');
-        const prototypeObject = Object.prototype as any;
-        expect(prototypeObject.injectedParsedConstructorPrototype).to.be.an('undefined');
-        const rawObject = {} as any;
-        expect(rawObject.injectedParsedConstructorPrototype).to.be.an('undefined');
+    describe('Prototype pollution', () => {
+        it('Ignores key `__proto__`', () => {
+            const value: Record<string, any> = {
+                'my.key1.foo': 'value1',
+                '__proto__.injectedParsedPrototype': true,
+                'a.__proto__.injectedParsedPrototype': true,
+                '__proto__': {},
+                '[typescript].someKey.foo': 'value',
+                '[typescript].__proto__.injectedParsedPrototype': true,
+            };
+            const result = preferenceRegistryExtImpl['parseConfigurationData'](value);
+            expect(result.contents.my).to.be.an('object');
+            expect(result.contents.__proto__).to.be.an('undefined');
+            expect(result.contents.my.key1.foo).to.equal('value1');
+            expect(result.overrides[0].contents.__proto__).to.be.an('undefined');
+            const prototypeObject = Object.prototype as any;
+            expect(prototypeObject.injectedParsedPrototype).to.be.an('undefined');
+            const rawObject = {} as any;
+            expect(rawObject.injectedParsedPrototype).to.be.an('undefined');
+        });
+
+        it('Ignores key `constructor.prototype`', () => {
+            const value: Record<string, any> = {
+                'my.key1.foo': 'value1',
+                'a.constructor.prototype.injectedParsedConstructorPrototype': true,
+                'constructor.prototype.injectedParsedConstructorPrototype': true,
+                '[python].some.key.foo': 'value',
+                '[python].a.constructor.prototype.injectedParsedConsttructorPrototype': true
+            };
+            const result = preferenceRegistryExtImpl['parseConfigurationData'](value);
+            expect(result.contents.my).to.be.an('object');
+            expect(result.contents.__proto__).to.be.an('undefined');
+            expect(result.contents.my.key1.foo).to.equal('value1');
+            const prototypeObject = Object.prototype as any;
+            expect(prototypeObject.injectedParsedConstructorPrototype).to.be.an('undefined');
+            expect(result.overrides[0].contents.__proto__).to.be.an('undefined');
+            const rawObject = {} as any;
+            expect(rawObject.injectedParsedConstructorPrototype).to.be.an('undefined');
+        });
     });
 
+    /* eslint-disable no-unused-expressions */
+    describe('toConfigurationChangeEvent', () => {
+        // E.g. deletion of a `tasks.json`.
+        it('Handles deletion of a section', () => {
+            const affectsChecker = preferenceRegistryExtImpl['toConfigurationChangeEvent']([{ newValue: undefined, preferenceName: 'whole-section' }]);
+            expect(affectsChecker.affectsConfiguration('whole-section')).to.be.true;
+        });
+
+        it('Reports true of supersection if subsection changes', () => {
+            const affectsChecker = preferenceRegistryExtImpl['toConfigurationChangeEvent']([{ newValue: 'foo', preferenceName: 'whole-section.subsection.item' }]);
+            expect(affectsChecker.affectsConfiguration('whole-section')).to.be.true;
+        });
+
+        // This assumes that there should not exist a preference `section` and `section.*` as separate preferences.
+        // This is true in practice in all cases except `extensions` (i.e. extensions.json) and extensions.ignoreRecommendations etc.
+        // Given that, if a super-section changes (e.g. through deletion), all subsections will also be affected.
+        it('Reports true of a subsection if a supersection changes', () => {
+            const affectsChecker = preferenceRegistryExtImpl['toConfigurationChangeEvent']([{ newValue: 'bar', preferenceName: 'whole-section' }]);
+            expect(affectsChecker.affectsConfiguration('whole-section.subsection')).to.be.true;
+        });
+
+        it('Does not report true if a different subsection changes:', () => {
+            const affectsChecker = preferenceRegistryExtImpl['toConfigurationChangeEvent']([{ newValue: 'bar', preferenceName: 'whole-section.subsection.itemA' }]);
+            expect(affectsChecker.affectsConfiguration('whole-section.subsection.itemB')).to.be.false;
+        });
+
+        it('Reports that any URI is affected if change has no URI', () => {
+            const affectsChecker = preferenceRegistryExtImpl['toConfigurationChangeEvent']([{ newValue: 'bar', preferenceName: 'whole-section' }]);
+            expect(affectsChecker.affectsConfiguration('whole-section.subsection', URI.parse('/wherever'))).to.be.true;
+        });
+
+        it('Reports true if no URI is provided to check', () => {
+            const affectsChecker = preferenceRegistryExtImpl['toConfigurationChangeEvent'](
+                [{ newValue: 'bar', preferenceName: 'whole-section', scope: 'file:///very/specific/path' }]
+            );
+            expect(affectsChecker.affectsConfiguration('whole-section.subsection')).to.be.true;
+        });
+
+        it('Reports false if the URIs dont match.', () => {
+            const affectsChecker = preferenceRegistryExtImpl['toConfigurationChangeEvent'](
+                [{ newValue: 'bar', preferenceName: 'whole-section', scope: 'file:///very/specific/path' }]
+            );
+            expect(affectsChecker.affectsConfiguration('whole-section.subsection', URI.parse('/other/specific/path'))).to.be.false;
+        });
+
+        it('Reports true if the URIs do match', () => {
+            const affectsChecker = preferenceRegistryExtImpl['toConfigurationChangeEvent'](
+                [{ newValue: 'bar', preferenceName: 'whole-section', scope: 'file:///very/specific/path' }]
+            );
+            expect(affectsChecker.affectsConfiguration('whole-section.subsection', URI.parse('/very/specific/path'))).to.be.true;
+        });
+
+        it('Reports true if the checked URI is a child of the affected path', () => {
+            const affectsChecker = preferenceRegistryExtImpl['toConfigurationChangeEvent'](
+                [{ newValue: 'bar', preferenceName: 'whole-section', scope: 'file:///very/specific/path' }]
+            );
+            expect(affectsChecker.affectsConfiguration('whole-section.subsection', URI.parse('/very/specific/path/and/its/child'))).to.be.true;
+        });
+
+        it('Reports false if the checked URI starts with the affected path but not at a directory break', () => {
+            const affectsChecker = preferenceRegistryExtImpl['toConfigurationChangeEvent'](
+                [{ newValue: 'bar', preferenceName: 'whole-section', scope: 'file:///very/specific/path' }]
+            );
+            expect(affectsChecker.affectsConfiguration('whole-section.subsection', URI.parse('/very/specific/path-or-not/and/its/child'))).to.be.false;
+        });
+
+        it('Extracts language override and returns false if change does not include language', () => {
+            const affectsChecker = preferenceRegistryExtImpl['toConfigurationChangeEvent'](
+                [{ newValue: 'bar', preferenceName: 'whole-section', scope: 'file:///very/specific/path' }]
+            );
+            expect(affectsChecker.affectsConfiguration('whole-section.subsection', { languageId: 'typescript' })).to.be.false;
+        });
+
+        it('Extracts language override and returns true if change does include language', () => {
+            const affectsChecker = preferenceRegistryExtImpl['toConfigurationChangeEvent'](
+                [{ newValue: 'bar', preferenceName: '[typescript].whole-section', scope: 'file:///very/specific/path' }]
+            );
+            expect(affectsChecker.affectsConfiguration('whole-section.subsection', { languageId: 'typescript' })).to.be.true;
+        });
+
+        it("Extracts language override and URI and returns false if the URI doesn't match", () => {
+            const affectsChecker = preferenceRegistryExtImpl['toConfigurationChangeEvent'](
+                [{ newValue: 'bar', preferenceName: '[typescript].whole-section', scope: 'file:///very/specific/path' }]
+            );
+            expect(affectsChecker.affectsConfiguration('whole-section.subsection', { languageId: 'typescript', uri: URI.parse('/other/specific/path') })).to.be.false;
+        });
+
+        it('Extracts language override and URI and returns true if both match', () => {
+            const affectsChecker = preferenceRegistryExtImpl['toConfigurationChangeEvent'](
+                [{ newValue: 'bar', preferenceName: '[typescript].whole-section', scope: 'file:///very/specific/path' }]
+            );
+            expect(affectsChecker.affectsConfiguration('whole-section.subsection', { languageId: 'typescript', uri: URI.parse('/very/specific/path') })).to.be.true;
+        });
+
+        it('Reports true if no language override is provided and a language overriden preference changes', () => {
+            const affectsChecker = preferenceRegistryExtImpl['toConfigurationChangeEvent'](
+                [{ newValue: 'bar', preferenceName: '[typescript].whole-section.subitem', scope: 'file:///somewhat-specific-path' }]
+            );
+            expect(affectsChecker.affectsConfiguration('whole-section.subitem')).to.be.true;
+        });
+    });
+
+    describe('Overrides', () => {
+        const values = {
+            [PreferenceScope.Default]: {
+                'editor.fontSize': 14,
+                'editor.tabSize': 2,
+                'editor.renderWhitespace': 'selection'
+            },
+            [PreferenceScope.User]: {
+                'editor.tabSize': 4,
+            },
+            [PreferenceScope.Workspace]: {
+                'editor.renderWhitespace': 'none',
+                '[python].editor.renderWhitespace': 'all',
+            },
+            [PreferenceScope.Folder]: {
+                [workspaceRoot.toString()]: {
+                    'editor.fontSize': 12,
+                }
+            },
+        };
+        beforeEach(() => preferenceRegistryExtImpl.init(values));
+        it('Returns a scoped value when URI is provided', () => {
+            const valuesRetrieved = preferenceRegistryExtImpl.getConfiguration(undefined, workspaceRoot).get('editor') as Record<string, unknown>;
+            expect(valuesRetrieved.fontSize).equal(12);
+        });
+        it('Returns a lower-priority scope if the value is undefined in the URI-designated scope', () => {
+            const valuesRetrieved = preferenceRegistryExtImpl.getConfiguration(undefined, workspaceRoot).get('editor') as Record<string, unknown>;
+            expect(valuesRetrieved.renderWhitespace).equal('none');
+        });
+        it('Returns a language-overridden value if languageId is provided', () => {
+            const valuesRetrieved = preferenceRegistryExtImpl.getConfiguration(undefined, { uri: workspaceRoot, languageId: 'python' }).get('editor') as Record<string, unknown>;
+            expect(valuesRetrieved.renderWhitespace).equal('all');
+        });
+        it('Returns the default value if the language override is undefined', () => {
+            const valuesRetrieved = preferenceRegistryExtImpl.getConfiguration(undefined, { uri: workspaceRoot, languageId: 'python' }).get('editor') as Record<string, unknown>;
+            expect(valuesRetrieved.tabSize).equal(4);
+        });
+    });
 });