@codingame/monaco-vscode-api 4.5.2 → 5.0.0

package/vscode/src/vs/platform/actions/browser/toolbar.d.ts

@@ -2,6 +2,7 @@ import { ToolBar, IToolBarOptions } from '../../../base/browser/ui/toolbar/toolb
 import { IAction } from '../../../base/common/actions.js';
 import { MenuId, IMenuActionOptions } from '../common/actions.js';
 import { IMenuService } from '../common/actions.service.js';
+import { ICommandService } from '../../commands/common/commands.service.js';
 import { IContextKeyService } from '../../contextkey/common/contextkey.service.js';
 import { IContextMenuService } from '../../contextview/browser/contextView.service.js';
 import { IKeybindingService } from '../../keybinding/common/keybinding.service.js';
@@ -65,8 +66,10 @@ declare class WorkbenchToolBar extends ToolBar {
     private readonly _menuService;
     private readonly _contextKeyService;
     private readonly _contextMenuService;
+    private readonly _keybindingService;
+    private readonly _commandService;
     private readonly _sessionDisposables;
-    constructor(container: HTMLElement, _options: IWorkbenchToolBarOptions | undefined, _menuService: IMenuService, _contextKeyService: IContextKeyService, _contextMenuService: IContextMenuService, keybindingService: IKeybindingService, telemetryService: ITelemetryService);
+    constructor(container: HTMLElement, _options: IWorkbenchToolBarOptions | undefined, _menuService: IMenuService, _contextKeyService: IContextKeyService, _contextMenuService: IContextMenuService, _keybindingService: IKeybindingService, _commandService: ICommandService, telemetryService: ITelemetryService);
     setActions(_primary: readonly IAction[], _secondary?: readonly IAction[], menuIds?: readonly MenuId[]): void;
 }
 

package/vscode/src/vs/platform/actions/browser/toolbar.js

@@ -1,7 +1,7 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { addDisposableListener, getWindow } from '../../../base/browser/dom.js';
 import { StandardMouseEvent } from '../../../base/browser/mouseEvent.js';
-import { ToolBar } from '../../../base/browser/ui/toolbar/toolbar.js';
+import { ToolBar, ToggleMenuAction } from '../../../base/browser/ui/toolbar/toolbar.js';
 import { Separator, toAction } from '../../../base/common/actions.js';
 import { coalesceInPlace } from '../../../base/common/arrays.js';
 import { intersection } from '../../../base/common/collections.js';
@@ -13,15 +13,17 @@ import { localizeWithPath } from '../../../nls.js';
 import { createAndFillInActionBarActions } from './menuEntryActionViewItem.js';
 import { MenuItemAction, SubmenuItemAction } from '../common/actions.js';
 import { IMenuService } from '../common/actions.service.js';
+import { createConfigureKeybindingAction } from '../common/menuService.js';
+import { ICommandService } from '../../commands/common/commands.service.js';
 import { IContextKeyService } from '../../contextkey/common/contextkey.service.js';
 import { IContextMenuService } from '../../contextview/browser/contextView.service.js';
 import { IKeybindingService } from '../../keybinding/common/keybinding.service.js';
 import { ITelemetryService } from '../../telemetry/common/telemetry.service.js';
 const _moduleId = "vs/platform/actions/browser/toolbar";
 let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
-    constructor(container, _options, _menuService, _contextKeyService, _contextMenuService, keybindingService, telemetryService) {
+    constructor(container, _options, _menuService, _contextKeyService, _contextMenuService, _keybindingService, _commandService, telemetryService) {
         super(container, _contextMenuService, {
-            getKeyBinding: (action) => keybindingService.lookupKeybinding(action.id) ?? undefined,
+            getKeyBinding: (action) => _keybindingService.lookupKeybinding(action.id) ?? undefined,
             ..._options,
             allowContextMenu: true,
             skipTelemetry: typeof _options?.telemetrySource === 'string',
@@ -30,6 +32,8 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
         this._menuService = _menuService;
         this._contextKeyService = _contextKeyService;
         this._contextMenuService = _contextMenuService;
+        this._keybindingService = _keybindingService;
+        this._commandService = _commandService;
         this._sessionDisposables = this._store.add(( (new DisposableStore())));
         const telemetrySource = _options?.telemetrySource;
         if (telemetrySource) {
@@ -88,7 +92,7 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
         coalesceInPlace(primary);
         coalesceInPlace(extraSecondary);
         super.setActions(primary, Separator.join(extraSecondary, secondary));
-        if (toggleActions.length > 0) {
+        if (toggleActions.length > 0 || primary.length > 0) {
             this._sessionDisposables.add(addDisposableListener(this.getElement(), 'contextmenu', e => {
                 const event = ( (new StandardMouseEvent(getWindow(this.getElement()), e)));
                 const action = this.getItemAction(event.target);
@@ -97,38 +101,46 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
                 }
                 event.preventDefault();
                 event.stopPropagation();
-                let noHide = false;
-                if (toggleActionsCheckedCount === 1 && this._options?.hiddenItemStrategy === 0 ) {
-                    noHide = true;
-                    for (let i = 0; i < toggleActions.length; i++) {
-                        if (toggleActions[i].checked) {
-                            toggleActions[i] = toAction({
-                                id: action.id,
-                                label: action.label,
-                                checked: true,
-                                enabled: false,
-                                run() { }
-                            });
-                            break;
+                const primaryActions = [];
+                if (action instanceof MenuItemAction && action.menuKeybinding) {
+                    primaryActions.push(action.menuKeybinding);
+                }
+                else if (!(action instanceof SubmenuItemAction || action instanceof ToggleMenuAction)) {
+                    primaryActions.push(createConfigureKeybindingAction(action.id, undefined, this._commandService, this._keybindingService));
+                }
+                if (toggleActions.length > 0) {
+                    let noHide = false;
+                    if (toggleActionsCheckedCount === 1 && this._options?.hiddenItemStrategy === 0 ) {
+                        noHide = true;
+                        for (let i = 0; i < toggleActions.length; i++) {
+                            if (toggleActions[i].checked) {
+                                toggleActions[i] = toAction({
+                                    id: action.id,
+                                    label: action.label,
+                                    checked: true,
+                                    enabled: false,
+                                    run() { }
+                                });
+                                break;
+                            }
                         }
                     }
-                }
-                let hideAction;
-                if (!noHide && (action instanceof MenuItemAction || action instanceof SubmenuItemAction)) {
-                    if (!action.hideActions) {
-                        return;
+                    if (!noHide && (action instanceof MenuItemAction || action instanceof SubmenuItemAction)) {
+                        if (!action.hideActions) {
+                            return;
+                        }
+                        primaryActions.push(action.hideActions.hide);
+                    }
+                    else {
+                        primaryActions.push(toAction({
+                            id: 'label',
+                            label: ( localizeWithPath(_moduleId, 0, "Hide")),
+                            enabled: false,
+                            run() { }
+                        }));
                     }
-                    hideAction = action.hideActions.hide;
-                }
-                else {
-                    hideAction = toAction({
-                        id: 'label',
-                        label: ( localizeWithPath(_moduleId, 0, "Hide")),
-                        enabled: false,
-                        run() { }
-                    });
                 }
-                const actions = Separator.join([hideAction], toggleActions);
+                const actions = Separator.join(primaryActions, toggleActions);
                 if (this._options?.resetMenu && !menuIds) {
                     menuIds = [this._options.resetMenu];
                 }
@@ -140,6 +152,9 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
                         run: () => this._menuService.resetHiddenStates(menuIds)
                     }));
                 }
+                if (actions.length === 0) {
+                    return;
+                }
                 this._contextMenuService.showContextMenu({
                     getAnchor: () => event,
                     getActions: () => actions,
@@ -157,11 +172,12 @@ WorkbenchToolBar = ( (__decorate([
     ( (__param(3, IContextKeyService))),
     ( (__param(4, IContextMenuService))),
     ( (__param(5, IKeybindingService))),
-    ( (__param(6, ITelemetryService)))
+    ( (__param(6, ICommandService))),
+    ( (__param(7, ITelemetryService)))
 ], WorkbenchToolBar)));
 let MenuWorkbenchToolBar = class MenuWorkbenchToolBar extends WorkbenchToolBar {
-    constructor(container, menuId, options, menuService, contextKeyService, contextMenuService, keybindingService, telemetryService) {
-        super(container, { resetMenu: menuId, ...options }, menuService, contextKeyService, contextMenuService, keybindingService, telemetryService);
+    constructor(container, menuId, options, menuService, contextKeyService, contextMenuService, keybindingService, commandService, telemetryService) {
+        super(container, { resetMenu: menuId, ...options }, menuService, contextKeyService, contextMenuService, keybindingService, commandService, telemetryService);
         this._onDidChangeMenuItems = this._store.add(( (new Emitter())));
         this.onDidChangeMenuItems = this._onDidChangeMenuItems.event;
         const menu = this._store.add(menuService.createMenu(menuId, contextKeyService, { emitEventsForSubmenuChanges: true }));
@@ -187,6 +203,7 @@ MenuWorkbenchToolBar = ( (__decorate([
     ( (__param(4, IContextKeyService))),
     ( (__param(5, IContextMenuService))),
     ( (__param(6, IKeybindingService))),
-    ( (__param(7, ITelemetryService)))
+    ( (__param(7, ICommandService))),
+    ( (__param(8, ITelemetryService)))
 ], MenuWorkbenchToolBar)));
 export { MenuWorkbenchToolBar, WorkbenchToolBar };

package/vscode/src/vs/platform/actions/common/actions.d.ts

@@ -195,6 +195,7 @@ declare class MenuId {
     static readonly InlineEditToolbar: MenuId;
     static readonly ChatContext: MenuId;
     static readonly ChatCodeBlock: MenuId;
+    static readonly ChatCompareBlock: MenuId;
     static readonly ChatMessageTitle: MenuId;
     static readonly ChatExecute: MenuId;
     static readonly ChatExecuteSecondary: MenuId;
@@ -270,6 +271,7 @@ interface IMenuItemHide {
 }
 declare class MenuItemAction implements IAction {
     readonly hideActions: IMenuItemHide | undefined;
+    readonly menuKeybinding: IAction | undefined;
     private _commandService;
     static label(action: ICommandAction, options?: IMenuActionOptions): string;
     readonly item: ICommandAction;
@@ -281,7 +283,7 @@ declare class MenuItemAction implements IAction {
     readonly class: string | undefined;
     readonly enabled: boolean;
     readonly checked?: boolean;
-    constructor(item: ICommandAction, alt: ICommandAction | undefined, options: IMenuActionOptions | undefined, hideActions: IMenuItemHide | undefined, contextKeyService: IContextKeyService, _commandService: ICommandService);
+    constructor(item: ICommandAction, alt: ICommandAction | undefined, options: IMenuActionOptions | undefined, hideActions: IMenuItemHide | undefined, menuKeybinding: IAction | undefined, contextKeyService: IContextKeyService, _commandService: ICommandService);
     run(...args: any[]): Promise<void>;
 }
 

package/vscode/src/vs/platform/actions/common/actions.js

@@ -187,6 +187,7 @@ class MenuId {
     static { this.InlineEditToolbar = ( new MenuId('InlineEditToolbar')); }
     static { this.ChatContext = ( new MenuId('ChatContext')); }
     static { this.ChatCodeBlock = ( new MenuId('ChatCodeblock')); }
+    static { this.ChatCompareBlock = ( new MenuId('ChatCompareBlock')); }
     static { this.ChatMessageTitle = ( new MenuId('ChatMessageTitle')); }
     static { this.ChatExecute = ( new MenuId('ChatExecute')); }
     static { this.ChatExecuteSecondary = ( new MenuId('ChatExecuteSecondary')); }
@@ -321,8 +322,9 @@ let MenuItemAction = MenuItemAction_1 = class MenuItemAction {
             ? (typeof action.shortTitle === 'string' ? action.shortTitle : action.shortTitle.value)
             : (typeof action.title === 'string' ? action.title : action.title.value);
     }
-    constructor(item, alt, options, hideActions, contextKeyService, _commandService) {
+    constructor(item, alt, options, hideActions, menuKeybinding, contextKeyService, _commandService) {
         this.hideActions = hideActions;
+        this.menuKeybinding = menuKeybinding;
         this._commandService = _commandService;
         this.id = item.id;
         this.label = MenuItemAction_1.label(item, options);
@@ -347,7 +349,15 @@ let MenuItemAction = MenuItemAction_1 = class MenuItemAction {
             icon = ThemeIcon.isThemeIcon(item.icon) ? item.icon : undefined;
         }
         this.item = item;
-        this.alt = alt ? ( new MenuItemAction_1(alt, undefined, options, hideActions, contextKeyService, _commandService)) : undefined;
+        this.alt = alt ? ( new MenuItemAction_1(
+            alt,
+            undefined,
+            options,
+            hideActions,
+            undefined,
+            contextKeyService,
+            _commandService
+        )) : undefined;
         this._options = options;
         this.class = icon && ThemeIcon.asClassName(icon);
     }
@@ -363,8 +373,8 @@ let MenuItemAction = MenuItemAction_1 = class MenuItemAction {
     }
 };
 MenuItemAction = MenuItemAction_1 = ( __decorate([
-    ( __param(4, IContextKeyService)),
-    ( __param(5, ICommandService))
+    ( __param(5, IContextKeyService)),
+    ( __param(6, ICommandService))
 ], MenuItemAction));
 class Action2 {
     constructor(desc) {

package/vscode/src/vs/platform/actions/common/menuService.js

@@ -5,15 +5,17 @@ import { DisposableStore } from '../../../base/common/lifecycle.js';
 import { MenuRegistry, isIMenuItem, MenuItemAction, SubmenuItemAction, isISubmenuItem } from './actions.js';
 import { ICommandService } from '../../commands/common/commands.service.js';
 import { IContextKeyService } from '../../contextkey/common/contextkey.service.js';
-import { Separator, toAction } from '../../../base/common/actions.js';
+import { toAction, Separator } from '../../../base/common/actions.js';
 import { IStorageService } from '../../storage/common/storage.service.js';
 import { removeFastWithoutKeepingOrder } from '../../../base/common/arrays.js';
 import { localizeWithPath } from '../../../nls.js';
+import { IKeybindingService } from '../../keybinding/common/keybinding.service.js';
 var PersistedMenuHideState_1, MenuInfo_1;
 const _moduleId = "vs/platform/actions/common/menuService";
 let MenuService = class MenuService {
-    constructor(_commandService, storageService) {
+    constructor(_commandService, _keybindingService, storageService) {
         this._commandService = _commandService;
+        this._keybindingService = _keybindingService;
         this._hiddenStates = ( (new PersistedMenuHideState(storageService)));
     }
     createMenu(id, contextKeyService, options) {
@@ -23,6 +25,7 @@ let MenuService = class MenuService {
                 this._hiddenStates,
                 { emitEventsForSubmenuChanges: false, eventDebounceDelay: 50, ...options },
                 this._commandService,
+                this._keybindingService,
                 contextKeyService
             ))
         );
@@ -33,7 +36,8 @@ let MenuService = class MenuService {
 };
 MenuService = ( (__decorate([
     ( (__param(0, ICommandService))),
-    ( (__param(1, IStorageService)))
+    ( (__param(1, IKeybindingService))),
+    ( (__param(2, IStorageService)))
 ], MenuService)));
 let PersistedMenuHideState = class PersistedMenuHideState {
     static { PersistedMenuHideState_1 = this; }
@@ -139,11 +143,12 @@ PersistedMenuHideState = PersistedMenuHideState_1 = ( (__decorate([
     ( (__param(0, IStorageService)))
 ], PersistedMenuHideState)));
 let MenuInfo = MenuInfo_1 = class MenuInfo {
-    constructor(_id, _hiddenStates, _collectContextKeysForSubmenus, _commandService, _contextKeyService) {
+    constructor(_id, _hiddenStates, _collectContextKeysForSubmenus, _commandService, _keybindingService, _contextKeyService) {
         this._id = _id;
         this._hiddenStates = _hiddenStates;
         this._collectContextKeysForSubmenus = _collectContextKeysForSubmenus;
         this._commandService = _commandService;
+        this._keybindingService = _keybindingService;
         this._contextKeyService = _contextKeyService;
         this._menuGroups = [];
         this._structureContextKeys = ( (new Set()));
@@ -206,11 +211,13 @@ let MenuInfo = MenuInfo_1 = class MenuInfo {
                     }
                     const menuHide = createMenuHide(this._id, isMenuItem ? item.command : item, this._hiddenStates);
                     if (isMenuItem) {
+                        const menuKeybinding = createConfigureKeybindingAction(item.command.id, item.when, this._commandService, this._keybindingService);
                         activeActions.push(( (new MenuItemAction(
                             item.command,
                             item.alt,
                             options,
                             menuHide,
+                            menuKeybinding,
                             this._contextKeyService,
                             this._commandService
                         ))));
@@ -221,6 +228,7 @@ let MenuInfo = MenuInfo_1 = class MenuInfo {
                             this._hiddenStates,
                             this._collectContextKeysForSubmenus,
                             this._commandService,
+                            this._keybindingService,
                             this._contextKeyService
                         ))).createActionGroups(options);
                         const submenuActions = Separator.join(...( (groups.map(g => g[1]))));
@@ -282,16 +290,18 @@ let MenuInfo = MenuInfo_1 = class MenuInfo {
 };
 MenuInfo = MenuInfo_1 = ( (__decorate([
     ( (__param(3, ICommandService))),
-    ( (__param(4, IContextKeyService)))
+    ( (__param(4, IKeybindingService))),
+    ( (__param(5, IContextKeyService)))
 ], MenuInfo)));
 let MenuImpl = class MenuImpl {
-    constructor(id, hiddenStates, options, commandService, contextKeyService) {
+    constructor(id, hiddenStates, options, commandService, keybindingService, contextKeyService) {
         this._disposables = ( (new DisposableStore()));
         this._menuInfo = ( (new MenuInfo(
             id,
             hiddenStates,
             options.emitEventsForSubmenuChanges,
             commandService,
+            keybindingService,
             contextKeyService
         )));
         const rebuildMenuSoon = ( (new RunOnceScheduler(() => {
@@ -350,7 +360,8 @@ let MenuImpl = class MenuImpl {
 };
 MenuImpl = ( (__decorate([
     ( (__param(3, ICommandService))),
-    ( (__param(4, IContextKeyService)))
+    ( (__param(4, IKeybindingService))),
+    ( (__param(5, IContextKeyService)))
 ], MenuImpl)));
 function createMenuHide(menu, command, states) {
     const id = isISubmenuItem(command) ? command.submenu.id : command.id;
@@ -372,4 +383,15 @@ function createMenuHide(menu, command, states) {
         get isHidden() { return !toggle.checked; },
     };
 }
-export { MenuService };
+function createConfigureKeybindingAction(commandId, when = undefined, commandService, keybindingService) {
+    return toAction({
+        id: `configureKeybinding/${commandId}`,
+        label: ( localizeWithPath(_moduleId, 1, "Configure Keybinding")),
+        run() {
+            const hasKeybinding = !!keybindingService.lookupKeybinding(commandId);
+            const whenValue = !hasKeybinding && when ? when.serialize() : undefined;
+            commandService.executeCommand('workbench.action.openGlobalKeybindings', `@command:${commandId}` + (whenValue ? ` +when:${whenValue}` : ''));
+        }
+    });
+}
+export { MenuService, createConfigureKeybindingAction };

package/vscode/src/vs/platform/configuration/common/configuration.js

@@ -51,6 +51,10 @@ function addToValueTree(settingsTreeRoot, key, value, conflictReporter) {
                 obj = curr[s] = Object.create(null);
                 break;
             case 'object':
+                if (obj === null) {
+                    conflictReporter(`Ignoring ${key} as ${segments.slice(0, i + 1).join('.')} is null`);
+                    return;
+                }
                 break;
             default:
                 conflictReporter(`Ignoring ${key} as ${segments.slice(0, i + 1).join('.')} is ${JSON.stringify(obj)}`);

package/vscode/src/vs/platform/configuration/common/configurationModels.js

@@ -13,11 +13,15 @@ function freeze(data) {
     return Object.isFrozen(data) ? data : deepFreeze(data);
 }
 class ConfigurationModel {
-    constructor(_contents = {}, _keys = [], _overrides = [], raw) {
+    static createEmptyModel(logService) {
+        return ( new ConfigurationModel({}, [], [], undefined, logService));
+    }
+    constructor(_contents, _keys, _overrides, raw, logService) {
         this._contents = _contents;
         this._keys = _keys;
         this._overrides = _overrides;
         this.raw = raw;
+        this.logService = logService;
         this.overrideConfigurations = ( new Map());
     }
     get rawConfiguration() {
@@ -27,7 +31,7 @@ class ConfigurationModel {
                     if (raw instanceof ConfigurationModel) {
                         return raw;
                     }
-                    const parser = ( new ConfigurationModelParser(''));
+                    const parser = ( new ConfigurationModelParser('', this.logService));
                     parser.parseRaw(raw);
                     return parser.configurationModel;
                 }));
@@ -69,7 +73,7 @@ class ConfigurationModel {
             get overrides() {
                 const overrides = [];
                 for (const { contents, identifiers, keys } of that.rawConfiguration.overrides) {
-                    const value = ( new ConfigurationModel(contents, keys)).getValue(section);
+                    const value = ( new ConfigurationModel(contents, keys, [], undefined, that.logService)).getValue(section);
                     if (value !== undefined) {
                         overrides.push({ identifiers, value });
                     }
@@ -140,7 +144,8 @@ class ConfigurationModel {
             contents,
             keys,
             overrides,
-            raws.every(raw => raw instanceof ConfigurationModel) ? undefined : raws
+            raws.every(raw => raw instanceof ConfigurationModel) ? undefined : raws,
+            this.logService
         ));
     }
     createOverrideConfigurationModel(identifier) {
@@ -163,7 +168,7 @@ class ConfigurationModel {
             }
             contents[key] = contentsForKey;
         }
-        return ( new ConfigurationModel(contents, this.keys, this.overrides));
+        return ( new ConfigurationModel(contents, this.keys, this.overrides, undefined, this.logService));
     }
     mergeContents(source, target) {
         for (const key of ( Object.keys(target))) {
@@ -225,7 +230,7 @@ class ConfigurationModel {
         }
     }
     updateValue(key, value, add) {
-        addToValueTree(this.contents, key, value, e => console.error(e));
+        addToValueTree(this.contents, key, value, e => this.logService.error(e));
         add = add || this.keys.indexOf(key) === -1;
         if (add) {
             this.keys.push(key);
@@ -234,21 +239,22 @@ class ConfigurationModel {
             this.overrides.push({
                 identifiers: overrideIdentifiersFromKey(key),
                 keys: ( Object.keys(this.contents[key])),
-                contents: toValuesTree(this.contents[key], message => console.error(message)),
+                contents: toValuesTree(this.contents[key], message => this.logService.error(message)),
             });
         }
     }
 }
 class ConfigurationModelParser {
-    constructor(_name) {
+    constructor(_name, logService) {
         this._name = _name;
+        this.logService = logService;
         this._raw = null;
         this._configurationModel = null;
         this._restrictedConfigurations = [];
         this._parseErrors = [];
     }
     get configurationModel() {
-        return this._configurationModel || ( new ConfigurationModel());
+        return this._configurationModel || ConfigurationModel.createEmptyModel(this.logService);
     }
     get restrictedConfigurations() {
         return this._restrictedConfigurations;
@@ -274,7 +280,8 @@ class ConfigurationModelParser {
             contents,
             keys,
             overrides,
-            hasExcludedProperties ? [raw] : undefined
+            hasExcludedProperties ? [raw] : undefined ,
+            this.logService
         ));
         this._restrictedConfigurations = restricted || [];
     }
@@ -325,7 +332,7 @@ class ConfigurationModelParser {
                 raw = currentParent[0] || {};
             }
             catch (e) {
-                console.error(`Error while parsing settings file ${this._name}: ${e}`);
+                this.logService.error(`Error while parsing settings file ${this._name}: ${e}`);
                 this._parseErrors = [e];
             }
         }
@@ -335,9 +342,9 @@ class ConfigurationModelParser {
         const configurationProperties = ( Registry.as(Extensions.Configuration)).getConfigurationProperties();
         const filtered = this.filter(raw, configurationProperties, true, options);
         raw = filtered.raw;
-        const contents = toValuesTree(raw, message => console.error(`Conflict in settings file ${this._name}: ${message}`));
+        const contents = toValuesTree(raw, message => this.logService.error(`Conflict in settings file ${this._name}: ${message}`));
         const keys = ( Object.keys(raw));
-        const overrides = this.toOverrides(raw, message => console.error(`Conflict in settings file ${this._name}: ${message}`));
+        const overrides = this.toOverrides(raw, message => this.logService.error(`Conflict in settings file ${this._name}: ${message}`));
         return { contents, keys, overrides, restricted: filtered.restricted, hasExcludedProperties: filtered.hasExcludedProperties };
     }
     filter(properties, configurationProperties, filterOverriddenProperties, options) {
@@ -392,14 +399,15 @@ class ConfigurationModelParser {
     }
 }
 class UserSettings extends Disposable {
-    constructor(userSettingsResource, parseOptions, extUri, fileService) {
+    constructor(userSettingsResource, parseOptions, extUri, fileService, logService) {
         super();
         this.userSettingsResource = userSettingsResource;
         this.parseOptions = parseOptions;
         this.fileService = fileService;
+        this.logService = logService;
         this._onDidChange = this._register(( new Emitter()));
         this.onDidChange = this._onDidChange.event;
-        this.parser = ( new ConfigurationModelParser(( this.userSettingsResource.toString())));
+        this.parser = ( new ConfigurationModelParser(( this.userSettingsResource.toString()), logService));
         this._register(this.fileService.watch(extUri.dirname(this.userSettingsResource)));
         this._register(this.fileService.watch(this.userSettingsResource));
         this._register(Event.any(Event.filter(this.fileService.onDidFilesChange, e => e.contains(this.userSettingsResource)), Event.filter(this.fileService.onDidRunOperation, e => (e.isOperation(0 ) || e.isOperation(3 ) || e.isOperation(1 ) || e.isOperation(4 )) && extUri.isEqual(e.resource, userSettingsResource)))(() => this._onDidChange.fire()));
@@ -411,7 +419,7 @@ class UserSettings extends Disposable {
             return this.parser.configurationModel;
         }
         catch (e) {
-            return ( new ConfigurationModel());
+            return ConfigurationModel.createEmptyModel(this.logService);
         }
     }
     reparse(parseOptions) {
@@ -557,7 +565,7 @@ class ConfigurationInspectValue {
     }
 }
 let Configuration$1 = class Configuration {
-    constructor(_defaultConfiguration, _policyConfiguration, _applicationConfiguration, _localUserConfiguration, _remoteUserConfiguration = ( new ConfigurationModel()), _workspaceConfiguration = ( new ConfigurationModel()), _folderConfigurations = ( new ResourceMap()), _memoryConfiguration = ( new ConfigurationModel()), _memoryConfigurationByResource = ( new ResourceMap())) {
+    constructor(_defaultConfiguration, _policyConfiguration, _applicationConfiguration, _localUserConfiguration, _remoteUserConfiguration, _workspaceConfiguration, _folderConfigurations, _memoryConfiguration, _memoryConfigurationByResource, logService) {
         this._defaultConfiguration = _defaultConfiguration;
         this._policyConfiguration = _policyConfiguration;
         this._applicationConfiguration = _applicationConfiguration;
@@ -567,6 +575,7 @@ let Configuration$1 = class Configuration {
         this._folderConfigurations = _folderConfigurations;
         this._memoryConfiguration = _memoryConfiguration;
         this._memoryConfigurationByResource = _memoryConfigurationByResource;
+        this.logService = logService;
         this._workspaceConsolidatedConfiguration = null;
         this._foldersConsolidatedConfigurations = ( new ResourceMap());
         this._userConfiguration = null;
@@ -580,7 +589,7 @@ let Configuration$1 = class Configuration {
         if (overrides.resource) {
             memoryConfiguration = this._memoryConfigurationByResource.get(overrides.resource);
             if (!memoryConfiguration) {
-                memoryConfiguration = ( new ConfigurationModel());
+                memoryConfiguration = ConfigurationModel.createEmptyModel(this.logService);
                 this._memoryConfigurationByResource.set(overrides.resource, memoryConfiguration);
             }
         }
@@ -887,14 +896,14 @@ let Configuration$1 = class Configuration {
         this._folderConfigurations.forEach(folderConfiguration => folderConfiguration.getKeysForOverrideIdentifier(overrideIdentifier).forEach(key => keys.add(key)));
         return [...( keys.values())];
     }
-    static parse(data) {
-        const defaultConfiguration = this.parseConfigurationModel(data.defaults);
-        const policyConfiguration = this.parseConfigurationModel(data.policy);
-        const applicationConfiguration = this.parseConfigurationModel(data.application);
-        const userConfiguration = this.parseConfigurationModel(data.user);
-        const workspaceConfiguration = this.parseConfigurationModel(data.workspace);
+    static parse(data, logService) {
+        const defaultConfiguration = this.parseConfigurationModel(data.defaults, logService);
+        const policyConfiguration = this.parseConfigurationModel(data.policy, logService);
+        const applicationConfiguration = this.parseConfigurationModel(data.application, logService);
+        const userConfiguration = this.parseConfigurationModel(data.user, logService);
+        const workspaceConfiguration = this.parseConfigurationModel(data.workspace, logService);
         const folders = data.folders.reduce((result, value) => {
-            result.set(URI.revive(value[0]), this.parseConfigurationModel(value[1]));
+            result.set(URI.revive(value[0]), this.parseConfigurationModel(value[1], logService));
             return result;
         }, ( new ResourceMap()));
         return ( new Configuration(
@@ -902,15 +911,16 @@ let Configuration$1 = class Configuration {
             policyConfiguration,
             applicationConfiguration,
             userConfiguration,
-            ( new ConfigurationModel()),
+            ConfigurationModel.createEmptyModel(logService),
             workspaceConfiguration,
             folders,
-            ( new ConfigurationModel()),
-            ( new ResourceMap())
+            ConfigurationModel.createEmptyModel(logService),
+            ( new ResourceMap()),
+            logService
         ));
     }
-    static parseConfigurationModel(model) {
-        return ( new ConfigurationModel(model.contents, model.keys, model.overrides));
+    static parseConfigurationModel(model, logService) {
+        return ( new ConfigurationModel(model.contents, model.keys, model.overrides, undefined, logService));
     }
 };
 function mergeChanges(...changes) {
@@ -934,11 +944,12 @@ function mergeChanges(...changes) {
     return { keys: [...( keysSet.values())], overrides };
 }
 class ConfigurationChangeEvent {
-    constructor(change, previous, currentConfiguraiton, currentWorkspace) {
+    constructor(change, previous, currentConfiguraiton, currentWorkspace, logService) {
         this.change = change;
         this.previous = previous;
         this.currentConfiguraiton = currentConfiguraiton;
         this.currentWorkspace = currentWorkspace;
+        this.logService = logService;
         this._marker = '\n';
         this._markerCode1 = this._marker.charCodeAt(0);
         this._markerCode2 = '.'.charCodeAt(0);
@@ -959,7 +970,7 @@ class ConfigurationChangeEvent {
     }
     get previousConfiguration() {
         if (!this._previousConfiguration && this.previous) {
-            this._previousConfiguration = Configuration$1.parse(this.previous.data);
+            this._previousConfiguration = Configuration$1.parse(this.previous.data, this.logService);
         }
         return this._previousConfiguration;
     }