diff --git a/src/vs/editor/browser/services/abstractCodeEditorService.ts b/src/vs/editor/browser/services/abstractCodeEditorService.ts index bb96485db3e..2aeb0b21b42 100644 --- a/src/vs/editor/browser/services/abstractCodeEditorService.ts +++ b/src/vs/editor/browser/services/abstractCodeEditorService.ts @@ -9,7 +9,7 @@ import { ICodeEditor, IDiffEditor } from 'vs/editor/browser/editorBrowser'; import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService'; import { IDecorationRenderOptions } from 'vs/editor/common/editorCommon'; import { IModelDecorationOptions, ITextModel } from 'vs/editor/common/model'; -import { IResourceInput } from 'vs/platform/editor/common/editor'; +import { IResourceEditorInput } from 'vs/platform/editor/common/editor'; export abstract class AbstractCodeEditorService extends Disposable implements ICodeEditorService { @@ -135,7 +135,7 @@ export abstract class AbstractCodeEditorService extends Disposable implements IC } abstract getActiveCodeEditor(): ICodeEditor | null; - abstract openCodeEditor(input: IResourceInput, source: ICodeEditor | null, sideBySide?: boolean): Promise; + abstract openCodeEditor(input: IResourceEditorInput, source: ICodeEditor | null, sideBySide?: boolean): Promise; } export class ModelTransientSettingWatcher { diff --git a/src/vs/editor/browser/services/codeEditorService.ts b/src/vs/editor/browser/services/codeEditorService.ts index 145cb9d2641..c38fccad1ff 100644 --- a/src/vs/editor/browser/services/codeEditorService.ts +++ b/src/vs/editor/browser/services/codeEditorService.ts @@ -7,7 +7,7 @@ import { Event } from 'vs/base/common/event'; import { ICodeEditor, IDiffEditor } from 'vs/editor/browser/editorBrowser'; import { IDecorationRenderOptions } from 'vs/editor/common/editorCommon'; import { IModelDecorationOptions, ITextModel } from 'vs/editor/common/model'; -import { IResourceInput } from 'vs/platform/editor/common/editor'; +import { IResourceEditorInput } from 'vs/platform/editor/common/editor'; import { createDecorator } from 'vs/platform/instantiation/common/instantiation'; export const ICodeEditorService = createDecorator('codeEditorService'); @@ -46,5 +46,5 @@ export interface ICodeEditorService { getTransientModelProperties(model: ITextModel): [string, any][] | undefined; getActiveCodeEditor(): ICodeEditor | null; - openCodeEditor(input: IResourceInput, source: ICodeEditor | null, sideBySide?: boolean): Promise; + openCodeEditor(input: IResourceEditorInput, source: ICodeEditor | null, sideBySide?: boolean): Promise; } diff --git a/src/vs/editor/browser/services/codeEditorServiceImpl.ts b/src/vs/editor/browser/services/codeEditorServiceImpl.ts index bc59b17bb42..df62d99e484 100644 --- a/src/vs/editor/browser/services/codeEditorServiceImpl.ts +++ b/src/vs/editor/browser/services/codeEditorServiceImpl.ts @@ -11,7 +11,7 @@ import { ICodeEditor } from 'vs/editor/browser/editorBrowser'; import { AbstractCodeEditorService } from 'vs/editor/browser/services/abstractCodeEditorService'; import { IContentDecorationRenderOptions, IDecorationRenderOptions, IThemeDecorationRenderOptions, isThemeColor } from 'vs/editor/common/editorCommon'; import { IModelDecorationOptions, IModelDecorationOverviewRulerOptions, OverviewRulerLane, TrackedRangeStickiness } from 'vs/editor/common/model'; -import { IResourceInput } from 'vs/platform/editor/common/editor'; +import { IResourceEditorInput } from 'vs/platform/editor/common/editor'; import { IColorTheme, IThemeService, ThemeColor } from 'vs/platform/theme/common/themeService'; class RefCountedStyleSheet { @@ -136,7 +136,7 @@ export abstract class CodeEditorServiceImpl extends AbstractCodeEditorService { } abstract getActiveCodeEditor(): ICodeEditor | null; - abstract openCodeEditor(input: IResourceInput, source: ICodeEditor | null, sideBySide?: boolean): Promise; + abstract openCodeEditor(input: IResourceEditorInput, source: ICodeEditor | null, sideBySide?: boolean): Promise; } interface IModelDecorationOptionsProvider extends IDisposable { diff --git a/src/vs/editor/standalone/browser/standaloneCodeServiceImpl.ts b/src/vs/editor/standalone/browser/standaloneCodeServiceImpl.ts index c52be42a833..cd631b58008 100644 --- a/src/vs/editor/standalone/browser/standaloneCodeServiceImpl.ts +++ b/src/vs/editor/standalone/browser/standaloneCodeServiceImpl.ts @@ -11,7 +11,7 @@ import { CodeEditorServiceImpl } from 'vs/editor/browser/services/codeEditorServ import { IRange } from 'vs/editor/common/core/range'; import { ScrollType } from 'vs/editor/common/editorCommon'; import { ITextModel } from 'vs/editor/common/model'; -import { IResourceInput } from 'vs/platform/editor/common/editor'; +import { IResourceEditorInput } from 'vs/platform/editor/common/editor'; export class StandaloneCodeEditorServiceImpl extends CodeEditorServiceImpl { @@ -19,7 +19,7 @@ export class StandaloneCodeEditorServiceImpl extends CodeEditorServiceImpl { return null; // not supported in the standalone case } - public openCodeEditor(input: IResourceInput, source: ICodeEditor | null, sideBySide?: boolean): Promise { + public openCodeEditor(input: IResourceEditorInput, source: ICodeEditor | null, sideBySide?: boolean): Promise { if (!source) { return Promise.resolve(null); } @@ -27,7 +27,7 @@ export class StandaloneCodeEditorServiceImpl extends CodeEditorServiceImpl { return Promise.resolve(this.doOpenEditor(source, input)); } - private doOpenEditor(editor: ICodeEditor, input: IResourceInput): ICodeEditor | null { + private doOpenEditor(editor: ICodeEditor, input: IResourceEditorInput): ICodeEditor | null { const model = this.findModel(editor, input.resource); if (!model) { if (input.resource) { diff --git a/src/vs/editor/test/browser/editorTestServices.ts b/src/vs/editor/test/browser/editorTestServices.ts index f70b534d96e..747895a7a60 100644 --- a/src/vs/editor/test/browser/editorTestServices.ts +++ b/src/vs/editor/test/browser/editorTestServices.ts @@ -9,13 +9,13 @@ import { AbstractCodeEditorService } from 'vs/editor/browser/services/abstractCo import { IDecorationRenderOptions } from 'vs/editor/common/editorCommon'; import { IModelDecorationOptions } from 'vs/editor/common/model'; import { CommandsRegistry, ICommandEvent, ICommandService } from 'vs/platform/commands/common/commands'; -import { IResourceInput } from 'vs/platform/editor/common/editor'; +import { IResourceEditorInput } from 'vs/platform/editor/common/editor'; import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation'; export class TestCodeEditorService extends AbstractCodeEditorService { - public lastInput?: IResourceInput; + public lastInput?: IResourceEditorInput; public getActiveCodeEditor(): ICodeEditor | null { return null; } - public openCodeEditor(input: IResourceInput, source: ICodeEditor | null, sideBySide?: boolean): Promise { + public openCodeEditor(input: IResourceEditorInput, source: ICodeEditor | null, sideBySide?: boolean): Promise { this.lastInput = input; return Promise.resolve(null); } diff --git a/src/vs/editor/test/browser/services/decorationRenderOptions.test.ts b/src/vs/editor/test/browser/services/decorationRenderOptions.test.ts index c7aef9677fc..ea334d1070a 100644 --- a/src/vs/editor/test/browser/services/decorationRenderOptions.test.ts +++ b/src/vs/editor/test/browser/services/decorationRenderOptions.test.ts @@ -10,7 +10,7 @@ import { URI } from 'vs/base/common/uri'; import { ICodeEditor } from 'vs/editor/browser/editorBrowser'; import { CodeEditorServiceImpl } from 'vs/editor/browser/services/codeEditorServiceImpl'; import { IDecorationRenderOptions } from 'vs/editor/common/editorCommon'; -import { IResourceInput } from 'vs/platform/editor/common/editor'; +import { IResourceEditorInput } from 'vs/platform/editor/common/editor'; import { TestColorTheme, TestThemeService } from 'vs/platform/theme/test/common/testThemeService'; const themeServiceMock = new TestThemeService(); @@ -20,7 +20,7 @@ export class TestCodeEditorServiceImpl extends CodeEditorServiceImpl { return null; } - openCodeEditor(input: IResourceInput, source: ICodeEditor | null, sideBySide?: boolean): Promise { + openCodeEditor(input: IResourceEditorInput, source: ICodeEditor | null, sideBySide?: boolean): Promise { return Promise.resolve(null); } } diff --git a/src/vs/platform/editor/common/editor.ts b/src/vs/platform/editor/common/editor.ts index c973a6e3418..723ab723a32 100644 --- a/src/vs/platform/editor/common/editor.ts +++ b/src/vs/platform/editor/common/editor.ts @@ -24,7 +24,7 @@ export interface IEditorModel { dispose(): void; } -export interface IBaseResourceInput { +export interface IBaseResourceEditorInput { /** * Optional options to use when opening the text input. @@ -60,7 +60,7 @@ export interface IBaseResourceInput { readonly forceUntitled?: boolean; } -export interface IResourceInput extends IBaseResourceInput { +export interface IResourceEditorInput extends IBaseResourceEditorInput { /** * The resource URI of the resource to open. diff --git a/src/vs/workbench/api/browser/mainThreadEditors.ts b/src/vs/workbench/api/browser/mainThreadEditors.ts index 3b113a97783..a1f130d4c37 100644 --- a/src/vs/workbench/api/browser/mainThreadEditors.ts +++ b/src/vs/workbench/api/browser/mainThreadEditors.ts @@ -15,7 +15,7 @@ import { ISelection } from 'vs/editor/common/core/selection'; import { IDecorationOptions, IDecorationRenderOptions, ILineChange } from 'vs/editor/common/editorCommon'; import { ISingleEditOperation } from 'vs/editor/common/model'; import { CommandsRegistry } from 'vs/platform/commands/common/commands'; -import { IEditorOptions, ITextEditorOptions, IResourceInput, EditorActivation } from 'vs/platform/editor/common/editor'; +import { IEditorOptions, ITextEditorOptions, IResourceEditorInput, EditorActivation } from 'vs/platform/editor/common/editor'; import { ServicesAccessor } from 'vs/platform/instantiation/common/instantiation'; import { IOpenerService } from 'vs/platform/opener/common/opener'; import { MainThreadDocumentsAndEditors } from 'vs/workbench/api/browser/mainThreadDocumentsAndEditors'; @@ -124,7 +124,7 @@ export class MainThreadTextEditors implements MainThreadTextEditorsShape { activation: options.preserveFocus ? EditorActivation.RESTORE : undefined }; - const input: IResourceInput = { + const input: IResourceEditorInput = { resource: uri, options: editorOptions }; diff --git a/src/vs/workbench/browser/dnd.ts b/src/vs/workbench/browser/dnd.ts index 51561e66b49..4c54d359131 100644 --- a/src/vs/workbench/browser/dnd.ts +++ b/src/vs/workbench/browser/dnd.ts @@ -239,7 +239,7 @@ export class ResourcesDropHandler { // Untitled: always ensure that we open a new untitled editor for each file we drop if (droppedDirtyEditor.resource.scheme === Schemas.untitled) { - const untitledEditorResource = this.editorService.createInput({ mode: droppedDirtyEditor.mode, encoding: droppedDirtyEditor.encoding, forceUntitled: true }).resource; + const untitledEditorResource = this.editorService.createEditorInput({ mode: droppedDirtyEditor.mode, encoding: droppedDirtyEditor.encoding, forceUntitled: true }).resource; if (untitledEditorResource) { droppedDirtyEditor.resource = untitledEditorResource; } diff --git a/src/vs/workbench/browser/parts/editor/editor.contribution.ts b/src/vs/workbench/browser/parts/editor/editor.contribution.ts index 10f1f735dd4..f5fff985bed 100644 --- a/src/vs/workbench/browser/parts/editor/editor.contribution.ts +++ b/src/vs/workbench/browser/parts/editor/editor.contribution.ts @@ -163,7 +163,7 @@ class UntitledTextEditorInputFactory implements IEditorInputFactory { const mode = deserialized.modeId; const encoding = deserialized.encoding; - return accessor.get(IEditorService).createInput({ resource, mode, encoding, forceUntitled: true }) as UntitledTextEditorInput; + return accessor.get(IEditorService).createEditorInput({ resource, mode, encoding, forceUntitled: true }) as UntitledTextEditorInput; }); } } diff --git a/src/vs/workbench/browser/parts/editor/editor.ts b/src/vs/workbench/browser/parts/editor/editor.ts index 52a8f9ad63d..1884b133f67 100644 --- a/src/vs/workbench/browser/parts/editor/editor.ts +++ b/src/vs/workbench/browser/parts/editor/editor.ts @@ -160,5 +160,5 @@ export interface EditorServiceImpl extends IEditorService { /** * Override to return a typed `EditorInput`. */ - createInput(input: IResourceEditor): EditorInput; + createEditorInput(input: IResourceEditor): EditorInput; } diff --git a/src/vs/workbench/browser/parts/editor/editorActions.ts b/src/vs/workbench/browser/parts/editor/editorActions.ts index 3ee9b803659..26859c4ce0f 100644 --- a/src/vs/workbench/browser/parts/editor/editorActions.ts +++ b/src/vs/workbench/browser/parts/editor/editorActions.ts @@ -11,7 +11,7 @@ import { QuickOpenEntryGroup } from 'vs/base/parts/quickopen/browser/quickOpenMo import { EditorQuickOpenEntry, EditorQuickOpenEntryGroup, IEditorQuickOpenEntry, QuickOpenAction } from 'vs/workbench/browser/quickopen'; import { IQuickOpenService } from 'vs/platform/quickOpen/common/quickOpen'; import { IWorkbenchLayoutService } from 'vs/workbench/services/layout/browser/layoutService'; -import { IResourceInput } from 'vs/platform/editor/common/editor'; +import { IResourceEditorInput } from 'vs/platform/editor/common/editor'; import { IHistoryService } from 'vs/workbench/services/history/common/history'; import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding'; import { ICommandService } from 'vs/platform/commands/common/commands'; @@ -419,10 +419,10 @@ export class OpenToSideFromQuickOpenAction extends Action { return; } - const resourceInput = input as IResourceInput; - resourceInput.options = mixin(resourceInput.options, entry.getOptions()); + const resourceEditorInput = input as IResourceEditorInput; + resourceEditorInput.options = mixin(resourceEditorInput.options, entry.getOptions()); - await this.editorService.openEditor(resourceInput, SIDE_GROUP); + await this.editorService.openEditor(resourceEditorInput, SIDE_GROUP); } } } diff --git a/src/vs/workbench/browser/parts/editor/editorDropTarget.ts b/src/vs/workbench/browser/parts/editor/editorDropTarget.ts index bb51c1e0206..ff59b6c9916 100644 --- a/src/vs/workbench/browser/parts/editor/editorDropTarget.ts +++ b/src/vs/workbench/browser/parts/editor/editorDropTarget.ts @@ -308,7 +308,7 @@ class DropOverlay extends Themable { } // Open as untitled file with the provided contents - const untitledEditor = this.editorService.createInput({ + const untitledEditor = this.editorService.createEditorInput({ resource: proposedFilePath, forceUntitled: true, contents: VSBuffer.wrap(new Uint8Array(event.target.result)).toString() diff --git a/src/vs/workbench/browser/parts/editor/editorGroupView.ts b/src/vs/workbench/browser/parts/editor/editorGroupView.ts index 01c6df20c8a..26bde863ad3 100644 --- a/src/vs/workbench/browser/parts/editor/editorGroupView.ts +++ b/src/vs/workbench/browser/parts/editor/editorGroupView.ts @@ -255,7 +255,7 @@ export class EditorGroupView extends Themable implements IEditorGroupView { if (this.isEmpty) { EventHelper.stop(e); - this.openEditor(this.editorService.createInput({ forceUntitled: true }), EditorOptions.create({ pinned: true })); + this.openEditor(this.editorService.createEditorInput({ forceUntitled: true }), EditorOptions.create({ pinned: true })); } })); diff --git a/src/vs/workbench/browser/parts/editor/tabsTitleControl.ts b/src/vs/workbench/browser/parts/editor/tabsTitleControl.ts index 6fd0630ead8..feab641ad03 100644 --- a/src/vs/workbench/browser/parts/editor/tabsTitleControl.ts +++ b/src/vs/workbench/browser/parts/editor/tabsTitleControl.ts @@ -192,7 +192,7 @@ export class TabsTitleControl extends TitleControl { EventHelper.stop(e); - this.group.openEditor(this.editorService.createInput({ + this.group.openEditor(this.editorService.createEditorInput({ forceUntitled: true, options: { pinned: true, // untitled is always pinned diff --git a/src/vs/workbench/browser/parts/editor/textDiffEditor.ts b/src/vs/workbench/browser/parts/editor/textDiffEditor.ts index 912264d0659..23a1cecf42c 100644 --- a/src/vs/workbench/browser/parts/editor/textDiffEditor.ts +++ b/src/vs/workbench/browser/parts/editor/textDiffEditor.ts @@ -160,12 +160,12 @@ export class TextDiffEditor extends BaseTextEditor implements ITextDiffEditorPan const binaryDiffInput = new DiffEditorInput(input.getName(), input.getDescription(), originalInput, modifiedInput, true); // Forward binary flag to input if supported - const fileInputFactory = Registry.as(EditorInputExtensions.EditorInputFactories).getFileInputFactory(); - if (fileInputFactory.isFileInput(originalInput)) { + const fileEditorInputFactory = Registry.as(EditorInputExtensions.EditorInputFactories).getFileEditorInputFactory(); + if (fileEditorInputFactory.isFileEditorInput(originalInput)) { originalInput.setForceOpenAsBinary(); } - if (fileInputFactory.isFileInput(modifiedInput)) { + if (fileEditorInputFactory.isFileEditorInput(modifiedInput)) { modifiedInput.setForceOpenAsBinary(); } diff --git a/src/vs/workbench/browser/parts/quickopen/quickOpenController.ts b/src/vs/workbench/browser/parts/quickopen/quickOpenController.ts index 9c506768193..7f01f2145f0 100644 --- a/src/vs/workbench/browser/parts/quickopen/quickOpenController.ts +++ b/src/vs/workbench/browser/parts/quickopen/quickOpenController.ts @@ -18,7 +18,7 @@ import { QuickOpenWidget, HideReason } from 'vs/base/parts/quickopen/browser/qui import { ContributableActionProvider } from 'vs/workbench/browser/actions'; import { ITextFileService } from 'vs/workbench/services/textfile/common/textfiles'; import { Registry } from 'vs/platform/registry/common/platform'; -import { IResourceInput } from 'vs/platform/editor/common/editor'; +import { IResourceEditorInput } from 'vs/platform/editor/common/editor'; import { IModeService } from 'vs/editor/common/services/modeService'; import { getIconClasses } from 'vs/editor/common/services/getIconClasses'; import { IModelService } from 'vs/editor/common/services/modelService'; @@ -676,7 +676,7 @@ class EditorHistoryHandler { if (input instanceof EditorInput) { resource = resourceForEditorHistory(input, this.fileService); } else { - resource = (input as IResourceInput).resource; + resource = (input as IResourceEditorInput).resource; } return !!resource; @@ -722,14 +722,14 @@ export class EditorHistoryEntryGroup extends QuickOpenEntryGroup { } export class EditorHistoryEntry extends EditorQuickOpenEntry { - private input: IEditorInput | IResourceInput; + private input: IEditorInput | IResourceEditorInput; private resource: URI | undefined; private label: string; private description?: string; private icon: string; constructor( - input: IEditorInput | IResourceInput, + input: IEditorInput | IResourceEditorInput, @IEditorService editorService: IEditorService, @IModeService private readonly modeService: IModeService, @IModelService private readonly modelService: IModelService, @@ -749,15 +749,15 @@ export class EditorHistoryEntry extends EditorQuickOpenEntry { this.description = input.getDescription(); this.icon = this.getDirtyIndicatorForEditor(input); } else { - const resourceInput = input as IResourceInput; - this.resource = resourceInput.resource; - this.label = resources.basenameOrAuthority(resourceInput.resource); + const resourceEditorInput = input as IResourceEditorInput; + this.resource = resourceEditorInput.resource; + this.label = resources.basenameOrAuthority(resourceEditorInput.resource); this.description = labelService.getUriLabel(resources.dirname(this.resource), { relative: true }); - this.icon = this.getDirtyIndicatorForEditor(resourceInput); + this.icon = this.getDirtyIndicatorForEditor(resourceEditorInput); } } - private getDirtyIndicatorForEditor(input: EditorInput | IResourceInput): string { + private getDirtyIndicatorForEditor(input: EditorInput | IResourceEditorInput): string { let signalDirty = false; if (input instanceof EditorInput) { signalDirty = input.isDirty() && !input.isSaving(); @@ -794,7 +794,7 @@ export class EditorHistoryEntry extends EditorQuickOpenEntry { return this.resource; } - getInput(): IEditorInput | IResourceInput { + getInput(): IEditorInput | IResourceEditorInput { return this.input; } @@ -806,7 +806,7 @@ export class EditorHistoryEntry extends EditorQuickOpenEntry { if (this.input instanceof EditorInput) { this.editorService.openEditor(this.input, { pinned }, sideBySide ? SIDE_GROUP : ACTIVE_GROUP); } else { - this.editorService.openEditor({ resource: (this.input as IResourceInput).resource, options: { pinned } }, sideBySide ? SIDE_GROUP : ACTIVE_GROUP); + this.editorService.openEditor({ resource: (this.input as IResourceEditorInput).resource, options: { pinned } }, sideBySide ? SIDE_GROUP : ACTIVE_GROUP); } return true; @@ -847,7 +847,7 @@ export class RemoveFromEditorHistoryAction extends Action { async run(): Promise { interface IHistoryPickEntry extends IQuickPickItem { - input: IEditorInput | IResourceInput; + input: IEditorInput | IResourceEditorInput; } const history = this.historyService.getHistory(); diff --git a/src/vs/workbench/browser/quickopen.ts b/src/vs/workbench/browser/quickopen.ts index 2dda51f6ef2..82ee8ca9d46 100644 --- a/src/vs/workbench/browser/quickopen.ts +++ b/src/vs/workbench/browser/quickopen.ts @@ -13,7 +13,7 @@ import { Action } from 'vs/base/common/actions'; import { Mode, IEntryRunContext, IAutoFocus, IModel, IQuickNavigateConfiguration } from 'vs/base/parts/quickopen/common/quickOpen'; import { QuickOpenEntry, QuickOpenEntryGroup } from 'vs/base/parts/quickopen/browser/quickOpenModel'; import { EditorOptions, EditorInput, IEditorInput } from 'vs/workbench/common/editor'; -import { IResourceInput, IEditorOptions } from 'vs/platform/editor/common/editor'; +import { IResourceEditorInput, IEditorOptions } from 'vs/platform/editor/common/editor'; import { IQuickOpenService } from 'vs/platform/quickOpen/common/quickOpen'; import { IConstructorSignature0, IInstantiationService, BrandedService } from 'vs/platform/instantiation/common/instantiation'; import { IEditorService, SIDE_GROUP, ACTIVE_GROUP } from 'vs/workbench/services/editor/common/editorService'; @@ -233,7 +233,7 @@ export interface IEditorQuickOpenEntry { /** * The editor input used for this entry when opening. */ - getInput(): IResourceInput | IEditorInput | undefined; + getInput(): IResourceEditorInput | IEditorInput | undefined; /** * The editor options used for this entry when opening. @@ -254,7 +254,7 @@ export class EditorQuickOpenEntry extends QuickOpenEntry implements IEditorQuick return this._editorService; } - getInput(): IResourceInput | IEditorInput | undefined { + getInput(): IResourceEditorInput | IEditorInput | undefined { return undefined; } @@ -286,13 +286,13 @@ export class EditorQuickOpenEntry extends QuickOpenEntry implements IEditorQuick this.editorService.openEditor(input, withNullAsUndefined(opts), sideBySide ? SIDE_GROUP : ACTIVE_GROUP); } else { - const resourceInput = input; + const resourceEditorInput = input; if (openOptions) { - resourceInput.options = assign(resourceInput.options || Object.create(null), openOptions); + resourceEditorInput.options = assign(resourceEditorInput.options || Object.create(null), openOptions); } - this.editorService.openEditor(resourceInput, sideBySide ? SIDE_GROUP : ACTIVE_GROUP); + this.editorService.openEditor(resourceEditorInput, sideBySide ? SIDE_GROUP : ACTIVE_GROUP); } } @@ -305,7 +305,7 @@ export class EditorQuickOpenEntry extends QuickOpenEntry implements IEditorQuick */ export class EditorQuickOpenEntryGroup extends QuickOpenEntryGroup implements IEditorQuickOpenEntry { - getInput(): IEditorInput | IResourceInput | undefined { + getInput(): IEditorInput | IResourceEditorInput | undefined { return undefined; } diff --git a/src/vs/workbench/common/editor.ts b/src/vs/workbench/common/editor.ts index ddeae9f3fea..c80ee690158 100644 --- a/src/vs/workbench/common/editor.ts +++ b/src/vs/workbench/common/editor.ts @@ -10,7 +10,7 @@ import { withNullAsUndefined, assertIsDefined } from 'vs/base/common/types'; import { URI } from 'vs/base/common/uri'; import { IDisposable, Disposable, toDisposable } from 'vs/base/common/lifecycle'; import { IEditor, IEditorViewState, ScrollType, IDiffEditor } from 'vs/editor/common/editorCommon'; -import { IEditorModel, IEditorOptions, ITextEditorOptions, IBaseResourceInput, IResourceInput, EditorActivation, EditorOpenContext, ITextEditorSelection, TextEditorSelectionRevealType } from 'vs/platform/editor/common/editor'; +import { IEditorModel, IEditorOptions, ITextEditorOptions, IBaseResourceEditorInput, IResourceEditorInput, EditorActivation, EditorOpenContext, ITextEditorSelection, TextEditorSelectionRevealType } from 'vs/platform/editor/common/editor'; import { IInstantiationService, IConstructorSignature0, ServicesAccessor, BrandedService } from 'vs/platform/instantiation/common/instantiation'; import { RawContextKey } from 'vs/platform/contextkey/common/contextkey'; import { Registry } from 'vs/platform/registry/common/platform'; @@ -113,7 +113,7 @@ export interface IEditorPane extends IPanel { } /** - * Overrides `IEditor` where `input` and `group` are known to be set. + * Overrides `IEditorPane` where `input` and `group` are known to be set. */ export interface IVisibleEditorPane extends IEditorPane { readonly input: IEditorInput; @@ -148,28 +148,30 @@ export interface ITextDiffEditorPane extends IEditorPane { } /** - * Marker interface for the base editor control + * Marker interface for the control inside an editor pane. Callers + * have to cast the control to work with it, e.g. via methods + * such as `isCodeEditor(control)`. */ export interface IEditorControl extends ICompositeControl { } -export interface IFileInputFactory { +export interface IFileEditorInputFactory { - createFileInput(resource: URI, encoding: string | undefined, mode: string | undefined, instantiationService: IInstantiationService): IFileEditorInput; + createFileEditorInput(resource: URI, encoding: string | undefined, mode: string | undefined, instantiationService: IInstantiationService): IFileEditorInput; - isFileInput(obj: unknown): obj is IFileEditorInput; + isFileEditorInput(obj: unknown): obj is IFileEditorInput; } export interface IEditorInputFactoryRegistry { /** - * Registers the file input factory to use for file inputs. + * Registers the file editor input factory to use for file inputs. */ - registerFileInputFactory(factory: IFileInputFactory): void; + registerFileEditorInputFactory(factory: IFileEditorInputFactory): void; /** - * Returns the file input factory to use for file inputs. + * Returns the file editor input factory to use for file inputs. */ - getFileInputFactory(): IFileInputFactory; + getFileEditorInputFactory(): IFileEditorInputFactory; /** * Registers a editor input factory for the given editor input to the registry. An editor input factory @@ -213,7 +215,7 @@ export interface IEditorInputFactory { deserialize(instantiationService: IInstantiationService, serializedEditorInput: string): EditorInput | undefined; } -export interface IUntitledTextResourceInput extends IBaseResourceInput { +export interface IUntitledTextResourceEditorInput extends IBaseResourceEditorInput { /** * Optional resource. If the resource is not provided a new untitled file is created (e.g. Untitled-1). @@ -239,7 +241,7 @@ export interface IUntitledTextResourceInput extends IBaseResourceInput { readonly encoding?: string; } -export interface IResourceDiffInput extends IBaseResourceInput { +export interface IResourceDiffEditorInput extends IBaseResourceEditorInput { /** * The left hand side URI to open inside a diff editor. @@ -713,7 +715,7 @@ export abstract class TextResourceEditorInput extends EditorInput { } if (!isEqual(target, this.resource)) { - return this.editorService.createInput({ resource: target }); + return this.editorService.createEditorInput({ resource: target }); } return this; @@ -1127,7 +1129,7 @@ export class TextEditorOptions extends EditorOptions implements ITextEditorOptio */ selectionRevealType: TextEditorSelectionRevealType | undefined; - static from(input?: IBaseResourceInput): TextEditorOptions | undefined { + static from(input?: IBaseResourceEditorInput): TextEditorOptions | undefined { if (!input || !input.options) { return undefined; } @@ -1364,7 +1366,7 @@ export interface IEditorMemento { class EditorInputFactoryRegistry implements IEditorInputFactoryRegistry { private instantiationService: IInstantiationService | undefined; - private fileInputFactory: IFileInputFactory | undefined; + private fileEditorInputFactory: IFileEditorInputFactory | undefined; private readonly editorInputFactoryConstructors: Map> = new Map(); private readonly editorInputFactoryInstances: Map = new Map(); @@ -1384,12 +1386,12 @@ class EditorInputFactoryRegistry implements IEditorInputFactoryRegistry { this.editorInputFactoryInstances.set(editorInputId, instance); } - registerFileInputFactory(factory: IFileInputFactory): void { - this.fileInputFactory = factory; + registerFileEditorInputFactory(factory: IFileEditorInputFactory): void { + this.fileEditorInputFactory = factory; } - getFileInputFactory(): IFileInputFactory { - return assertIsDefined(this.fileInputFactory); + getFileEditorInputFactory(): IFileEditorInputFactory { + return assertIsDefined(this.fileEditorInputFactory); } registerEditorInputFactory(editorInputId: string, ctor: IConstructorSignature0): IDisposable { @@ -1417,7 +1419,7 @@ export const Extensions = { Registry.add(Extensions.EditorInputFactories, new EditorInputFactoryRegistry()); -export async function pathsToEditors(paths: IPathData[] | undefined, fileService: IFileService): Promise<(IResourceInput | IUntitledTextResourceInput)[]> { +export async function pathsToEditors(paths: IPathData[] | undefined, fileService: IFileService): Promise<(IResourceEditorInput | IUntitledTextResourceEditorInput)[]> { if (!paths || !paths.length) { return []; } @@ -1438,7 +1440,7 @@ export async function pathsToEditors(paths: IPathData[] | undefined, fileService pinned: true } : { pinned: true }; - let input: IResourceInput | IUntitledTextResourceInput; + let input: IResourceEditorInput | IUntitledTextResourceEditorInput; if (!exists) { input = { resource, options, forceUntitled: true }; } else { diff --git a/src/vs/workbench/common/editor/resourceEditorInput.ts b/src/vs/workbench/common/editor/resourceEditorInput.ts index 18d7965ca6b..3ea14b511f8 100644 --- a/src/vs/workbench/common/editor/resourceEditorInput.ts +++ b/src/vs/workbench/common/editor/resourceEditorInput.ts @@ -94,7 +94,7 @@ export class ResourceEditorInput extends TextResourceEditorInput implements IMod ref.dispose(); this.modelReference = undefined; - throw new Error(`Unexpected model for ResourceInput: ${this.resource}`); + throw new Error(`Unexpected model for ResourcEditorInput: ${this.resource}`); } this.cachedModel = model; diff --git a/src/vs/workbench/contrib/backup/common/backupRestorer.ts b/src/vs/workbench/contrib/backup/common/backupRestorer.ts index 147cfd3d6eb..bb6ce23065f 100644 --- a/src/vs/workbench/contrib/backup/common/backupRestorer.ts +++ b/src/vs/workbench/contrib/backup/common/backupRestorer.ts @@ -7,10 +7,10 @@ import { URI } from 'vs/base/common/uri'; import { IWorkbenchContribution } from 'vs/workbench/common/contributions'; import { IBackupFileService } from 'vs/workbench/services/backup/common/backup'; import { IEditorService } from 'vs/workbench/services/editor/common/editorService'; -import { IResourceInput } from 'vs/platform/editor/common/editor'; +import { IResourceEditorInput } from 'vs/platform/editor/common/editor'; import { Schemas } from 'vs/base/common/network'; import { ILifecycleService, LifecyclePhase } from 'vs/platform/lifecycle/common/lifecycle'; -import { IUntitledTextResourceInput, IEditorInput } from 'vs/workbench/common/editor'; +import { IUntitledTextResourceEditorInput, IEditorInput } from 'vs/workbench/common/editor'; import { toLocalResource, isEqual } from 'vs/base/common/resources'; import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/common/environmentService'; @@ -84,7 +84,7 @@ export class BackupRestorer implements IWorkbenchContribution { await this.editorService.openEditors(inputs); } - private resolveInput(resource: URI, index: number, hasOpenedEditors: boolean): IResourceInput | IUntitledTextResourceInput { + private resolveInput(resource: URI, index: number, hasOpenedEditors: boolean): IResourceEditorInput | IUntitledTextResourceEditorInput { const options = { pinned: true, preserveFocus: true, inactive: index > 0 || hasOpenedEditors }; // this is a (weak) strategy to find out if the untitled input had diff --git a/src/vs/workbench/contrib/backup/test/electron-browser/backupTracker.test.ts b/src/vs/workbench/contrib/backup/test/electron-browser/backupTracker.test.ts index b3d66ede005..1e7343260ea 100644 --- a/src/vs/workbench/contrib/backup/test/electron-browser/backupTracker.test.ts +++ b/src/vs/workbench/contrib/backup/test/electron-browser/backupTracker.test.ts @@ -18,7 +18,7 @@ import { EditorPart } from 'vs/workbench/browser/parts/editor/editorPart'; import { IEditorGroupsService } from 'vs/workbench/services/editor/common/editorGroupsService'; import { EditorService } from 'vs/workbench/services/editor/browser/editorService'; import { Registry } from 'vs/platform/registry/common/platform'; -import { EditorInput, IUntitledTextResourceInput } from 'vs/workbench/common/editor'; +import { EditorInput, IUntitledTextResourceEditorInput } from 'vs/workbench/common/editor'; import { FileEditorInput } from 'vs/workbench/contrib/files/common/editors/fileEditorInput'; import { SyncDescriptor } from 'vs/platform/instantiation/common/descriptors'; import { IEditorRegistry, EditorDescriptor, Extensions as EditorExtensions } from 'vs/workbench/browser/editor'; @@ -153,7 +153,7 @@ suite('BackupTracker', () => { return [accessor, part, tracker, instantiationService]; } - async function untitledBackupTest(untitled: IUntitledTextResourceInput = {}): Promise { + async function untitledBackupTest(untitled: IUntitledTextResourceEditorInput = {}): Promise { const [accessor, part, tracker] = await createTracker(); const untitledEditor = (await accessor.editorService.openEditor(untitled))?.input as UntitledTextEditorInput; diff --git a/src/vs/workbench/contrib/customEditor/browser/customEditorInput.ts b/src/vs/workbench/contrib/customEditor/browser/customEditorInput.ts index 5f73bb25c61..4dccecaff6d 100644 --- a/src/vs/workbench/contrib/customEditor/browser/customEditorInput.ts +++ b/src/vs/workbench/contrib/customEditor/browser/customEditorInput.ts @@ -142,7 +142,7 @@ export class CustomEditorInput extends LazilyResolvedWebviewEditorInput { return undefined; } - return this.handleMove(groupId, target) || this.editorService.createInput({ resource: target, forceFile: true }); + return this.handleMove(groupId, target) || this.editorService.createEditorInput({ resource: target, forceFile: true }); } public async revert(group: GroupIdentifier, options?: IRevertOptions): Promise { diff --git a/src/vs/workbench/contrib/customEditor/browser/customEditors.ts b/src/vs/workbench/contrib/customEditor/browser/customEditors.ts index 828284159f3..8e89ae01631 100644 --- a/src/vs/workbench/contrib/customEditor/browser/customEditors.ts +++ b/src/vs/workbench/contrib/customEditor/browser/customEditors.ts @@ -241,8 +241,8 @@ export class CustomEditorService extends Disposable implements ICustomEditorServ group?: IEditorGroup, ): Promise { if (viewType === defaultEditorId) { - const fileInput = this.editorService.createInput({ resource, forceFile: true }); - return this.openEditorForResource(resource, fileInput, { ...options, ignoreOverrides: true }, group); + const fileEditorInput = this.editorService.createEditorInput({ resource, forceFile: true }); + return this.openEditorForResource(resource, fileEditorInput, { ...options, ignoreOverrides: true }, group); } if (!this._editorInfoStore.get(viewType)) { @@ -260,7 +260,7 @@ export class CustomEditorService extends Disposable implements ICustomEditorServ options?: { readonly customClasses: string; }, ): IEditorInput { if (viewType === defaultEditorId) { - return this.editorService.createInput({ resource, forceFile: true }); + return this.editorService.createEditorInput({ resource, forceFile: true }); } const id = generateUuid(); diff --git a/src/vs/workbench/contrib/files/browser/files.contribution.ts b/src/vs/workbench/contrib/files/browser/files.contribution.ts index 6112c0cb3d0..f7107199951 100644 --- a/src/vs/workbench/contrib/files/browser/files.contribution.ts +++ b/src/vs/workbench/contrib/files/browser/files.contribution.ts @@ -102,17 +102,17 @@ Registry.as(EditorExtensions.Editors).registerEditor( ); // Register default file input factory -Registry.as(EditorInputExtensions.EditorInputFactories).registerFileInputFactory({ - createFileInput: (resource, encoding, mode, instantiationService): IFileEditorInput => { +Registry.as(EditorInputExtensions.EditorInputFactories).registerFileEditorInputFactory({ + createFileEditorInput: (resource, encoding, mode, instantiationService): IFileEditorInput => { return instantiationService.createInstance(FileEditorInput, resource, encoding, mode); }, - isFileInput: (obj): obj is IFileEditorInput => { + isFileEditorInput: (obj): obj is IFileEditorInput => { return obj instanceof FileEditorInput; } }); -interface ISerializedFileInput { +interface ISerializedFileEditorInput { resourceJSON: UriComponents; encoding?: string; modeId?: string; @@ -128,23 +128,23 @@ class FileEditorInputFactory implements IEditorInputFactory { serialize(editorInput: EditorInput): string { const fileEditorInput = editorInput; const resource = fileEditorInput.resource; - const fileInput: ISerializedFileInput = { + const serializedFileEditorInput: ISerializedFileEditorInput = { resourceJSON: resource.toJSON(), encoding: fileEditorInput.getEncoding(), modeId: fileEditorInput.getPreferredMode() // only using the preferred user associated mode here if available to not store redundant data }; - return JSON.stringify(fileInput); + return JSON.stringify(serializedFileEditorInput); } deserialize(instantiationService: IInstantiationService, serializedEditorInput: string): FileEditorInput { return instantiationService.invokeFunction(accessor => { - const fileInput: ISerializedFileInput = JSON.parse(serializedEditorInput); - const resource = URI.revive(fileInput.resourceJSON); - const encoding = fileInput.encoding; - const mode = fileInput.modeId; + const serializedFileEditorInput: ISerializedFileEditorInput = JSON.parse(serializedEditorInput); + const resource = URI.revive(serializedFileEditorInput.resourceJSON); + const encoding = serializedFileEditorInput.encoding; + const mode = serializedFileEditorInput.modeId; - return accessor.get(IEditorService).createInput({ resource, encoding, mode, forceFile: true }) as FileEditorInput; + return accessor.get(IEditorService).createEditorInput({ resource, encoding, mode, forceFile: true }) as FileEditorInput; }); } } diff --git a/src/vs/workbench/contrib/files/test/browser/textFileEditor.test.ts b/src/vs/workbench/contrib/files/test/browser/textFileEditor.test.ts index a58dd887f65..81e71fd750f 100644 --- a/src/vs/workbench/contrib/files/test/browser/textFileEditor.test.ts +++ b/src/vs/workbench/contrib/files/test/browser/textFileEditor.test.ts @@ -87,14 +87,14 @@ suite('Files - TextFileEditor', () => { async function viewStateTest(context: Mocha.ITestCallbackContext, restoreViewState: boolean): Promise { const [part, accessor] = await createPart(restoreViewState); - let editor = await accessor.editorService.openEditor(accessor.editorService.createInput({ resource: toResource.call(context, '/path/index.txt'), forceFile: true })); + let editor = await accessor.editorService.openEditor(accessor.editorService.createEditorInput({ resource: toResource.call(context, '/path/index.txt'), forceFile: true })); let codeEditor = editor?.getControl() as CodeEditorWidget; const selection = new Selection(1, 3, 1, 4); codeEditor.setSelection(selection); - editor = await accessor.editorService.openEditor(accessor.editorService.createInput({ resource: toResource.call(context, '/path/index-other.txt'), forceFile: true })); - editor = await accessor.editorService.openEditor(accessor.editorService.createInput({ resource: toResource.call(context, '/path/index.txt'), forceFile: true })); + editor = await accessor.editorService.openEditor(accessor.editorService.createEditorInput({ resource: toResource.call(context, '/path/index-other.txt'), forceFile: true })); + editor = await accessor.editorService.openEditor(accessor.editorService.createEditorInput({ resource: toResource.call(context, '/path/index.txt'), forceFile: true })); codeEditor = editor?.getControl() as CodeEditorWidget; diff --git a/src/vs/workbench/contrib/files/test/browser/textFileEditorTracker.test.ts b/src/vs/workbench/contrib/files/test/browser/textFileEditorTracker.test.ts index 081e0d02d1a..f50a26af1a9 100644 --- a/src/vs/workbench/contrib/files/test/browser/textFileEditorTracker.test.ts +++ b/src/vs/workbench/contrib/files/test/browser/textFileEditorTracker.test.ts @@ -97,14 +97,14 @@ suite('Files - TextFileEditorTracker', () => { const resource = toResource.call(this, '/path/index.txt'); - assert.ok(!accessor.editorService.isOpen(accessor.editorService.createInput({ resource, forceFile: true }))); + assert.ok(!accessor.editorService.isOpen(accessor.editorService.createEditorInput({ resource, forceFile: true }))); const model = await accessor.textFileService.files.resolve(resource) as IResolvedTextFileEditorModel; model.textEditorModel.setValue('Super Good'); await awaitEditorOpening(accessor.editorService); - assert.ok(accessor.editorService.isOpen(accessor.editorService.createInput({ resource, forceFile: true }))); + assert.ok(accessor.editorService.isOpen(accessor.editorService.createEditorInput({ resource, forceFile: true }))); part.dispose(); tracker.dispose(); @@ -114,7 +114,7 @@ suite('Files - TextFileEditorTracker', () => { test('dirty untitled text file model opens as editor', async function () { const [part, accessor, tracker, , editorService] = await createTracker(); - const untitledEditor = editorService.createInput({ forceUntitled: true }) as UntitledTextEditorInput; + const untitledEditor = editorService.createEditorInput({ forceUntitled: true }) as UntitledTextEditorInput; const model = await untitledEditor.resolve(); assert.ok(!accessor.editorService.isOpen(untitledEditor)); @@ -140,7 +140,7 @@ suite('Files - TextFileEditorTracker', () => { const resource = toResource.call(this, '/path/index.txt'); - await accessor.editorService.openEditor(accessor.editorService.createInput({ resource, forceFile: true })); + await accessor.editorService.openEditor(accessor.editorService.createEditorInput({ resource, forceFile: true })); accessor.hostService.setFocus(false); accessor.hostService.setFocus(true); diff --git a/src/vs/workbench/contrib/search/browser/openFileHandler.ts b/src/vs/workbench/contrib/search/browser/openFileHandler.ts index f4a5f62c36a..3c88120a110 100644 --- a/src/vs/workbench/contrib/search/browser/openFileHandler.ts +++ b/src/vs/workbench/contrib/search/browser/openFileHandler.ts @@ -20,7 +20,7 @@ import { IModelService } from 'vs/editor/common/services/modelService'; import { IModeService } from 'vs/editor/common/services/modeService'; import * as nls from 'vs/nls'; import { IConfigurationService } from 'vs/platform/configuration/common/configuration'; -import { IResourceInput } from 'vs/platform/editor/common/editor'; +import { IResourceEditorInput } from 'vs/platform/editor/common/editor'; import { IFileService } from 'vs/platform/files/common/files'; import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation'; import { ILabelService } from 'vs/platform/label/common/label'; @@ -93,8 +93,8 @@ export class FileEntry extends EditorQuickOpenEntry { return true; } - getInput(): IResourceInput | EditorInput { - const input: IResourceInput = { + getInput(): IResourceEditorInput | EditorInput { + const input: IResourceEditorInput = { resource: this.resource, options: { pinned: !this.configurationService.getValue().workbench.editor.enablePreviewFromQuickOpen, diff --git a/src/vs/workbench/contrib/search/browser/openSymbolHandler.ts b/src/vs/workbench/contrib/search/browser/openSymbolHandler.ts index 54d2cfe03a6..d962bc1bc1f 100644 --- a/src/vs/workbench/contrib/search/browser/openSymbolHandler.ts +++ b/src/vs/workbench/contrib/search/browser/openSymbolHandler.ts @@ -15,7 +15,7 @@ import * as strings from 'vs/base/common/strings'; import { Range } from 'vs/editor/common/core/range'; import { IWorkbenchEditorConfiguration } from 'vs/workbench/common/editor'; import { SymbolKinds, SymbolTag } from 'vs/editor/common/modes'; -import { IResourceInput } from 'vs/platform/editor/common/editor'; +import { IResourceEditorInput } from 'vs/platform/editor/common/editor'; import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation'; import { IConfigurationService } from 'vs/platform/configuration/common/configuration'; import { IWorkspaceSymbolProvider, getWorkspaceSymbols, IWorkspaceSymbol } from 'vs/workbench/contrib/search/common/search'; @@ -115,8 +115,8 @@ class SymbolEntry extends EditorQuickOpenEntry { return mode === Mode.OPEN; } - getInput(): IResourceInput { - const input: IResourceInput = { + getInput(): IResourceEditorInput { + const input: IResourceEditorInput = { resource: this.bearing.location.uri, options: { pinned: !this.configurationService.getValue().workbench.editor.enablePreviewFromQuickOpen, diff --git a/src/vs/workbench/electron-browser/window.ts b/src/vs/workbench/electron-browser/window.ts index 5851917f0da..6724a8b8ac7 100644 --- a/src/vs/workbench/electron-browser/window.ts +++ b/src/vs/workbench/electron-browser/window.ts @@ -11,7 +11,7 @@ import * as DOM from 'vs/base/browser/dom'; import { Separator } from 'vs/base/browser/ui/actionbar/actionbar'; import { IAction } from 'vs/base/common/actions'; import { IFileService } from 'vs/platform/files/common/files'; -import { toResource, IUntitledTextResourceInput, SideBySideEditor, pathsToEditors } from 'vs/workbench/common/editor'; +import { toResource, IUntitledTextResourceEditorInput, SideBySideEditor, pathsToEditors } from 'vs/workbench/common/editor'; import { IEditorService, IResourceEditor } from 'vs/workbench/services/editor/common/editorService'; import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry'; import { IWindowSettings, IOpenFileRequest, IWindowsConfiguration, IAddFoldersRequest, IRunActionInWindowRequest, IRunKeybindingInWindowRequest, getTitleBarStyle } from 'vs/platform/windows/common/windows'; @@ -19,7 +19,7 @@ import { ITitleService } from 'vs/workbench/services/title/common/titleService'; import { IWorkbenchThemeService, VS_HC_THEME } from 'vs/workbench/services/themes/common/workbenchThemeService'; import * as browser from 'vs/base/browser/browser'; import { ICommandService, CommandsRegistry } from 'vs/platform/commands/common/commands'; -import { IResourceInput } from 'vs/platform/editor/common/editor'; +import { IResourceEditorInput } from 'vs/platform/editor/common/editor'; import { KeyboardMapperFactory } from 'vs/workbench/services/keybinding/electron-browser/nativeKeymapService'; import { ipcRenderer as ipc, webFrame, crashReporter, CrashReporterStartOptions, Event as IpcEvent } from 'electron'; import { IWorkspaceEditingService } from 'vs/workbench/services/workspaces/common/workspaceEditing'; @@ -671,7 +671,7 @@ export class ElectronWindow extends Disposable { }); } - private async openResources(resources: Array, diffMode: boolean): Promise { + private async openResources(resources: Array, diffMode: boolean): Promise { await this.lifecycleService.when(LifecyclePhase.Ready); // In diffMode we open 2 resources as diff diff --git a/src/vs/workbench/services/editor/browser/codeEditorService.ts b/src/vs/workbench/services/editor/browser/codeEditorService.ts index c55fe2939e3..4c933e05f9a 100644 --- a/src/vs/workbench/services/editor/browser/codeEditorService.ts +++ b/src/vs/workbench/services/editor/browser/codeEditorService.ts @@ -6,7 +6,7 @@ import { ICodeEditor, isCodeEditor, isDiffEditor } from 'vs/editor/browser/editorBrowser'; import { CodeEditorServiceImpl } from 'vs/editor/browser/services/codeEditorServiceImpl'; import { ScrollType } from 'vs/editor/common/editorCommon'; -import { IResourceInput } from 'vs/platform/editor/common/editor'; +import { IResourceEditorInput } from 'vs/platform/editor/common/editor'; import { IThemeService } from 'vs/platform/theme/common/themeService'; import { TextEditorOptions } from 'vs/workbench/common/editor'; import { ACTIVE_GROUP, IEditorService, SIDE_GROUP } from 'vs/workbench/services/editor/common/editorService'; @@ -35,7 +35,7 @@ export class CodeEditorService extends CodeEditorServiceImpl { return null; } - openCodeEditor(input: IResourceInput, source: ICodeEditor | null, sideBySide?: boolean): Promise { + openCodeEditor(input: IResourceEditorInput, source: ICodeEditor | null, sideBySide?: boolean): Promise { // Special case: If the active editor is a diff editor and the request to open originates and // targets the modified side of it, we just apply the request there to prevent opening the modified @@ -62,7 +62,7 @@ export class CodeEditorService extends CodeEditorServiceImpl { return this.doOpenCodeEditor(input, source, sideBySide); } - private async doOpenCodeEditor(input: IResourceInput, source: ICodeEditor | null, sideBySide?: boolean): Promise { + private async doOpenCodeEditor(input: IResourceEditorInput, source: ICodeEditor | null, sideBySide?: boolean): Promise { const control = await this.editorService.openEditor(input, sideBySide ? SIDE_GROUP : ACTIVE_GROUP); if (control) { const widget = control.getControl(); diff --git a/src/vs/workbench/services/editor/browser/editorService.ts b/src/vs/workbench/services/editor/browser/editorService.ts index 8f1c799f157..282eef65ad5 100644 --- a/src/vs/workbench/services/editor/browser/editorService.ts +++ b/src/vs/workbench/services/editor/browser/editorService.ts @@ -4,8 +4,8 @@ *--------------------------------------------------------------------------------------------*/ import { IInstantiationService, ServicesAccessor } from 'vs/platform/instantiation/common/instantiation'; -import { IResourceInput, ITextEditorOptions, IEditorOptions, EditorActivation } from 'vs/platform/editor/common/editor'; -import { SideBySideEditor, IEditorInput, IEditorPane, GroupIdentifier, IFileEditorInput, IUntitledTextResourceInput, IResourceDiffInput, IEditorInputFactoryRegistry, Extensions as EditorExtensions, EditorInput, SideBySideEditorInput, IEditorInputWithOptions, isEditorInputWithOptions, EditorOptions, TextEditorOptions, IEditorIdentifier, IEditorCloseEvent, ITextEditorPane, ITextDiffEditorPane, IRevertOptions, SaveReason, EditorsOrder, isTextEditorPane, IWorkbenchEditorConfiguration, toResource, IVisibleEditorPane } from 'vs/workbench/common/editor'; +import { IResourceEditorInput, ITextEditorOptions, IEditorOptions, EditorActivation } from 'vs/platform/editor/common/editor'; +import { SideBySideEditor, IEditorInput, IEditorPane, GroupIdentifier, IFileEditorInput, IUntitledTextResourceEditorInput, IResourceDiffEditorInput, IEditorInputFactoryRegistry, Extensions as EditorExtensions, EditorInput, SideBySideEditorInput, IEditorInputWithOptions, isEditorInputWithOptions, EditorOptions, TextEditorOptions, IEditorIdentifier, IEditorCloseEvent, ITextEditorPane, ITextDiffEditorPane, IRevertOptions, SaveReason, EditorsOrder, isTextEditorPane, IWorkbenchEditorConfiguration, toResource, IVisibleEditorPane } from 'vs/workbench/common/editor'; import { ResourceEditorInput } from 'vs/workbench/common/editor/resourceEditorInput'; import { Registry } from 'vs/platform/registry/common/platform'; import { ResourceMap } from 'vs/base/common/map'; @@ -293,7 +293,7 @@ export class EditorService extends Disposable implements EditorServiceImpl { } private closeOnFileDelete: boolean = false; - private fileInputFactory = Registry.as(EditorExtensions.EditorInputFactories).getFileInputFactory(); + private fileEditorInputFactory = Registry.as(EditorExtensions.EditorInputFactories).getFileEditorInputFactory(); private onConfigurationUpdated(configuration: IWorkbenchEditorConfiguration): void { if (typeof configuration.workbench?.editor?.closeOnFileDelete === 'boolean') { this.closeOnFileDelete = configuration.workbench.editor.closeOnFileDelete; @@ -314,7 +314,7 @@ export class EditorService extends Disposable implements EditorServiceImpl { // - the user has not disabled the setting closeOnFileDelete // - the file change is local // - the input is a file that is not resolved (we need to dispose because we cannot restore otherwise since we do not have the contents) - if (this.closeOnFileDelete || !isExternal || (this.fileInputFactory.isFileInput(editor) && !editor.isResolved())) { + if (this.closeOnFileDelete || !isExternal || (this.fileEditorInputFactory.isFileEditorInput(editor) && !editor.isResolved())) { // Do NOT close any opened editor that matches the resource path (either equal or being parent) of the // resource we move to (movedTo). Otherwise we would close a resource that has been renamed to the same @@ -495,8 +495,8 @@ export class EditorService extends Disposable implements EditorServiceImpl { //#region openEditor() openEditor(editor: IEditorInput, options?: IEditorOptions | ITextEditorOptions, group?: OpenInEditorGroup): Promise; - openEditor(editor: IResourceInput | IUntitledTextResourceInput, group?: OpenInEditorGroup): Promise; - openEditor(editor: IResourceDiffInput, group?: OpenInEditorGroup): Promise; + openEditor(editor: IResourceEditorInput | IUntitledTextResourceEditorInput, group?: OpenInEditorGroup): Promise; + openEditor(editor: IResourceDiffEditorInput, group?: OpenInEditorGroup): Promise; async openEditor(editor: IEditorInput | IResourceEditor, optionsOrGroup?: IEditorOptions | ITextEditorOptions | OpenInEditorGroup, group?: OpenInEditorGroup): Promise { const result = this.doResolveEditorOpenRequest(editor, optionsOrGroup, group); if (result) { @@ -527,7 +527,7 @@ export class EditorService extends Disposable implements EditorServiceImpl { // Untyped Text Editor Support else { const textInput = editor; - typedEditor = this.createInput(textInput); + typedEditor = this.createEditorInput(textInput); if (typedEditor) { typedOptions = TextEditorOptions.from(textInput); @@ -669,7 +669,7 @@ export class EditorService extends Disposable implements EditorServiceImpl { if (isEditorInputWithOptions(editor)) { typedEditors.push(editor); } else { - typedEditors.push({ editor: this.createInput(editor), options: TextEditorOptions.from(editor) }); + typedEditors.push({ editor: this.createEditorInput(editor), options: TextEditorOptions.from(editor) }); } }); @@ -705,8 +705,8 @@ export class EditorService extends Disposable implements EditorServiceImpl { //#region isOpen() isOpen(editor: IEditorInput): boolean; - isOpen(editor: IResourceInput): boolean; - isOpen(editor: IEditorInput | IResourceInput): boolean { + isOpen(editor: IResourceEditorInput): boolean; + isOpen(editor: IEditorInput | IResourceEditorInput): boolean { if (editor instanceof EditorInput) { return this.editorGroupService.groups.some(group => group.isOpened(editor)); } @@ -740,8 +740,8 @@ export class EditorService extends Disposable implements EditorServiceImpl { const replacementArg = replaceEditorArg as IResourceEditorReplacement; typedEditors.push({ - editor: this.createInput(replacementArg.editor), - replacement: this.createInput(replacementArg.replacement), + editor: this.createEditorInput(replacementArg.editor), + replacement: this.createEditorInput(replacementArg.replacement), options: this.toOptions(replacementArg.replacement.options) }); } @@ -775,11 +775,11 @@ export class EditorService extends Disposable implements EditorServiceImpl { //#endregion - //#region createInput() + //#region createEditorInput() private readonly editorInputCache = new ResourceMap(); - createInput(input: IEditorInputWithOptions | IEditorInput | IResourceEditor): EditorInput { + createEditorInput(input: IEditorInputWithOptions | IEditorInput | IResourceEditor): EditorInput { // Typed Editor Input Support (EditorInput) if (input instanceof EditorInput) { @@ -793,10 +793,10 @@ export class EditorService extends Disposable implements EditorServiceImpl { } // Diff Editor Support - const resourceDiffInput = input as IResourceDiffInput; + const resourceDiffInput = input as IResourceDiffEditorInput; if (resourceDiffInput.leftResource && resourceDiffInput.rightResource) { - const leftInput = this.createInput({ resource: resourceDiffInput.leftResource, forceFile: resourceDiffInput.forceFile }); - const rightInput = this.createInput({ resource: resourceDiffInput.rightResource, forceFile: resourceDiffInput.forceFile }); + const leftInput = this.createEditorInput({ resource: resourceDiffInput.leftResource, forceFile: resourceDiffInput.forceFile }); + const rightInput = this.createEditorInput({ resource: resourceDiffInput.rightResource, forceFile: resourceDiffInput.forceFile }); return new DiffEditorInput( resourceDiffInput.label || this.toSideBySideLabel(leftInput, rightInput, '↔'), @@ -807,7 +807,7 @@ export class EditorService extends Disposable implements EditorServiceImpl { } // Untitled file support - const untitledInput = input as IUntitledTextResourceInput; + const untitledInput = input as IUntitledTextResourceEditorInput; if (untitledInput.forceUntitled || !untitledInput.resource || (untitledInput.resource && untitledInput.resource.scheme === Schemas.untitled)) { const untitledOptions = { mode: untitledInput.mode, @@ -843,22 +843,22 @@ export class EditorService extends Disposable implements EditorServiceImpl { } // Resource Editor Support - const resourceInput = input as IResourceInput; - if (resourceInput.resource instanceof URI) { - let label = resourceInput.label; + const resourceEditorInput = input as IResourceEditorInput; + if (resourceEditorInput.resource instanceof URI) { + let label = resourceEditorInput.label; if (!label) { - label = basename(resourceInput.resource); // derive the label from the path + label = basename(resourceEditorInput.resource); // derive the label from the path } - return this.createOrGetCached(resourceInput.resource, () => { + return this.createOrGetCached(resourceEditorInput.resource, () => { // File - if (resourceInput.forceFile /* fix for https://github.com/Microsoft/vscode/issues/48275 */ || this.fileService.canHandleResource(resourceInput.resource)) { - return this.fileInputFactory.createFileInput(resourceInput.resource, resourceInput.encoding, resourceInput.mode, this.instantiationService); + if (resourceEditorInput.forceFile /* fix for https://github.com/Microsoft/vscode/issues/48275 */ || this.fileService.canHandleResource(resourceEditorInput.resource)) { + return this.fileEditorInputFactory.createFileEditorInput(resourceEditorInput.resource, resourceEditorInput.encoding, resourceEditorInput.mode, this.instantiationService); } // Resource - return this.instantiationService.createInstance(ResourceEditorInput, resourceInput.label, resourceInput.description, resourceInput.resource, resourceInput.mode); + return this.instantiationService.createInstance(ResourceEditorInput, resourceEditorInput.label, resourceEditorInput.description, resourceEditorInput.resource, resourceEditorInput.mode); }, cachedInput => { // Untitled @@ -868,12 +868,12 @@ export class EditorService extends Disposable implements EditorServiceImpl { // Files else if (!(cachedInput instanceof ResourceEditorInput)) { - if (resourceInput.encoding) { - cachedInput.setPreferredEncoding(resourceInput.encoding); + if (resourceEditorInput.encoding) { + cachedInput.setPreferredEncoding(resourceEditorInput.encoding); } - if (resourceInput.mode) { - cachedInput.setPreferredMode(resourceInput.mode); + if (resourceEditorInput.mode) { + cachedInput.setPreferredMode(resourceEditorInput.mode); } } @@ -883,12 +883,12 @@ export class EditorService extends Disposable implements EditorServiceImpl { cachedInput.setName(label); } - if (resourceInput.description) { - cachedInput.setDescription(resourceInput.description); + if (resourceEditorInput.description) { + cachedInput.setDescription(resourceEditorInput.description); } - if (resourceInput.mode) { - cachedInput.setPreferredMode(resourceInput.mode); + if (resourceEditorInput.mode) { + cachedInput.setPreferredMode(resourceEditorInput.mode); } } }) as EditorInput; @@ -929,7 +929,7 @@ export class EditorService extends Disposable implements EditorServiceImpl { // If both editors are file inputs, we produce an optimized label // by adding the relative path of both inputs to the label. This // makes it easier to understand a file-based comparison. - if (this.fileInputFactory.isFileInput(leftInput) && this.fileInputFactory.isFileInput(rightInput)) { + if (this.fileEditorInputFactory.isFileEditorInput(leftInput) && this.fileEditorInputFactory.isFileEditorInput(rightInput)) { return `${this.labelService.getUriLabel(leftResource, { relative: true })} ${divider} ${this.labelService.getUriLabel(rightResource, { relative: true })}`; } @@ -1109,8 +1109,8 @@ export class DelegatingEditorService implements IEditorService { ) { } openEditor(editor: IEditorInput, options?: IEditorOptions | ITextEditorOptions, group?: OpenInEditorGroup): Promise; - openEditor(editor: IResourceInput | IUntitledTextResourceInput, group?: OpenInEditorGroup): Promise; - openEditor(editor: IResourceDiffInput, group?: OpenInEditorGroup): Promise; + openEditor(editor: IResourceEditorInput | IUntitledTextResourceEditorInput, group?: OpenInEditorGroup): Promise; + openEditor(editor: IResourceDiffEditorInput, group?: OpenInEditorGroup): Promise; async openEditor(editor: IEditorInput | IResourceEditor, optionsOrGroup?: IEditorOptions | ITextEditorOptions | OpenInEditorGroup, group?: OpenInEditorGroup): Promise { const result = this.editorService.doResolveEditorOpenRequest(editor, optionsOrGroup, group); if (result) { @@ -1164,14 +1164,14 @@ export class DelegatingEditorService implements IEditorService { } isOpen(editor: IEditorInput): boolean; - isOpen(editor: IResourceInput): boolean; - isOpen(editor: IEditorInput | IResourceInput): boolean { return this.editorService.isOpen(editor as IResourceInput /* TS fail */); } + isOpen(editor: IResourceEditorInput): boolean; + isOpen(editor: IEditorInput | IResourceEditorInput): boolean { return this.editorService.isOpen(editor as IResourceEditorInput /* TS fail */); } overrideOpenEditor(handler: IOpenEditorOverrideHandler): IDisposable { return this.editorService.overrideOpenEditor(handler); } invokeWithinEditorContext(fn: (accessor: ServicesAccessor) => T): T { return this.editorService.invokeWithinEditorContext(fn); } - createInput(input: IResourceEditor): IEditorInput { return this.editorService.createInput(input); } + createEditorInput(input: IResourceEditor): IEditorInput { return this.editorService.createEditorInput(input); } save(editors: IEditorIdentifier | IEditorIdentifier[], options?: ISaveEditorsOptions): Promise { return this.editorService.save(editors, options); } saveAll(options?: ISaveAllEditorsOptions): Promise { return this.editorService.saveAll(options); } diff --git a/src/vs/workbench/services/editor/common/editorService.ts b/src/vs/workbench/services/editor/common/editorService.ts index 27bad10f336..e79abbfa5ec 100644 --- a/src/vs/workbench/services/editor/common/editorService.ts +++ b/src/vs/workbench/services/editor/common/editorService.ts @@ -4,8 +4,8 @@ *--------------------------------------------------------------------------------------------*/ import { createDecorator, ServicesAccessor } from 'vs/platform/instantiation/common/instantiation'; -import { IResourceInput, IEditorOptions, ITextEditorOptions } from 'vs/platform/editor/common/editor'; -import { IEditorInput, IEditorPane, GroupIdentifier, IEditorInputWithOptions, IUntitledTextResourceInput, IResourceDiffInput, ITextEditorPane, ITextDiffEditorPane, IEditorIdentifier, ISaveOptions, IRevertOptions, EditorsOrder, IVisibleEditorPane } from 'vs/workbench/common/editor'; +import { IResourceEditorInput, IEditorOptions, ITextEditorOptions } from 'vs/platform/editor/common/editor'; +import { IEditorInput, IEditorPane, GroupIdentifier, IEditorInputWithOptions, IUntitledTextResourceEditorInput, IResourceDiffEditorInput, ITextEditorPane, ITextDiffEditorPane, IEditorIdentifier, ISaveOptions, IRevertOptions, EditorsOrder, IVisibleEditorPane } from 'vs/workbench/common/editor'; import { Event } from 'vs/base/common/event'; import { IEditor, IDiffEditor } from 'vs/editor/common/editorCommon'; import { IEditorGroup, IEditorReplacement } from 'vs/workbench/services/editor/common/editorGroupsService'; @@ -13,7 +13,7 @@ import { IDisposable } from 'vs/base/common/lifecycle'; export const IEditorService = createDecorator('editorService'); -export type IResourceEditor = IResourceInput | IUntitledTextResourceInput | IResourceDiffInput; +export type IResourceEditor = IResourceEditorInput | IUntitledTextResourceEditorInput | IResourceDiffEditorInput; export interface IResourceEditorReplacement { readonly editor: IResourceEditor; @@ -158,8 +158,8 @@ export interface IEditorService { * opened to be active. */ openEditor(editor: IEditorInput, options?: IEditorOptions | ITextEditorOptions, group?: IEditorGroup | GroupIdentifier | SIDE_GROUP_TYPE | ACTIVE_GROUP_TYPE): Promise; - openEditor(editor: IResourceInput | IUntitledTextResourceInput, group?: IEditorGroup | GroupIdentifier | SIDE_GROUP_TYPE | ACTIVE_GROUP_TYPE): Promise; - openEditor(editor: IResourceDiffInput, group?: IEditorGroup | GroupIdentifier | SIDE_GROUP_TYPE | ACTIVE_GROUP_TYPE): Promise; + openEditor(editor: IResourceEditorInput | IUntitledTextResourceEditorInput, group?: IEditorGroup | GroupIdentifier | SIDE_GROUP_TYPE | ACTIVE_GROUP_TYPE): Promise; + openEditor(editor: IResourceDiffEditorInput, group?: IEditorGroup | GroupIdentifier | SIDE_GROUP_TYPE | ACTIVE_GROUP_TYPE): Promise; /** * Open editors in an editor group. @@ -192,11 +192,11 @@ export interface IEditorService { * Note: An editor can be opened but not actively visible. * * @param editor the editor to check for being opened. If a - * `IResourceInput` is passed in, the resource is checked on + * `IResourceEditorInput` is passed in, the resource is checked on * all opened editors. In case of a side by side editor, the * right hand side resource is considered only. */ - isOpen(editor: IResourceInput): boolean; + isOpen(editor: IResourceEditorInput): boolean; isOpen(editor: IEditorInput): boolean; /** @@ -214,7 +214,7 @@ export interface IEditorService { /** * Converts a lightweight input to a workbench editor input. */ - createInput(input: IResourceEditor): IEditorInput; + createEditorInput(input: IResourceEditor): IEditorInput; /** * Save the provided list of editors. diff --git a/src/vs/workbench/services/editor/test/browser/editorService.test.ts b/src/vs/workbench/services/editor/test/browser/editorService.test.ts index 8222a35a60d..fec64ea2b21 100644 --- a/src/vs/workbench/services/editor/test/browser/editorService.test.ts +++ b/src/vs/workbench/services/editor/test/browser/editorService.test.ts @@ -226,50 +226,50 @@ suite('EditorService', () => { // Cached Input (Files) const fileResource1 = toResource.call(this, '/foo/bar/cache1.js'); - const fileInput1 = service.createInput({ resource: fileResource1 }); - assert.ok(fileInput1); + const fileEditorInput1 = service.createEditorInput({ resource: fileResource1 }); + assert.ok(fileEditorInput1); const fileResource2 = toResource.call(this, '/foo/bar/cache2.js'); - const fileInput2 = service.createInput({ resource: fileResource2 }); - assert.ok(fileInput2); + const fileEditorInput2 = service.createEditorInput({ resource: fileResource2 }); + assert.ok(fileEditorInput2); - assert.notEqual(fileInput1, fileInput2); + assert.notEqual(fileEditorInput1, fileEditorInput2); - const fileInput1Again = service.createInput({ resource: fileResource1 }); - assert.equal(fileInput1Again, fileInput1); + const fileEditorInput1Again = service.createEditorInput({ resource: fileResource1 }); + assert.equal(fileEditorInput1Again, fileEditorInput1); - fileInput1Again!.dispose(); + fileEditorInput1Again!.dispose(); - assert.ok(fileInput1!.isDisposed()); + assert.ok(fileEditorInput1!.isDisposed()); - const fileInput1AgainAndAgain = service.createInput({ resource: fileResource1 }); - assert.notEqual(fileInput1AgainAndAgain, fileInput1); - assert.ok(!fileInput1AgainAndAgain!.isDisposed()); + const fileEditorInput1AgainAndAgain = service.createEditorInput({ resource: fileResource1 }); + assert.notEqual(fileEditorInput1AgainAndAgain, fileEditorInput1); + assert.ok(!fileEditorInput1AgainAndAgain!.isDisposed()); // Cached Input (Resource) const resource1 = URI.from({ scheme: 'custom', path: '/foo/bar/cache1.js' }); - const input1 = service.createInput({ resource: resource1 }); + const input1 = service.createEditorInput({ resource: resource1 }); assert.ok(input1); const resource2 = URI.from({ scheme: 'custom', path: '/foo/bar/cache2.js' }); - const input2 = service.createInput({ resource: resource2 }); + const input2 = service.createEditorInput({ resource: resource2 }); assert.ok(input2); assert.notEqual(input1, input2); - const input1Again = service.createInput({ resource: resource1 }); + const input1Again = service.createEditorInput({ resource: resource1 }); assert.equal(input1Again, input1); input1Again!.dispose(); assert.ok(input1!.isDisposed()); - const input1AgainAndAgain = service.createInput({ resource: resource1 }); + const input1AgainAndAgain = service.createEditorInput({ resource: resource1 }); assert.notEqual(input1AgainAndAgain, input1); assert.ok(!input1AgainAndAgain!.isDisposed()); }); - test('createInput', async function () { + test('createEditorInput', async function () { const instantiationService = workbenchInstantiationService(); const service = instantiationService.createInstance(EditorService); @@ -279,74 +279,74 @@ suite('EditorService', () => { }); // Untyped Input (file) - let input = service.createInput({ resource: toResource.call(this, '/index.html'), options: { selection: { startLineNumber: 1, startColumn: 1 } } }); + let input = service.createEditorInput({ resource: toResource.call(this, '/index.html'), options: { selection: { startLineNumber: 1, startColumn: 1 } } }); assert(input instanceof FileEditorInput); let contentInput = input; assert.strictEqual(contentInput.resource.fsPath, toResource.call(this, '/index.html').fsPath); // Typed Input - assert.equal(service.createInput(input), input); - assert.equal(service.createInput({ editor: input }), input); + assert.equal(service.createEditorInput(input), input); + assert.equal(service.createEditorInput({ editor: input }), input); // Untyped Input (file, encoding) - input = service.createInput({ resource: toResource.call(this, '/index.html'), encoding: 'utf16le', options: { selection: { startLineNumber: 1, startColumn: 1 } } }); + input = service.createEditorInput({ resource: toResource.call(this, '/index.html'), encoding: 'utf16le', options: { selection: { startLineNumber: 1, startColumn: 1 } } }); assert(input instanceof FileEditorInput); contentInput = input; assert.equal(contentInput.getPreferredEncoding(), 'utf16le'); // Untyped Input (file, mode) - input = service.createInput({ resource: toResource.call(this, '/index.html'), mode }); + input = service.createEditorInput({ resource: toResource.call(this, '/index.html'), mode }); assert(input instanceof FileEditorInput); contentInput = input; assert.equal(contentInput.getPreferredMode(), mode); // Untyped Input (file, different mode) - input = service.createInput({ resource: toResource.call(this, '/index.html'), mode: 'text' }); + input = service.createEditorInput({ resource: toResource.call(this, '/index.html'), mode: 'text' }); assert(input instanceof FileEditorInput); contentInput = input; assert.equal(contentInput.getPreferredMode(), 'text'); // Untyped Input (untitled) - input = service.createInput({ options: { selection: { startLineNumber: 1, startColumn: 1 } } }); + input = service.createEditorInput({ options: { selection: { startLineNumber: 1, startColumn: 1 } } }); assert(input instanceof UntitledTextEditorInput); // Untyped Input (untitled with contents) - input = service.createInput({ contents: 'Hello Untitled', options: { selection: { startLineNumber: 1, startColumn: 1 } } }); + input = service.createEditorInput({ contents: 'Hello Untitled', options: { selection: { startLineNumber: 1, startColumn: 1 } } }); assert(input instanceof UntitledTextEditorInput); let model = await input.resolve() as UntitledTextEditorModel; assert.equal(model.textEditorModel!.getValue(), 'Hello Untitled'); // Untyped Input (untitled with mode) - input = service.createInput({ mode, options: { selection: { startLineNumber: 1, startColumn: 1 } } }); + input = service.createEditorInput({ mode, options: { selection: { startLineNumber: 1, startColumn: 1 } } }); assert(input instanceof UntitledTextEditorInput); model = await input.resolve() as UntitledTextEditorModel; assert.equal(model.getMode(), mode); // Untyped Input (untitled with file path) - input = service.createInput({ resource: URI.file('/some/path.txt'), forceUntitled: true, options: { selection: { startLineNumber: 1, startColumn: 1 } } }); + input = service.createEditorInput({ resource: URI.file('/some/path.txt'), forceUntitled: true, options: { selection: { startLineNumber: 1, startColumn: 1 } } }); assert(input instanceof UntitledTextEditorInput); assert.ok((input as UntitledTextEditorInput).model.hasAssociatedFilePath); // Untyped Input (untitled with untitled resource) - input = service.createInput({ resource: URI.parse('untitled://Untitled-1'), forceUntitled: true, options: { selection: { startLineNumber: 1, startColumn: 1 } } }); + input = service.createEditorInput({ resource: URI.parse('untitled://Untitled-1'), forceUntitled: true, options: { selection: { startLineNumber: 1, startColumn: 1 } } }); assert(input instanceof UntitledTextEditorInput); assert.ok(!(input as UntitledTextEditorInput).model.hasAssociatedFilePath); // Untyped Input (untitled with custom resource) const provider = instantiationService.createInstance(FileServiceProvider, 'untitled-custom'); - input = service.createInput({ resource: URI.parse('untitled-custom://some/path'), forceUntitled: true, options: { selection: { startLineNumber: 1, startColumn: 1 } } }); + input = service.createEditorInput({ resource: URI.parse('untitled-custom://some/path'), forceUntitled: true, options: { selection: { startLineNumber: 1, startColumn: 1 } } }); assert(input instanceof UntitledTextEditorInput); assert.ok((input as UntitledTextEditorInput).model.hasAssociatedFilePath); provider.dispose(); // Untyped Input (resource) - input = service.createInput({ resource: URI.parse('custom:resource') }); + input = service.createEditorInput({ resource: URI.parse('custom:resource') }); assert(input instanceof ResourceEditorInput); // Untyped Input (diff) - input = service.createInput({ + input = service.createEditorInput({ leftResource: toResource.call(this, '/master.html'), rightResource: toResource.call(this, '/detail.html') }); diff --git a/src/vs/workbench/services/history/browser/history.ts b/src/vs/workbench/services/history/browser/history.ts index ef015a8c814..8d2d923d7ce 100644 --- a/src/vs/workbench/services/history/browser/history.ts +++ b/src/vs/workbench/services/history/browser/history.ts @@ -5,7 +5,7 @@ import { URI, UriComponents } from 'vs/base/common/uri'; import { IEditor } from 'vs/editor/common/editorCommon'; -import { ITextEditorOptions, IResourceInput, TextEditorSelectionRevealType } from 'vs/platform/editor/common/editor'; +import { ITextEditorOptions, IResourceEditorInput, TextEditorSelectionRevealType } from 'vs/platform/editor/common/editor'; import { IEditorInput, IEditorPane, Extensions as EditorExtensions, EditorInput, IEditorCloseEvent, IEditorInputFactoryRegistry, toResource, IEditorIdentifier, GroupIdentifier, EditorsOrder } from 'vs/workbench/common/editor'; import { IEditorService } from 'vs/workbench/services/editor/common/editorService'; import { IHistoryService } from 'vs/workbench/services/history/common/history'; @@ -82,7 +82,7 @@ interface ISerializedEditorHistoryEntry { } interface IStackEntry { - input: IEditorInput | IResourceInput; + input: IEditorInput | IResourceEditorInput; selection?: Selection; } @@ -245,7 +245,7 @@ export class HistoryService extends Disposable implements IHistoryService { disposables.add(toDispose); } - private clearOnEditorDispose(editor: IEditorInput | IResourceInput | FileChangesEvent, mapEditorToDispose: Map): void { + private clearOnEditorDispose(editor: IEditorInput | IResourceEditorInput | FileChangesEvent, mapEditorToDispose: Map): void { if (editor instanceof EditorInput) { const disposables = mapEditorToDispose.get(editor); if (disposables) { @@ -255,21 +255,21 @@ export class HistoryService extends Disposable implements IHistoryService { } } - remove(input: IEditorInput | IResourceInput): void; + remove(input: IEditorInput | IResourceEditorInput): void; remove(input: FileChangesEvent): void; - remove(arg1: IEditorInput | IResourceInput | FileChangesEvent): void { + remove(arg1: IEditorInput | IResourceEditorInput | FileChangesEvent): void { this.removeFromHistory(arg1); this.removeFromNavigationStack(arg1); this.removeFromRecentlyClosedFiles(arg1); this.removeFromRecentlyOpened(arg1); } - private removeFromRecentlyOpened(arg1: IEditorInput | IResourceInput | FileChangesEvent): void { + private removeFromRecentlyOpened(arg1: IEditorInput | IResourceEditorInput | FileChangesEvent): void { if (arg1 instanceof EditorInput || arg1 instanceof FileChangesEvent) { return; // for now do not delete from file events since recently open are likely out of workspace files for which there are no delete events } - const input = arg1 as IResourceInput; + const input = arg1 as IResourceEditorInput; this.workspacesService.removeRecentlyOpened([input.resource]); } @@ -355,7 +355,7 @@ export class HistoryService extends Disposable implements IHistoryService { return this.editorService.openEditor(location.input, options); } - return this.editorService.openEditor({ resource: (location.input as IResourceInput).resource, options }); + return this.editorService.openEditor({ resource: (location.input as IResourceEditorInput).resource, options }); } private handleEditorEventInNavigationStack(control: IEditorPane | undefined, event?: ICursorPositionChangedEvent): void { @@ -458,8 +458,8 @@ export class HistoryService extends Disposable implements IHistoryService { } } - const stackInput = this.preferResourceInput(input); - const entry = { input: stackInput, selection }; + const stackEditorInput = this.preferResourceEditorInput(input); + const entry = { input: stackEditorInput, selection }; // Replace at current position let removedEntries: IStackEntry[] = []; @@ -499,15 +499,15 @@ export class HistoryService extends Disposable implements IHistoryService { // Remove this from the stack unless the stack input is a resource // that can easily be restored even when the input gets disposed - if (stackInput instanceof EditorInput) { - this.onEditorDispose(stackInput, () => this.removeFromNavigationStack(stackInput), this.editorStackListeners); + if (stackEditorInput instanceof EditorInput) { + this.onEditorDispose(stackEditorInput, () => this.removeFromNavigationStack(stackEditorInput), this.editorStackListeners); } // Context Keys this.updateContextKeys(); } - private preferResourceInput(input: IEditorInput): IEditorInput | IResourceInput { + private preferResourceEditorInput(input: IEditorInput): IEditorInput | IResourceEditorInput { const resource = input.resource; if (resource && (resource.scheme === Schemas.file || resource.scheme === Schemas.vscodeRemote || resource.scheme === Schemas.userData)) { // for now, only prefer well known schemes that we control to prevent @@ -530,7 +530,7 @@ export class HistoryService extends Disposable implements IHistoryService { return selectionA.startLineNumber === selectionB.startLineNumber; // we consider the history entry same if we are on the same line } - private removeFromNavigationStack(arg1: IEditorInput | IResourceInput | FileChangesEvent): void { + private removeFromNavigationStack(arg1: IEditorInput | IResourceEditorInput | FileChangesEvent): void { this.navigationStack = this.navigationStack.filter(e => { const matches = this.matches(arg1, e.input); @@ -548,15 +548,15 @@ export class HistoryService extends Disposable implements IHistoryService { this.updateContextKeys(); } - private matches(arg1: IEditorInput | IResourceInput | FileChangesEvent, inputB: IEditorInput | IResourceInput): boolean { + private matches(arg1: IEditorInput | IResourceEditorInput | FileChangesEvent, inputB: IEditorInput | IResourceEditorInput): boolean { if (arg1 instanceof FileChangesEvent) { if (inputB instanceof EditorInput) { - return false; // we only support this for IResourceInput + return false; // we only support this for IResourceEditorInput } - const resourceInputB = inputB as IResourceInput; + const resourceEditorInputB = inputB as IResourceEditorInput; - return arg1.contains(resourceInputB.resource, FileChangeType.DELETED); + return arg1.contains(resourceEditorInputB.resource, FileChangeType.DELETED); } if (arg1 instanceof EditorInput && inputB instanceof EditorInput) { @@ -564,20 +564,20 @@ export class HistoryService extends Disposable implements IHistoryService { } if (arg1 instanceof EditorInput) { - return this.matchesFile((inputB as IResourceInput).resource, arg1); + return this.matchesFile((inputB as IResourceEditorInput).resource, arg1); } if (inputB instanceof EditorInput) { - return this.matchesFile((arg1 as IResourceInput).resource, inputB); + return this.matchesFile((arg1 as IResourceEditorInput).resource, inputB); } - const resourceInputA = arg1 as IResourceInput; - const resourceInputB = inputB as IResourceInput; + const resourceEditorInputA = arg1 as IResourceEditorInput; + const resourceEditorInputB = inputB as IResourceEditorInput; - return resourceInputA && resourceInputB && resourceInputA.resource.toString() === resourceInputB.resource.toString(); + return resourceEditorInputA && resourceEditorInputB && resourceEditorInputA.resource.toString() === resourceEditorInputB.resource.toString(); } - private matchesFile(resource: URI, arg2: IEditorInput | IResourceInput | FileChangesEvent): boolean { + private matchesFile(resource: URI, arg2: IEditorInput | IResourceEditorInput | FileChangesEvent): boolean { if (arg2 instanceof FileChangesEvent) { return arg2.contains(resource, FileChangeType.DELETED); } @@ -595,9 +595,9 @@ export class HistoryService extends Disposable implements IHistoryService { return inputResource.toString() === resource.toString(); } - const resourceInput = arg2 as IResourceInput; + const resourceEditorInput = arg2 as IResourceEditorInput; - return resourceInput?.resource.toString() === resource.toString(); + return resourceEditorInput?.resource.toString() === resource.toString(); } //#endregion @@ -666,7 +666,7 @@ export class HistoryService extends Disposable implements IHistoryService { return false; } - private removeFromRecentlyClosedFiles(arg1: IEditorInput | IResourceInput | FileChangesEvent): void { + private removeFromRecentlyClosedFiles(arg1: IEditorInput | IResourceEditorInput | FileChangesEvent): void { this.recentlyClosedFiles = this.recentlyClosedFiles.filter(e => !this.matchesFile(e.resource, arg1)); this.canReopenClosedEditorContextKey.set(this.recentlyClosedFiles.length > 0); } @@ -716,7 +716,7 @@ export class HistoryService extends Disposable implements IHistoryService { private static readonly MAX_HISTORY_ITEMS = 200; private static readonly HISTORY_STORAGE_KEY = 'history.entries'; - private history: Array | undefined = undefined; + private history: Array | undefined = undefined; private readonly resourceFilter = this._register(this.instantiationService.createInstance( ResourceGlobMatcher, @@ -738,7 +738,7 @@ export class HistoryService extends Disposable implements IHistoryService { return; } - const historyInput = this.preferResourceInput(input); + const historyInput = this.preferResourceEditorInput(input); // Remove any existing entry and add to the beginning this.ensureHistoryLoaded(this.history); @@ -757,14 +757,14 @@ export class HistoryService extends Disposable implements IHistoryService { } } - private include(input: IEditorInput | IResourceInput): boolean { + private include(input: IEditorInput | IResourceEditorInput): boolean { if (input instanceof EditorInput) { return true; // include any non files } - const resourceInput = input as IResourceInput; + const resourceEditorInput = input as IResourceEditorInput; - return !this.resourceFilter.matches(resourceInput.resource); + return !this.resourceFilter.matches(resourceEditorInput.resource); } private removeExcludedFromHistory(): void { @@ -782,7 +782,7 @@ export class HistoryService extends Disposable implements IHistoryService { }); } - private removeFromHistory(arg1: IEditorInput | IResourceInput | FileChangesEvent): void { + private removeFromHistory(arg1: IEditorInput | IResourceEditorInput | FileChangesEvent): void { this.ensureHistoryLoaded(this.history); this.history = this.history.filter(e => { @@ -804,19 +804,19 @@ export class HistoryService extends Disposable implements IHistoryService { this.editorHistoryListeners.clear(); } - getHistory(): ReadonlyArray { + getHistory(): ReadonlyArray { this.ensureHistoryLoaded(this.history); return this.history.slice(0); } - private ensureHistoryLoaded(history: Array | undefined): asserts history { + private ensureHistoryLoaded(history: Array | undefined): asserts history { if (!this.history) { this.history = this.loadHistory(); } } - private loadHistory(): Array { + private loadHistory(): Array { let entries: ISerializedEditorHistoryEntry[] = []; const entriesRaw = this.storageService.get(HistoryService.HISTORY_STORAGE_KEY, StorageScope.WORKSPACE); @@ -835,7 +835,7 @@ export class HistoryService extends Disposable implements IHistoryService { })); } - private safeLoadHistoryEntry(registry: IEditorInputFactoryRegistry, entry: ISerializedEditorHistoryEntry): IEditorInput | IResourceInput | undefined { + private safeLoadHistoryEntry(registry: IEditorInputFactoryRegistry, entry: ISerializedEditorHistoryEntry): IEditorInput | IResourceEditorInput | undefined { const serializedEditorHistoryEntry = entry; // File resource: via URI.revive() @@ -882,7 +882,7 @@ export class HistoryService extends Disposable implements IHistoryService { // File resource: via URI.toJSON() else { - return { resourceJSON: (input as IResourceInput).resource.toJSON() }; + return { resourceJSON: (input as IResourceEditorInput).resource.toJSON() }; } return undefined; @@ -919,12 +919,12 @@ export class HistoryService extends Disposable implements IHistoryService { continue; } - const resourceInput = input as IResourceInput; - if (schemeFilter && resourceInput.resource.scheme !== schemeFilter) { + const resourceEditorInput = input as IResourceEditorInput; + if (schemeFilter && resourceEditorInput.resource.scheme !== schemeFilter) { continue; } - const resourceWorkspace = this.contextService.getWorkspaceFolder(resourceInput.resource); + const resourceWorkspace = this.contextService.getWorkspaceFolder(resourceEditorInput.resource); if (resourceWorkspace) { return resourceWorkspace.uri; } @@ -947,7 +947,7 @@ export class HistoryService extends Disposable implements IHistoryService { if (input instanceof EditorInput) { resource = toResource(input, { filterByScheme }); } else { - resource = (input as IResourceInput).resource; + resource = (input as IResourceEditorInput).resource; } if (resource?.scheme === filterByScheme) { diff --git a/src/vs/workbench/services/history/common/history.ts b/src/vs/workbench/services/history/common/history.ts index 598a446f9df..04349f87efe 100644 --- a/src/vs/workbench/services/history/common/history.ts +++ b/src/vs/workbench/services/history/common/history.ts @@ -4,7 +4,7 @@ *--------------------------------------------------------------------------------------------*/ import { createDecorator } from 'vs/platform/instantiation/common/instantiation'; -import { IResourceInput } from 'vs/platform/editor/common/editor'; +import { IResourceEditorInput } from 'vs/platform/editor/common/editor'; import { IEditorInput, GroupIdentifier } from 'vs/workbench/common/editor'; import { URI } from 'vs/base/common/uri'; @@ -42,7 +42,7 @@ export interface IHistoryService { /** * Removes an entry from history. */ - remove(input: IEditorInput | IResourceInput): void; + remove(input: IEditorInput | IResourceEditorInput): void; /** * Clears all history. @@ -57,7 +57,7 @@ export interface IHistoryService { /** * Get the entire history of editors that were opened. */ - getHistory(): ReadonlyArray; + getHistory(): ReadonlyArray; /** * Looking at the editor history, returns the workspace root of the last file that was diff --git a/src/vs/workbench/services/preferences/browser/preferencesService.ts b/src/vs/workbench/services/preferences/browser/preferencesService.ts index ad1b43d5886..d709b09b412 100644 --- a/src/vs/workbench/services/preferences/browser/preferencesService.ts +++ b/src/vs/workbench/services/preferences/browser/preferencesService.ts @@ -489,7 +489,7 @@ export class PreferencesService extends Disposable implements IPreferencesServic private getOrCreateEditableSettingsEditorInput(target: ConfigurationTarget, resource: URI): Promise { return this.createSettingsIfNotExists(target, resource) - .then(() => this.editorService.createInput({ resource })); + .then(() => this.editorService.createEditorInput({ resource })); } private createEditableSettingsEditorModel(configurationTarget: ConfigurationTarget, settingsUri: URI): Promise { diff --git a/src/vs/workbench/services/textfile/test/browser/textFileEditorModel.test.ts b/src/vs/workbench/services/textfile/test/browser/textFileEditorModel.test.ts index b61434bb1bc..1382a73a73f 100644 --- a/src/vs/workbench/services/textfile/test/browser/textFileEditorModel.test.ts +++ b/src/vs/workbench/services/textfile/test/browser/textFileEditorModel.test.ts @@ -8,7 +8,7 @@ import { IInstantiationService } from 'vs/platform/instantiation/common/instanti import { EncodingMode } from 'vs/workbench/common/editor'; import { TextFileEditorModel } from 'vs/workbench/services/textfile/common/textFileEditorModel'; import { TextFileEditorModelState, snapshotToString } from 'vs/workbench/services/textfile/common/textfiles'; -import { createFileInput, workbenchInstantiationService, TestServiceAccessor, TestReadonlyTextFileEditorModel } from 'vs/workbench/test/browser/workbenchTestServices'; +import { createFileEditorInput, workbenchInstantiationService, TestServiceAccessor, TestReadonlyTextFileEditorModel } from 'vs/workbench/test/browser/workbenchTestServices'; import { toResource } from 'vs/base/test/common/utils'; import { TextFileEditorModelManager } from 'vs/workbench/services/textfile/common/textFileEditorModelManager'; import { FileOperationResult, FileOperationError } from 'vs/platform/files/common/files'; @@ -469,8 +469,8 @@ suite('Files - TextFileEditorModel', () => { }); test('save() and isDirty() - proper with check for mtimes', async function () { - const input1 = createFileInput(instantiationService, toResource.call(this, '/path/index_async2.txt')); - const input2 = createFileInput(instantiationService, toResource.call(this, '/path/index_async.txt')); + const input1 = createFileEditorInput(instantiationService, toResource.call(this, '/path/index_async2.txt')); + const input2 = createFileEditorInput(instantiationService, toResource.call(this, '/path/index_async.txt')); const model1 = await input1.resolve() as TextFileEditorModel; const model2 = await input2.resolve() as TextFileEditorModel; diff --git a/src/vs/workbench/test/browser/parts/editor/baseEditor.test.ts b/src/vs/workbench/test/browser/parts/editor/baseEditor.test.ts index e76d0813009..d5d30e62aae 100644 --- a/src/vs/workbench/test/browser/parts/editor/baseEditor.test.ts +++ b/src/vs/workbench/test/browser/parts/editor/baseEditor.test.ts @@ -92,7 +92,7 @@ class MyOtherInput extends EditorInput { return null; } } -class MyResourceInput extends ResourceEditorInput { } +class MyResourceEditorInput extends ResourceEditorInput { } suite('Workbench base editor', () => { @@ -153,11 +153,11 @@ suite('Workbench base editor', () => { test('Editor Lookup favors specific class over superclass (match on specific class)', function () { let d1 = EditorDescriptor.create(MyEditor, 'id1', 'name'); - const disposable = EditorRegistry.registerEditor(d1, [new SyncDescriptor(MyResourceInput)]); + const disposable = EditorRegistry.registerEditor(d1, [new SyncDescriptor(MyResourceEditorInput)]); let inst = workbenchInstantiationService(); - const editor = EditorRegistry.getEditor(inst.createInstance(MyResourceInput, 'fake', '', URI.file('/fake'), undefined))!.instantiate(inst); + const editor = EditorRegistry.getEditor(inst.createInstance(MyResourceEditorInput, 'fake', '', URI.file('/fake'), undefined))!.instantiate(inst); assert.strictEqual(editor.getId(), 'myEditor'); const otherEditor = EditorRegistry.getEditor(inst.createInstance(ResourceEditorInput, 'fake', '', URI.file('/fake'), undefined))!.instantiate(inst); @@ -169,7 +169,7 @@ suite('Workbench base editor', () => { test('Editor Lookup favors specific class over superclass (match on super class)', function () { let inst = workbenchInstantiationService(); - const editor = EditorRegistry.getEditor(inst.createInstance(MyResourceInput, 'fake', '', URI.file('/fake'), undefined))!.instantiate(inst); + const editor = EditorRegistry.getEditor(inst.createInstance(MyResourceEditorInput, 'fake', '', URI.file('/fake'), undefined))!.instantiate(inst); assert.strictEqual('workbench.editors.textResourceEditor', editor.getId()); }); diff --git a/src/vs/workbench/test/browser/workbenchTestServices.ts b/src/vs/workbench/test/browser/workbenchTestServices.ts index 7734a323a96..b2020ee1b03 100644 --- a/src/vs/workbench/test/browser/workbenchTestServices.ts +++ b/src/vs/workbench/test/browser/workbenchTestServices.ts @@ -10,7 +10,7 @@ import * as resources from 'vs/base/common/resources'; import { URI } from 'vs/base/common/uri'; import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry'; import { NullTelemetryService } from 'vs/platform/telemetry/common/telemetryUtils'; -import { IEditorInputWithOptions, CloseDirection, IEditorIdentifier, IUntitledTextResourceInput, IResourceDiffInput, IEditorInput, IEditorPane, IEditorCloseEvent, IEditorPartOptions, IRevertOptions, GroupIdentifier, EditorInput, EditorOptions, EditorsOrder, IFileEditorInput, IEditorInputFactoryRegistry, IEditorInputFactory, Extensions as EditorExtensions, ISaveOptions, IMoveResult, ITextEditorPane, ITextDiffEditorPane, IVisibleEditorPane } from 'vs/workbench/common/editor'; +import { IEditorInputWithOptions, CloseDirection, IEditorIdentifier, IUntitledTextResourceEditorInput, IResourceDiffEditorInput, IEditorInput, IEditorPane, IEditorCloseEvent, IEditorPartOptions, IRevertOptions, GroupIdentifier, EditorInput, EditorOptions, EditorsOrder, IFileEditorInput, IEditorInputFactoryRegistry, IEditorInputFactory, Extensions as EditorExtensions, ISaveOptions, IMoveResult, ITextEditorPane, ITextDiffEditorPane, IVisibleEditorPane } from 'vs/workbench/common/editor'; import { IEditorOpeningEvent, EditorServiceImpl, IEditorGroupView, IEditorGroupsAccessor } from 'vs/workbench/browser/parts/editor/editor'; import { Event, Emitter } from 'vs/base/common/event'; import { IBackupFileService, IResolvedBackup } from 'vs/workbench/services/backup/common/backup'; @@ -18,7 +18,7 @@ import { IConfigurationService, ConfigurationTarget } from 'vs/platform/configur import { IWorkbenchLayoutService, Parts, Position as PartPosition } from 'vs/workbench/services/layout/browser/layoutService'; import { TextModelResolverService } from 'vs/workbench/services/textmodelResolver/common/textModelResolverService'; import { ITextModelService } from 'vs/editor/common/services/resolverService'; -import { IEditorOptions, IResourceInput, IEditorModel, ITextEditorOptions } from 'vs/platform/editor/common/editor'; +import { IEditorOptions, IResourceEditorInput, IEditorModel, ITextEditorOptions } from 'vs/platform/editor/common/editor'; import { IUntitledTextEditorService, UntitledTextEditorService } from 'vs/workbench/services/untitled/common/untitledTextEditorService'; import { IWorkspaceContextService } from 'vs/platform/workspace/common/workspace'; import { ILifecycleService, BeforeShutdownEvent, ShutdownReason, StartupKind, LifecyclePhase, WillShutdownEvent } from 'vs/platform/lifecycle/common/lifecycle'; @@ -107,7 +107,7 @@ export import TestWorkingCopyService = CommonWorkbenchTestServices.TestWorkingCo import { ICodeEditor } from 'vs/editor/browser/editorBrowser'; import { IDiffEditor } from 'vs/editor/common/editorCommon'; -export function createFileInput(instantiationService: IInstantiationService, resource: URI): FileEditorInput { +export function createFileEditorInput(instantiationService: IInstantiationService, resource: URI): FileEditorInput { return instantiationService.createInstance(FileEditorInput, resource, undefined, undefined); } @@ -315,10 +315,10 @@ export class TestHistoryService implements IHistoryService { forward(): void { } back(): void { } last(): void { } - remove(_input: IEditorInput | IResourceInput): void { } + remove(_input: IEditorInput | IResourceEditorInput): void { } clear(): void { } clearRecentlyOpened(): void { } - getHistory(): ReadonlyArray { return []; } + getHistory(): ReadonlyArray { return []; } openNextRecentlyUsedEditor(group?: GroupIdentifier): void { } openPreviouslyUsedEditor(group?: GroupIdentifier): void { } getLastActiveWorkspaceRoot(_schemeFilter: string): URI | undefined { return this.root; } @@ -541,7 +541,7 @@ export class TestEditorGroupView implements IEditorGroupView { getIndexOfEditor(_editor: IEditorInput): number { return -1; } openEditor(_editor: IEditorInput, _options?: IEditorOptions): Promise { throw new Error('not implemented'); } openEditors(_editors: IEditorInputWithOptions[]): Promise { throw new Error('not implemented'); } - isOpened(_editor: IEditorInput | IResourceInput): boolean { return false; } + isOpened(_editor: IEditorInput | IResourceEditorInput): boolean { return false; } isPinned(_editor: IEditorInput): boolean { return false; } isActive(_editor: IEditorInput): boolean { return false; } moveEditor(_editor: IEditorInput, _target: IEditorGroup, _options?: IMoveEditorOptions): void { } @@ -609,8 +609,8 @@ export class TestEditorService implements EditorServiceImpl { getEditors() { return []; } overrideOpenEditor(_handler: IOpenEditorOverrideHandler): IDisposable { return toDisposable(() => undefined); } openEditor(editor: IEditorInput, options?: IEditorOptions | ITextEditorOptions, group?: IEditorGroup | GroupIdentifier | SIDE_GROUP_TYPE | ACTIVE_GROUP_TYPE): Promise; - openEditor(editor: IResourceInput | IUntitledTextResourceInput, group?: IEditorGroup | GroupIdentifier | SIDE_GROUP_TYPE | ACTIVE_GROUP_TYPE): Promise; - openEditor(editor: IResourceDiffInput, group?: IEditorGroup | GroupIdentifier | SIDE_GROUP_TYPE | ACTIVE_GROUP_TYPE): Promise; + openEditor(editor: IResourceEditorInput | IUntitledTextResourceEditorInput, group?: IEditorGroup | GroupIdentifier | SIDE_GROUP_TYPE | ACTIVE_GROUP_TYPE): Promise; + openEditor(editor: IResourceDiffEditorInput, group?: IEditorGroup | GroupIdentifier | SIDE_GROUP_TYPE | ACTIVE_GROUP_TYPE): Promise; async openEditor(editor: IEditorInput | IResourceEditor, optionsOrGroup?: IEditorOptions | ITextEditorOptions | IEditorGroup | GroupIdentifier | SIDE_GROUP_TYPE | ACTIVE_GROUP_TYPE, group?: IEditorGroup | GroupIdentifier | SIDE_GROUP_TYPE | ACTIVE_GROUP_TYPE): Promise { throw new Error('not implemented'); } @@ -622,10 +622,10 @@ export class TestEditorService implements EditorServiceImpl { return [this.editorGroupService.activeGroup, editor as EditorInput, undefined]; } openEditors(_editors: any, _group?: any): Promise { throw new Error('not implemented'); } - isOpen(_editor: IEditorInput | IResourceInput): boolean { return false; } + isOpen(_editor: IEditorInput | IResourceEditorInput): boolean { return false; } replaceEditors(_editors: any, _group: any) { return Promise.resolve(undefined); } invokeWithinEditorContext(fn: (accessor: ServicesAccessor) => T): T { throw new Error('not implemented'); } - createInput(_input: IResourceInput | IUntitledTextResourceInput | IResourceDiffInput): EditorInput { throw new Error('not implemented'); } + createEditorInput(_input: IResourceEditorInput | IUntitledTextResourceEditorInput | IResourceDiffEditorInput): EditorInput { throw new Error('not implemented'); } save(editors: IEditorIdentifier[], options?: ISaveEditorsOptions): Promise { throw new Error('Method not implemented.'); } saveAll(options?: ISaveEditorsOptions): Promise { throw new Error('Method not implemented.'); } revert(editors: IEditorIdentifier[], options?: IRevertOptions): Promise { throw new Error('Method not implemented.'); }