move onDidRename to filesystem-events things, #43768

extensions/typescript-language-features/src/features/updatePathsOnRename.ts

@@ -34,8 +34,8 @@ export class UpdateImportsOnFileRenameHandler {
 		private readonly fileConfigurationManager: FileConfigurationManager,
 		private readonly _handles: (uri: vscode.Uri) => Promise<boolean>,
 	) {
-		this._onDidRenameSub = vscode.workspace.onDidRenameResource(e => {
-			this.doRename(e.oldResource, e.newResource);
+		this._onDidRenameSub = vscode.workspace.onDidRenameFile(e => {
+			this.doRename(e.oldUri, e.newUri);
 		});
 	}
 

src/vs/vscode.proposed.d.ts

@@ -629,13 +629,13 @@ declare module 'vscode' {
 	//#endregion
 
 	//#region mjbvz: File rename events
-	export interface ResourceRenamedEvent {
-		readonly oldResource: Uri;
-		readonly newResource: Uri;
+	export interface FileRenameEvent {
+		readonly oldUri: Uri;
+		readonly newUri: Uri;
 	}
 
 	export namespace workspace {
-		export const onDidRenameResource: Event<ResourceRenamedEvent>;
+		export const onDidRenameFile: Event<FileRenameEvent>;
 	}
 	//#endregion
 

src/vs/workbench/api/electron-browser/mainThreadDocuments.ts

@@ -10,7 +10,7 @@ import { IModelService, shouldSynchronizeModel } from 'vs/editor/common/services
 import { IDisposable, dispose, IReference } from 'vs/base/common/lifecycle';
 import { TextFileModelChangeEvent, ITextFileService } from 'vs/workbench/services/textfile/common/textfiles';
 import { TPromise } from 'vs/base/common/winjs.base';
-import { IFileService, FileOperation } from 'vs/platform/files/common/files';
+import { IFileService } from 'vs/platform/files/common/files';
 import { IModeService } from 'vs/editor/common/services/modeService';
 import { IUntitledEditorService } from 'vs/workbench/services/untitled/common/untitledEditorService';
 import { ExtHostContext, MainThreadDocumentsShape, ExtHostDocumentsShape, IExtHostContext } from '../node/extHost.protocol';
@@ -119,12 +119,6 @@ export class MainThreadDocuments implements MainThreadDocumentsShape {
 			}
 		}));
 
-		this._toDispose.push(fileService.onAfterOperation(e => {
-			if (e.operation === FileOperation.MOVE) {
-				this._proxy.$onDidRename(e.resource, e.target.resource);
-			}
-		}));
-
 		this._modelToDisposeMap = Object.create(null);
 	}
 

src/vs/workbench/api/electron-browser/mainThreadFileSystemEventService.ts

@@ -4,15 +4,16 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import { FileChangeType, IFileService } from 'vs/platform/files/common/files';
-import { ExtHostContext, ExtHostFileSystemEventServiceShape, FileSystemEvents, IExtHostContext } from '../node/extHost.protocol';
 import { IDisposable } from 'vs/base/common/lifecycle';
+import { FileChangeType, IFileService, FileOperation } from 'vs/platform/files/common/files';
 import { extHostCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
+import { ExtHostContext, ExtHostFileSystemEventServiceShape, FileSystemEvents, IExtHostContext } from '../node/extHost.protocol';
 
 @extHostCustomer
 export class MainThreadFileSystemEventService {
 
-	private readonly _listener: IDisposable;
+	private readonly _fileEventListener: IDisposable;
+	private readonly _fileOperationListener: IDisposable;
 
 	constructor(
 		extHostContext: IExtHostContext,
@@ -20,13 +21,14 @@ export class MainThreadFileSystemEventService {
 	) {
 
 		const proxy: ExtHostFileSystemEventServiceShape = extHostContext.getProxy(ExtHostContext.ExtHostFileSystemEventService);
+
+		// file system events - (changes the editor and other make)
 		const events: FileSystemEvents = {
 			created: [],
 			changed: [],
 			deleted: []
 		};
-
-		this._listener = fileService.onFileChanges(event => {
+		this._fileEventListener = fileService.onFileChanges(event => {
 			for (let change of event.changes) {
 				switch (change.type) {
 					case FileChangeType.ADDED:
@@ -46,9 +48,17 @@ export class MainThreadFileSystemEventService {
 			events.changed.length = 0;
 			events.deleted.length = 0;
 		});
+
+		// file operation events - (changes the editor makes)
+		this._fileOperationListener = fileService.onAfterOperation(e => {
+			if (e.operation === FileOperation.MOVE) {
+				proxy.$onFileRename(e.resource, e.target.resource);
+			}
+		});
 	}
 
 	dispose(): void {
-		this._listener.dispose();
+		this._fileEventListener.dispose();
+		this._fileOperationListener.dispose();
 	}
 }

src/vs/workbench/api/node/extHost.api.impl.ts

@@ -576,8 +576,8 @@ export function createApiFactory(
 			registerWorkspaceCommentProvider: proposedApiFunction(extension, (provider: vscode.WorkspaceCommentProvider) => {
 				return exthostCommentProviders.registerWorkspaceCommentProvider(provider);
 			}),
-			onDidRenameResource: proposedApiFunction(extension, (listener, thisArg?, disposables?) => {
-				return extHostDocuments.onDidRenameResource(listener, thisArg, disposables);
+			onDidRenameFile: proposedApiFunction(extension, (listener, thisArg?, disposables?) => {
+				return extHostFileSystemEvent.onDidRenameFile(listener, thisArg, disposables);
 			})
 		};
 

src/vs/workbench/api/node/extHost.protocol.ts

@@ -614,7 +614,6 @@ export interface ExtHostDocumentsShape {
 	$acceptModelSaved(strURL: UriComponents): void;
 	$acceptDirtyStateChanged(strURL: UriComponents, isDirty: boolean): void;
 	$acceptModelChanged(strURL: UriComponents, e: IModelChangedEvent, isDirty: boolean): void;
-	$onDidRename(oldURL: UriComponents, newURL: UriComponents): void;
 }
 
 export interface ExtHostDocumentSaveParticipantShape {
@@ -698,6 +697,7 @@ export interface FileSystemEvents {
 }
 export interface ExtHostFileSystemEventServiceShape {
 	$onFileEvent(events: FileSystemEvents): void;
+	$onFileRename(oldUri: UriComponents, newUri: UriComponents): void;
 }
 
 export interface ObjectIdentifier {

src/vs/workbench/api/node/extHostDocuments.ts

@@ -21,13 +21,11 @@ export class ExtHostDocuments implements ExtHostDocumentsShape {
 	private _onDidRemoveDocument = new Emitter<vscode.TextDocument>();
 	private _onDidChangeDocument = new Emitter<vscode.TextDocumentChangeEvent>();
 	private _onDidSaveDocument = new Emitter<vscode.TextDocument>();
-	private _onDidRenameResource = new Emitter<vscode.ResourceRenamedEvent>();
 
 	readonly onDidAddDocument: Event<vscode.TextDocument> = this._onDidAddDocument.event;
 	readonly onDidRemoveDocument: Event<vscode.TextDocument> = this._onDidRemoveDocument.event;
 	readonly onDidChangeDocument: Event<vscode.TextDocumentChangeEvent> = this._onDidChangeDocument.event;
 	readonly onDidSaveDocument: Event<vscode.TextDocument> = this._onDidSaveDocument.event;
-	readonly onDidRenameResource: Event<vscode.ResourceRenamedEvent> = this._onDidRenameResource.event;
 
 	private _toDispose: IDisposable[];
 	private _proxy: MainThreadDocumentsShape;
@@ -150,11 +148,4 @@ export class ExtHostDocuments implements ExtHostDocumentsShape {
 	public setWordDefinitionFor(modeId: string, wordDefinition: RegExp): void {
 		setWordDefinitionFor(modeId, wordDefinition);
 	}
-
-	public $onDidRename(oldURL: UriComponents, newURL: UriComponents): void {
-		const oldResource = URI.revive(oldURL);
-		const newResource = URI.revive(newURL);
-		this._onDidRenameResource.fire({ oldResource, newResource });
-	}
-
 }

src/vs/workbench/api/node/extHostFileSystemEventService.ts

@@ -4,18 +4,18 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import { Event, Emitter } from 'vs/base/common/event';
+import { Emitter, Event } from 'vs/base/common/event';
+import { IRelativePattern, parse } from 'vs/base/common/glob';
+import URI, { UriComponents } from 'vs/base/common/uri';
+import * as vscode from 'vscode';
+import { ExtHostFileSystemEventServiceShape, FileSystemEvents } from './extHost.protocol';
 import { Disposable } from './extHostTypes';
-import { parse, IRelativePattern } from 'vs/base/common/glob';
-import { Uri, FileSystemWatcher as _FileSystemWatcher } from 'vscode';
-import { FileSystemEvents, ExtHostFileSystemEventServiceShape } from './extHost.protocol';
-import URI from 'vs/base/common/uri';
 
-class FileSystemWatcher implements _FileSystemWatcher {
+class FileSystemWatcher implements vscode.FileSystemWatcher {
 
-	private _onDidCreate = new Emitter<Uri>();
-	private _onDidChange = new Emitter<Uri>();
-	private _onDidDelete = new Emitter<Uri>();
+	private _onDidCreate = new Emitter<vscode.Uri>();
+	private _onDidChange = new Emitter<vscode.Uri>();
+	private _onDidDelete = new Emitter<vscode.Uri>();
 	private _disposable: Disposable;
 	private _config: number;
 
@@ -80,31 +80,38 @@ class FileSystemWatcher implements _FileSystemWatcher {
 		this._disposable.dispose();
 	}
 
-	get onDidCreate(): Event<Uri> {
+	get onDidCreate(): Event<vscode.Uri> {
 		return this._onDidCreate.event;
 	}
 
-	get onDidChange(): Event<Uri> {
+	get onDidChange(): Event<vscode.Uri> {
 		return this._onDidChange.event;
 	}
 
-	get onDidDelete(): Event<Uri> {
+	get onDidDelete(): Event<vscode.Uri> {
 		return this._onDidDelete.event;
 	}
 }
 
 export class ExtHostFileSystemEventService implements ExtHostFileSystemEventServiceShape {
 
-	private _emitter = new Emitter<FileSystemEvents>();
+	private _onFileEvent = new Emitter<FileSystemEvents>();
+	private _onDidRenameFile = new Emitter<vscode.FileRenameEvent>();
+
+	readonly onDidRenameFile: Event<vscode.FileRenameEvent> = this._onDidRenameFile.event;
 
 	constructor() {
 	}
 
-	public createFileSystemWatcher(globPattern: string | IRelativePattern, ignoreCreateEvents?: boolean, ignoreChangeEvents?: boolean, ignoreDeleteEvents?: boolean): _FileSystemWatcher {
-		return new FileSystemWatcher(this._emitter.event, globPattern, ignoreCreateEvents, ignoreChangeEvents, ignoreDeleteEvents);
+	public createFileSystemWatcher(globPattern: string | IRelativePattern, ignoreCreateEvents?: boolean, ignoreChangeEvents?: boolean, ignoreDeleteEvents?: boolean): vscode.FileSystemWatcher {
+		return new FileSystemWatcher(this._onFileEvent.event, globPattern, ignoreCreateEvents, ignoreChangeEvents, ignoreDeleteEvents);
 	}
 
 	$onFileEvent(events: FileSystemEvents) {
-		this._emitter.fire(events);
+		this._onFileEvent.fire(events);
+	}
+
+	$onFileRename(oldUri: UriComponents, newUri: UriComponents) {
+		this._onDidRenameFile.fire(Object.freeze({ oldUri: URI.revive(oldUri), newUri: URI.revive(newUri) }));
 	}
 }