Fix microsoft#176813 (microsoft#187750)

* Fix microsoft#176813

* fix tests

* fix tests

* address feedback

Author: sandy081

src/vs/platform/configuration/common/configurationModels.ts

@@ -269,8 +269,10 @@ export class ConfigurationModel implements IConfigurationModel {
 }
 
 export interface ConfigurationParseOptions {
-	scopes: ConfigurationScope[] | undefined;
+	scopes?: ConfigurationScope[];
 	skipRestricted?: boolean;
+	include?: string[];
+	exclude?: string[];
 }
 
 export class ConfigurationModelParser {
@@ -383,7 +385,7 @@ export class ConfigurationModelParser {
 
 	private filter(properties: any, configurationProperties: { [qualifiedKey: string]: IConfigurationPropertySchema | undefined }, filterOverriddenProperties: boolean, options?: ConfigurationParseOptions): { raw: {}; restricted: string[]; hasExcludedProperties: boolean } {
 		let hasExcludedProperties = false;
-		if (!options?.scopes && !options?.skipRestricted) {
+		if (!options?.scopes && !options?.skipRestricted && !options?.exclude?.length) {
 			return { raw: properties, restricted: [], hasExcludedProperties };
 		}
 		const raw: any = {};
@@ -400,9 +402,10 @@ export class ConfigurationModelParser {
 				if (propertySchema?.restricted) {
 					restricted.push(key);
 				}
-				// Load unregistered configurations always.
-				if ((scope === undefined || options.scopes === undefined || options.scopes.includes(scope)) // Check scopes
-					&& !(options.skipRestricted && propertySchema?.restricted)) { // Check restricted
+				if (!options.exclude?.includes(key) /* Check exclude */
+					&& (options.include?.includes(key) /* Check include */
+						|| ((scope === undefined || options.scopes === undefined || options.scopes.includes(scope)) /* Check scopes */
+							&& !(options.skipRestricted && propertySchema?.restricted)))) /* Check restricted */ {
 					raw[key] = properties[key];
 				} else {
 					hasExcludedProperties = true;
@@ -435,19 +438,17 @@ export class ConfigurationModelParser {
 export class UserSettings extends Disposable {
 
 	private readonly parser: ConfigurationModelParser;
-	private readonly parseOptions: ConfigurationParseOptions;
 	protected readonly _onDidChange: Emitter<void> = this._register(new Emitter<void>());
 	readonly onDidChange: Event<void> = this._onDidChange.event;
 
 	constructor(
 		private readonly userSettingsResource: URI,
-		private readonly scopes: ConfigurationScope[] | undefined,
+		protected parseOptions: ConfigurationParseOptions,
 		extUri: IExtUri,
 		private readonly fileService: IFileService
 	) {
 		super();
 		this.parser = new ConfigurationModelParser(this.userSettingsResource.toString());
-		this.parseOptions = { scopes: this.scopes };
 		this._register(this.fileService.watch(extUri.dirname(this.userSettingsResource)));
 		// Also listen to the resource incase the resource is a symlink - https://github.com/microsoft/vscode/issues/118134
 		this._register(this.fileService.watch(this.userSettingsResource));
@@ -467,7 +468,10 @@ export class UserSettings extends Disposable {
 		}
 	}
 
-	reparse(): ConfigurationModel {
+	reparse(parseOptions?: ConfigurationParseOptions): ConfigurationModel {
+		if (parseOptions) {
+			this.parseOptions = parseOptions;
+		}
 		this.parser.reparse(this.parseOptions);
 		return this.parser.configurationModel;
 	}

src/vs/platform/configuration/common/configurationService.ts

@@ -37,7 +37,7 @@ export class ConfigurationService extends Disposable implements IConfigurationSe
 		super();
 		this.defaultConfiguration = this._register(new DefaultConfiguration());
 		this.policyConfiguration = policyService instanceof NullPolicyService ? new NullPolicyConfiguration() : this._register(new PolicyConfiguration(this.defaultConfiguration, policyService, logService));
-		this.userConfiguration = this._register(new UserSettings(this.settingsResource, undefined, extUriBiasedIgnorePathCase, fileService));
+		this.userConfiguration = this._register(new UserSettings(this.settingsResource, {}, extUriBiasedIgnorePathCase, fileService));
 		this.configuration = new Configuration(this.defaultConfiguration.configurationModel, this.policyConfiguration.configurationModel, new ConfigurationModel(), new ConfigurationModel());
 
 		this.reloadConfigurationScheduler = this._register(new RunOnceScheduler(() => this.reloadConfiguration(), 50));

src/vs/platform/configuration/test/common/configurationModels.test.ts

@@ -6,11 +6,26 @@ import * as assert from 'assert';
 import { join } from 'vs/base/common/path';
 import { URI } from 'vs/base/common/uri';
 import { Configuration, ConfigurationChangeEvent, ConfigurationModel, ConfigurationModelParser, mergeChanges } from 'vs/platform/configuration/common/configurationModels';
+import { IConfigurationRegistry, Extensions, ConfigurationScope } from 'vs/platform/configuration/common/configurationRegistry';
+import { Registry } from 'vs/platform/registry/common/platform';
 import { WorkspaceFolder } from 'vs/platform/workspace/common/workspace';
 import { Workspace } from 'vs/platform/workspace/test/common/testWorkspace';
 
 suite('ConfigurationModelParser', () => {
 
+	suiteSetup(() => {
+		Registry.as<IConfigurationRegistry>(Extensions.Configuration).registerConfiguration({
+			'id': 'ConfigurationModelParserTest',
+			'type': 'object',
+			'properties': {
+				'ConfigurationModelParserTest.windowSetting': {
+					'type': 'string',
+					'default': 'isSet',
+				}
+			}
+		});
+	});
+
 	test('parse configuration model with single override identifier', () => {
 		const testObject = new ConfigurationModelParser('');
 
@@ -35,6 +50,39 @@ suite('ConfigurationModelParser', () => {
 		assert.deepStrictEqual(JSON.stringify(testObject.configurationModel.overrides), JSON.stringify([{ identifiers: ['x', 'y', 'z'], keys: ['a'], contents: { 'a': 1 } }]));
 	});
 
+	test('parse configuration model with exclude option', () => {
+		const testObject = new ConfigurationModelParser('');
+
+		testObject.parse(JSON.stringify({ 'a': 1, 'b': 2 }), { exclude: ['a'] });
+
+		assert.strictEqual(testObject.configurationModel.getValue('a'), undefined);
+		assert.strictEqual(testObject.configurationModel.getValue('b'), 2);
+	});
+
+	test('parse configuration model with exclude option even included', () => {
+		const testObject = new ConfigurationModelParser('');
+
+		testObject.parse(JSON.stringify({ 'a': 1, 'b': 2 }), { exclude: ['a'], include: ['a'] });
+
+		assert.strictEqual(testObject.configurationModel.getValue('a'), undefined);
+		assert.strictEqual(testObject.configurationModel.getValue('b'), 2);
+	});
+
+	test('parse configuration model with scopes filter', () => {
+		const testObject = new ConfigurationModelParser('');
+
+		testObject.parse(JSON.stringify({ 'ConfigurationModelParserTest.windowSetting': '1' }), { scopes: [ConfigurationScope.APPLICATION] });
+
+		assert.strictEqual(testObject.configurationModel.getValue('ConfigurationModelParserTest.windowSetting'), undefined);
+	});
+
+	test('parse configuration model with include option', () => {
+		const testObject = new ConfigurationModelParser('');
+
+		testObject.parse(JSON.stringify({ 'ConfigurationModelParserTest.windowSetting': '1' }), { include: ['ConfigurationModelParserTest.windowSetting'], scopes: [ConfigurationScope.APPLICATION] });
+
+		assert.strictEqual(testObject.configurationModel.getValue('ConfigurationModelParserTest.windowSetting'), '1');
+	});
 
 });
 

src/vs/platform/configuration/test/common/configurations.test.ts

@@ -62,24 +62,24 @@ suite('DefaultConfiguration', () => {
 
 	test('Test registering a property after initialize', async () => {
 		const testObject = new DefaultConfiguration();
-		const promise = Event.toPromise(testObject.onDidChangeConfiguration);
 		await testObject.initialize();
+		const promise = Event.toPromise(testObject.onDidChangeConfiguration);
 		configurationRegistry.registerConfiguration({
 			'id': 'a',
 			'order': 1,
 			'title': 'a',
 			'type': 'object',
 			'properties': {
-				'a': {
+				'defaultConfiguration.testSetting1': {
 					'description': 'a',
 					'type': 'boolean',
 					'default': false,
 				}
 			}
 		});
 		const { defaults: actual, properties } = await promise;
-		assert.strictEqual(actual.getValue('a'), false);
-		assert.deepStrictEqual(properties, ['a']);
+		assert.strictEqual(actual.getValue('defaultConfiguration.testSetting1'), false);
+		assert.deepStrictEqual(properties, ['defaultConfiguration.testSetting1']);
 	});
 
 	test('Test registering nested properties', async () => {

src/vs/workbench/contrib/preferences/browser/preferencesRenderers.ts

@@ -44,6 +44,7 @@ import { IUserDataProfileService } from 'vs/workbench/services/userDataProfile/c
 import { isEqual } from 'vs/base/common/resources';
 import { IUserDataProfilesService } from 'vs/platform/userDataProfile/common/userDataProfile';
 import { IStringDictionary } from 'vs/base/common/collections';
+import { APPLY_ALL_PROFILES_SETTING, IWorkbenchConfigurationService } from 'vs/workbench/services/configuration/common/configuration';
 
 export interface IPreferencesRenderer extends IDisposable {
 	render(): void;
@@ -481,7 +482,7 @@ class UnsupportedSettingsRenderer extends Disposable implements languages.CodeAc
 		private readonly settingsEditorModel: SettingsEditorModel,
 		@IMarkerService private readonly markerService: IMarkerService,
 		@IWorkbenchEnvironmentService private readonly environmentService: IWorkbenchEnvironmentService,
-		@IConfigurationService private readonly configurationService: IConfigurationService,
+		@IWorkbenchConfigurationService private readonly configurationService: IWorkbenchConfigurationService,
 		@IWorkspaceTrustManagementService private readonly workspaceTrustManagementService: IWorkspaceTrustManagementService,
 		@IUriIdentityService private readonly uriIdentityService: IUriIdentityService,
 		@ILanguageFeaturesService languageFeaturesService: ILanguageFeaturesService,
@@ -603,19 +604,27 @@ class UnsupportedSettingsRenderer extends Disposable implements languages.CodeAc
 
 	private handleLocalUserConfiguration(setting: ISetting, configuration: IConfigurationPropertySchema, markerData: IMarkerData[]): void {
 		if (!this.userDataProfileService.currentProfile.isDefault && !this.userDataProfileService.currentProfile.useDefaultFlags?.settings) {
-			if (isEqual(this.userDataProfilesService.defaultProfile.settingsResource, this.settingsEditorModel.uri) && configuration.scope !== ConfigurationScope.APPLICATION) {
-				// If we're in the default profile setting file, and the setting is not
-				// application-scoped, fade it out.
+			if (isEqual(this.userDataProfilesService.defaultProfile.settingsResource, this.settingsEditorModel.uri) && !this.configurationService.isSettingAppliedForAllProfiles(setting.key)) {
+				// If we're in the default profile setting file, and the setting cannot be applied in all profiles
 				markerData.push({
 					severity: MarkerSeverity.Hint,
 					tags: [MarkerTag.Unnecessary],
 					...setting.range,
 					message: nls.localize('defaultProfileSettingWhileNonDefaultActive', "This setting cannot be applied while a non-default profile is active. It will be applied when the default profile is active.")
 				});
-			} else if (isEqual(this.userDataProfileService.currentProfile.settingsResource, this.settingsEditorModel.uri) && configuration.scope === ConfigurationScope.APPLICATION) {
-				// If we're in a profile setting file, and the setting is
-				// application-scoped, fade it out.
-				markerData.push(this.generateUnsupportedApplicationSettingMarker(setting));
+			} else if (isEqual(this.userDataProfileService.currentProfile.settingsResource, this.settingsEditorModel.uri)) {
+				if (configuration.scope === ConfigurationScope.APPLICATION) {
+					// If we're in a profile setting file, and the setting is application-scoped, fade it out.
+					markerData.push(this.generateUnsupportedApplicationSettingMarker(setting));
+				} else if (this.configurationService.isSettingAppliedForAllProfiles(setting.key)) {
+					// If we're in the non-default profile setting file, and the setting can be applied in all profiles, fade it out.
+					markerData.push({
+						severity: MarkerSeverity.Hint,
+						tags: [MarkerTag.Unnecessary],
+						...setting.range,
+						message: nls.localize('allProfileSettingWhileInNonDefaultProfileSetting', "This setting cannot be applied because it is configured to be applied in all profiles using setting {0}. Value from the default profile will be used instead.", APPLY_ALL_PROFILES_SETTING)
+					});
+				}
 			}
 		}
 		if (this.environmentService.remoteAuthority && (configuration.scope === ConfigurationScope.MACHINE || configuration.scope === ConfigurationScope.MACHINE_OVERRIDABLE)) {

src/vs/workbench/contrib/preferences/browser/settingsEditorSettingIndicators.ts

@@ -15,11 +15,12 @@ import { IDisposable, DisposableStore } from 'vs/base/common/lifecycle';
 import { ILanguageService } from 'vs/editor/common/languages/language';
 import { localize } from 'vs/nls';
 import { ICommandService } from 'vs/platform/commands/common/commands';
-import { ConfigurationTarget, IConfigurationService } from 'vs/platform/configuration/common/configuration';
+import { ConfigurationTarget } from 'vs/platform/configuration/common/configuration';
 import { IUserDataProfilesService } from 'vs/platform/userDataProfile/common/userDataProfile';
 import { IUserDataSyncEnablementService } from 'vs/platform/userDataSync/common/userDataSync';
 import { SettingsTreeSettingElement } from 'vs/workbench/contrib/preferences/browser/settingsTreeModels';
 import { POLICY_SETTING_TAG } from 'vs/workbench/contrib/preferences/common/preferences';
+import { IWorkbenchConfigurationService } from 'vs/workbench/services/configuration/common/configuration';
 import { IHoverOptions, IHoverService, IHoverWidget } from 'vs/workbench/services/hover/browser/hover';
 
 const $ = DOM.$;
@@ -75,7 +76,7 @@ export class SettingsTreeIndicatorsLabel implements IDisposable {
 
 	constructor(
 		container: HTMLElement,
-		@IConfigurationService private readonly configurationService: IConfigurationService,
+		@IWorkbenchConfigurationService private readonly configurationService: IWorkbenchConfigurationService,
 		@IHoverService private readonly hoverService: IHoverService,
 		@IUserDataSyncEnablementService private readonly userDataSyncEnablementService: IUserDataSyncEnablementService,
 		@ILanguageService private readonly languageService: ILanguageService,
@@ -330,14 +331,11 @@ export class SettingsTreeIndicatorsLabel implements IDisposable {
 				}, focus);
 			};
 			this.addHoverDisposables(this.scopeOverridesIndicator.disposables, this.scopeOverridesIndicator.element, showHover);
-		} else if (this.profilesEnabled && element.matchesScope(ConfigurationTarget.APPLICATION, false)) {
-			// If the setting is an application-scoped setting, there are no overrides so we can use this
-			// indicator to display that information instead.
+		} else if (this.profilesEnabled && element.settingsTarget === ConfigurationTarget.USER_LOCAL && this.configurationService.isSettingAppliedForAllProfiles(element.setting.key)) {
 			this.scopeOverridesIndicator.element.style.display = 'inline';
 			this.scopeOverridesIndicator.element.classList.add('setting-indicator');
 
-			const applicationSettingText = localize('applicationSetting', "Applies to all profiles");
-			this.scopeOverridesIndicator.label.text = applicationSettingText;
+			this.scopeOverridesIndicator.label.text = localize('applicationSetting', "Applies to all profiles");
 
 			const content = localize('applicationSettingDescription', "The setting is not specific to the current profile, and will retain its value when switching profiles.");
 			const showHover = (focus: boolean) => {
@@ -499,18 +497,17 @@ function getAccessibleScopeDisplayMidSentenceText(completeScope: string, languag
 	return localizedScope;
 }
 
-export function getIndicatorsLabelAriaLabel(element: SettingsTreeSettingElement, configurationService: IConfigurationService, userDataProfilesService: IUserDataProfilesService, languageService: ILanguageService): string {
+export function getIndicatorsLabelAriaLabel(element: SettingsTreeSettingElement, configurationService: IWorkbenchConfigurationService, userDataProfilesService: IUserDataProfilesService, languageService: ILanguageService): string {
 	const ariaLabelSections: string[] = [];
 
 	// Add workspace trust text
 	if (element.isUntrusted) {
 		ariaLabelSections.push(localize('workspaceUntrustedAriaLabel', "Workspace untrusted; setting value not applied"));
 	}
 
-	const profilesEnabled = userDataProfilesService.isEnabled();
 	if (element.hasPolicyValue) {
 		ariaLabelSections.push(localize('policyDescriptionAccessible', "Managed by organization policy; setting value not applied"));
-	} else if (profilesEnabled && element.matchesScope(ConfigurationTarget.APPLICATION, false)) {
+	} else if (userDataProfilesService.isEnabled() && element.settingsTarget === ConfigurationTarget.USER_LOCAL && configurationService.isSettingAppliedForAllProfiles(element.setting.key)) {
 		ariaLabelSections.push(localize('applicationSettingDescriptionAccessible', "Setting value retained when switching profiles"));
 	} else {
 		// Add other overrides text