Merge VS Code 1.31.1 (#4283)

src/vs/workbench/services/backup/common/backup.ts

@@ -5,7 +5,6 @@
 
 import { URI as Uri } from 'vs/base/common/uri';
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
-import { TPromise } from 'vs/base/common/winjs.base';
 import { IResolveContentOptions, IUpdateContentOptions, ITextSnapshot } from 'vs/platform/files/common/files';
 import { ITextBufferFactory } from 'vs/editor/common/model';
 
@@ -23,7 +22,7 @@ export interface IBackupFileService {
 	/**
 	 * Finds out if there are any backups stored.
 	 */
-	hasBackups(): TPromise<boolean>;
+	hasBackups(): Promise<boolean>;
 
 	/**
 	 * Loads the backup resource for a particular resource within the current workspace.
@@ -31,7 +30,7 @@ export interface IBackupFileService {
 	 * @param resource The resource that is backed up.
 	 * @return The backup resource if any.
 	 */
-	loadBackupResource(resource: Uri): TPromise<Uri | undefined>;
+	loadBackupResource(resource: Uri): Promise<Uri | undefined>;
 
 	/**
 	 * Given a resource, returns the associated backup resource.
@@ -48,14 +47,14 @@ export interface IBackupFileService {
 	 * @param content The content of the resource as snapshot.
 	 * @param versionId The version id of the resource to backup.
 	 */
-	backupResource(resource: Uri, content: ITextSnapshot, versionId?: number): TPromise<void>;
+	backupResource(resource: Uri, content: ITextSnapshot, versionId?: number): Promise<void>;
 
 	/**
 	 * Gets a list of file backups for the current workspace.
 	 *
 	 * @return The list of backups.
 	 */
-	getWorkspaceFileBackups(): TPromise<Uri[]>;
+	getWorkspaceFileBackups(): Promise<Uri[]>;
 
 	/**
 	 * Resolves the backup for the given resource.
@@ -63,18 +62,18 @@ export interface IBackupFileService {
 	 * @param value The contents from a backup resource as stream.
 	 * @return The backup file's backed up content as text buffer factory.
 	 */
-	resolveBackupContent(backup: Uri): TPromise<ITextBufferFactory | undefined>;
+	resolveBackupContent(backup: Uri): Promise<ITextBufferFactory | undefined>;
 
 	/**
 	 * Discards the backup associated with a resource if it exists..
 	 *
 	 * @param resource The resource whose backup is being discarded discard to back up.
 	 */
-	discardResourceBackup(resource: Uri): TPromise<void>;
+	discardResourceBackup(resource: Uri): Promise<void>;
 
 	/**
 	 * Discards all backups associated with the current workspace and prevents further backups from
 	 * being made.
 	 */
-	discardAllWorkspaceBackups(): TPromise<void>;
+	discardAllWorkspaceBackups(): Promise<void>;
 }

src/vs/workbench/services/backup/node/backupFileService.ts

@@ -10,14 +10,13 @@ import { URI as Uri } from 'vs/base/common/uri';
 import { ResourceQueue } from 'vs/base/common/async';
 import { IBackupFileService, BACKUP_FILE_UPDATE_OPTIONS, BACKUP_FILE_RESOLVE_OPTIONS } from 'vs/workbench/services/backup/common/backup';
 import { IFileService, ITextSnapshot } from 'vs/platform/files/common/files';
-import { TPromise } from 'vs/base/common/winjs.base';
 import { readToMatchingString } from 'vs/base/node/stream';
 import { ITextBufferFactory } from 'vs/editor/common/model';
 import { createTextBufferFactoryFromStream, createTextBufferFactoryFromSnapshot } from 'vs/editor/common/model/textModel';
 import { keys } from 'vs/base/common/map';
 
 export interface IBackupFilesModel {
-	resolve(backupRoot: string): TPromise<IBackupFilesModel>;
+	resolve(backupRoot: string): Promise<IBackupFilesModel>;
 
 	add(resource: Uri, versionId?: number): void;
 	has(resource: Uri, versionId?: number): boolean;
@@ -51,11 +50,11 @@ export class BackupSnapshot implements ITextSnapshot {
 export class BackupFilesModel implements IBackupFilesModel {
 	private cache: { [resource: string]: number /* version ID */ } = Object.create(null);
 
-	resolve(backupRoot: string): TPromise<IBackupFilesModel> {
+	resolve(backupRoot: string): Promise<IBackupFilesModel> {
 		return pfs.readDirsInDir(backupRoot).then(backupSchemas => {
 
 			// For all supported schemas
-			return TPromise.join(backupSchemas.map(backupSchema => {
+			return Promise.all(backupSchemas.map(backupSchema => {
 
 				// Read backup directory for backups
 				const backupSchemaPath = path.join(backupRoot, backupSchema);
@@ -114,12 +113,12 @@ export class BackupFileService implements IBackupFileService {
 	private backupWorkspacePath: string;
 
 	private isShuttingDown: boolean;
-	private ready: TPromise<IBackupFilesModel>;
+	private ready: Promise<IBackupFilesModel>;
 	private ioOperationQueues: ResourceQueue; // queue IO operations to ensure write order
 
 	constructor(
 		backupWorkspacePath: string,
-		@IFileService private fileService: IFileService
+		@IFileService private readonly fileService: IFileService
 	) {
 		this.isShuttingDown = false;
 		this.ioOperationQueues = new ResourceQueue();
@@ -133,19 +132,19 @@ export class BackupFileService implements IBackupFileService {
 		this.ready = this.init();
 	}
 
-	private init(): TPromise<IBackupFilesModel> {
+	private init(): Promise<IBackupFilesModel> {
 		const model = new BackupFilesModel();
 
 		return model.resolve(this.backupWorkspacePath);
 	}
 
-	hasBackups(): TPromise<boolean> {
+	hasBackups(): Promise<boolean> {
 		return this.ready.then(model => {
 			return model.count() > 0;
 		});
 	}
 
-	loadBackupResource(resource: Uri): TPromise<Uri | undefined> {
+	loadBackupResource(resource: Uri): Promise<Uri | undefined> {
 		return this.ready.then(model => {
 
 			// Return directly if we have a known backup with that resource
@@ -154,19 +153,19 @@ export class BackupFileService implements IBackupFileService {
 				return backupResource;
 			}
 
-			return void 0;
+			return undefined;
 		});
 	}
 
-	backupResource(resource: Uri, content: ITextSnapshot, versionId?: number): TPromise<void> {
+	backupResource(resource: Uri, content: ITextSnapshot, versionId?: number): Promise<void> {
 		if (this.isShuttingDown) {
-			return TPromise.as(void 0);
+			return Promise.resolve();
 		}
 
 		return this.ready.then(model => {
 			const backupResource = this.toBackupResource(resource);
 			if (model.has(backupResource, versionId)) {
-				return void 0; // return early if backup version id matches requested one
+				return undefined; // return early if backup version id matches requested one
 			}
 
 			return this.ioOperationQueues.queueFor(backupResource).queue(() => {
@@ -178,7 +177,7 @@ export class BackupFileService implements IBackupFileService {
 		});
 	}
 
-	discardResourceBackup(resource: Uri): TPromise<void> {
+	discardResourceBackup(resource: Uri): Promise<void> {
 		return this.ready.then(model => {
 			const backupResource = this.toBackupResource(resource);
 
@@ -188,7 +187,7 @@ export class BackupFileService implements IBackupFileService {
 		});
 	}
 
-	discardAllWorkspaceBackups(): TPromise<void> {
+	discardAllWorkspaceBackups(): Promise<void> {
 		this.isShuttingDown = true;
 
 		return this.ready.then(model => {
@@ -196,9 +195,9 @@ export class BackupFileService implements IBackupFileService {
 		});
 	}
 
-	getWorkspaceFileBackups(): TPromise<Uri[]> {
+	getWorkspaceFileBackups(): Promise<Uri[]> {
 		return this.ready.then(model => {
-			const readPromises: TPromise<Uri>[] = [];
+			const readPromises: Promise<Uri>[] = [];
 
 			model.get().forEach(fileBackup => {
 				readPromises.push(
@@ -206,11 +205,11 @@ export class BackupFileService implements IBackupFileService {
 				);
 			});
 
-			return TPromise.join(readPromises);
+			return Promise.all(readPromises);
 		});
 	}
 
-	resolveBackupContent(backup: Uri): TPromise<ITextBufferFactory> {
+	resolveBackupContent(backup: Uri): Promise<ITextBufferFactory> {
 		return this.fileService.resolveStreamContent(backup, BACKUP_FILE_RESOLVE_OPTIONS).then(content => {
 
 			// Add a filter method to filter out everything until the meta marker
@@ -248,49 +247,49 @@ export class InMemoryBackupFileService implements IBackupFileService {
 
 	private backups: Map<string, ITextSnapshot> = new Map();
 
-	hasBackups(): TPromise<boolean> {
-		return TPromise.as(this.backups.size > 0);
+	hasBackups(): Promise<boolean> {
+		return Promise.resolve(this.backups.size > 0);
 	}
 
-	loadBackupResource(resource: Uri): TPromise<Uri | undefined> {
+	loadBackupResource(resource: Uri): Promise<Uri | undefined> {
 		const backupResource = this.toBackupResource(resource);
 		if (this.backups.has(backupResource.toString())) {
-			return TPromise.as(backupResource);
+			return Promise.resolve(backupResource);
 		}
 
-		return TPromise.as(void 0);
+		return Promise.resolve();
 	}
 
-	backupResource(resource: Uri, content: ITextSnapshot, versionId?: number): TPromise<void> {
+	backupResource(resource: Uri, content: ITextSnapshot, versionId?: number): Promise<void> {
 		const backupResource = this.toBackupResource(resource);
 		this.backups.set(backupResource.toString(), content);
 
-		return TPromise.as(void 0);
+		return Promise.resolve();
 	}
 
-	resolveBackupContent(backupResource: Uri): TPromise<ITextBufferFactory | undefined> {
+	resolveBackupContent(backupResource: Uri): Promise<ITextBufferFactory | undefined> {
 		const snapshot = this.backups.get(backupResource.toString());
 		if (snapshot) {
-			return TPromise.as(createTextBufferFactoryFromSnapshot(snapshot));
+			return Promise.resolve(createTextBufferFactoryFromSnapshot(snapshot));
 		}
 
-		return TPromise.as(void 0);
+		return Promise.resolve();
 	}
 
-	getWorkspaceFileBackups(): TPromise<Uri[]> {
-		return TPromise.as(keys(this.backups).map(key => Uri.parse(key)));
+	getWorkspaceFileBackups(): Promise<Uri[]> {
+		return Promise.resolve(keys(this.backups).map(key => Uri.parse(key)));
 	}
 
-	discardResourceBackup(resource: Uri): TPromise<void> {
+	discardResourceBackup(resource: Uri): Promise<void> {
 		this.backups.delete(this.toBackupResource(resource).toString());
 
-		return TPromise.as(void 0);
+		return Promise.resolve();
 	}
 
-	discardAllWorkspaceBackups(): TPromise<void> {
+	discardAllWorkspaceBackups(): Promise<void> {
 		this.backups.clear();
 
-		return TPromise.as(void 0);
+		return Promise.resolve();
 	}
 
 	toBackupResource(resource: Uri): Uri {

src/vs/workbench/services/backup/test/electron-browser/backupFileService.test.ts

@@ -92,7 +92,7 @@ suite('BackupFileService', () => {
 				service = new TestBackupFileService(workspaceResource, backupHome, workspacesJsonPath);
 				return service.loadBackupResource(fooFile).then(resource => {
 					assert.ok(resource);
-					assert.equal(path.basename(resource.fsPath), path.basename(fooBackupPath));
+					assert.equal(path.basename(resource!.fsPath), path.basename(fooBackupPath));
 					return service.hasBackups().then(hasBackups => {
 						assert.ok(hasBackups);
 					});