From ec02f555f055e05f4ba9b6e486a2a538d221e023 Mon Sep 17 00:00:00 2001
From: Eric Snow <ericsnowcurrently@gmail.com>
Date: Mon, 21 Oct 2019 15:46:20 -0600
Subject: [PATCH 01/25] Use the new API for deleting files and directories.

---
 src/client/common/platform/fileSystem.ts      |  47 ++++++--
 .../platform/filesystem.functional.test.ts    |  84 ++-----------
 src/test/common/platform/filesystem.test.ts   | 113 ++++++++++++++++++
 .../common/platform/filesystem.unit.test.ts   |  24 ++--
 4 files changed, 169 insertions(+), 99 deletions(-)
 create mode 100644 src/test/common/platform/filesystem.test.ts

diff --git a/src/client/common/platform/fileSystem.ts b/src/client/common/platform/fileSystem.ts
index 25886aabc12d..a3b5769c1a40 100644
--- a/src/client/common/platform/fileSystem.ts
+++ b/src/client/common/platform/fileSystem.ts
@@ -112,6 +112,18 @@ export class TempFileSystem {
     }
 }
 
+// This is the parts of the vscode.workspace.fs API that we use here.
+interface INewAPI {
+    //copy(source: vscode.Uri, target: vscode.Uri, options?: {overwrite: boolean}): Thenable<void>;
+    //createDirectory(uri: vscode.Uri): Thenable<void>;
+    delete(uri: vscode.Uri, options?: {recursive: boolean; useTrash: boolean}): Thenable<void>;
+    //readDirectory(uri: vscode.Uri): Thenable<[string, FileType][]>;
+    //readFile(uri: vscode.Uri): Thenable<Uint8Array>;
+    //rename(source: vscode.Uri, target: vscode.Uri, options?: {overwrite: boolean}): Thenable<void>;
+    //stat(uri: vscode.Uri): Thenable<vscode.FileStat>;
+    //writeFile(uri: vscode.Uri, content: Uint8Array): Thenable<void>;
+}
+
 // This is the parts of node's 'fs' module that we use in RawFileSystem.
 interface IRawFS {
     // non-async
@@ -124,13 +136,10 @@ interface IRawFSExtra {
     readFile(path: string, encoding: string): Promise<string>;
     //tslint:disable-next-line:no-any
     writeFile(path: string, data: any, options: any): Promise<void>;
-    unlink(filename: string): Promise<void>;
     stat(filename: string): Promise<fsextra.Stats>;
     lstat(filename: string): Promise<fsextra.Stats>;
     mkdirp(dirname: string): Promise<void>;
-    rmdir(dirname: string): Promise<void>;
     readdir(dirname: string): Promise<string[]>;
-    remove(dirname: string): Promise<void>;
 
     // non-async
     statSync(filename: string): fsextra.Stats;
@@ -151,6 +160,7 @@ interface IRawPath {
 export class RawFileSystem implements IRawFileSystem {
     constructor(
         protected readonly path: IRawPath,
+        protected readonly newapi: INewAPI,
         protected readonly nodefs: IRawFS,
         protected readonly fsExtra: IRawFSExtra
     ) { }
@@ -159,11 +169,31 @@ export class RawFileSystem implements IRawFileSystem {
     public static withDefaults(): RawFileSystem{
         return new RawFileSystem(
             FileSystemPaths.withDefaults(),
+            vscode.workspace.fs,
             fs,
             fsextra
         );
     }
 
+    //****************************
+    // VS Code API
+
+    public async rmtree(dirname: string): Promise<void> {
+        const uri = vscode.Uri.file(dirname);
+        return this.newapi.delete(uri, {
+            recursive: true,
+            useTrash: false
+        });
+    }
+
+    public async rmfile(filename: string): Promise<void> {
+        const uri = vscode.Uri.file(filename);
+        return this.newapi.delete(uri, {
+            recursive: false,
+            useTrash: false
+        });
+    }
+
     //****************************
     // fs-extra
 
@@ -182,15 +212,6 @@ export class RawFileSystem implements IRawFileSystem {
         return this.fsExtra.mkdirp(dirname);
     }
 
-    public async rmtree(dirname: string): Promise<void> {
-        return this.fsExtra.stat(dirname)
-            .then(() => this.fsExtra.remove(dirname));
-    }
-
-    public async rmfile(filename: string): Promise<void> {
-        return this.fsExtra.unlink(filename);
-    }
-
     public async chmod(filename: string, mode: string | number): Promise<void> {
         return this.fsExtra.chmod(filename, mode);
     }
@@ -266,7 +287,7 @@ export class FileSystemUtils implements IFileSystemUtils {
     public static withDefaults(): FileSystemUtils {
         const paths = FileSystemPaths.withDefaults();
         return new FileSystemUtils(
-            new RawFileSystem(paths, fs, fsextra),
+            new RawFileSystem(paths, vscode.workspace.fs, fs, fsextra),
             paths,
             TempFileSystem.withDefaults(),
             getHashString,
diff --git a/src/test/common/platform/filesystem.functional.test.ts b/src/test/common/platform/filesystem.functional.test.ts
index 24419c7369d8..7451271dbcc4 100644
--- a/src/test/common/platform/filesystem.functional.test.ts
+++ b/src/test/common/platform/filesystem.functional.test.ts
@@ -24,23 +24,26 @@ const assertArrays = require('chai-arrays');
 use(assertArrays);
 use(chaiAsPromised);
 
-const WINDOWS = /^win/.test(process.platform);
+// Note: all functional tests that trigger the VS Code "fs" API are
+// found in filesystem.test.ts.
 
-const DOES_NOT_EXIST = 'this file does not exist';
+export const WINDOWS = /^win/.test(process.platform);
 
-async function assertDoesNotExist(filename: string) {
+export const DOES_NOT_EXIST = 'this file does not exist';
+
+export async function assertDoesNotExist(filename: string) {
     await expect(
         fsextra.stat(filename)
     ).to.eventually.be.rejected;
 }
 
-async function assertExists(filename: string) {
+export async function assertExists(filename: string) {
     await expect(
         fsextra.stat(filename)
     ).to.not.eventually.be.rejected;
 }
 
-class FSFixture {
+export class FSFixture {
     public tempDir: tmpMod.SynchrounousResult | undefined;
     public sockServer: net.Server | undefined;
 
@@ -293,41 +296,6 @@ suite('Raw FileSystem', () => {
         });
     });
 
-    suite('rmtree', () => {
-        test('deletes the directory and everything in it', async () => {
-            const dirname = await fix.createDirectory('x');
-            const filename = await fix.createFile('x/y/z/spam.py');
-            await assertExists(filename);
-
-            await filesystem.rmtree(dirname);
-
-            await assertDoesNotExist(dirname);
-        });
-
-        test('fails if the directory does not exist', async () => {
-            const promise = filesystem.rmtree(DOES_NOT_EXIST);
-
-            await expect(promise).to.eventually.be.rejected;
-        });
-    });
-
-    suite('rmfile', () => {
-        test('deletes the file', async () => {
-            const filename = await fix.createFile('x/y/z/spam.py', '...');
-            await assertExists(filename);
-
-            await filesystem.rmfile(filename);
-
-            await assertDoesNotExist(filename);
-        });
-
-        test('fails if the file does not exist', async () => {
-            const promise = filesystem.rmfile(DOES_NOT_EXIST);
-
-            await expect(promise).to.eventually.be.rejected;
-        });
-    });
-
     suite('chmod (non-Windows)', () => {
         suiteSetup(function () {
             // On Windows, chmod won't have any effect on the file itself.
@@ -336,7 +304,6 @@ suite('Raw FileSystem', () => {
                 this.skip();
             }
         });
-
         async function checkMode(filename: string, expected: number) {
             const stat = await fsextra.stat(filename);
             expect(stat.mode & 0o777).to.equal(expected);
@@ -871,41 +838,6 @@ suite('FileSystem Utils', () => {
         });
     });
 
-    suite('isDirReadonly', () => {
-        suite('non-Windows', () => {
-            suiteSetup(function () {
-                if (WINDOWS) {
-                    // tslint:disable-next-line:no-invalid-this
-                    this.skip();
-                }
-            });
-
-            // On Windows, chmod won't have any effect on the file itself.
-            test('is readonly', async () => {
-                const dirname = await fix.createDirectory('x/y/z/spam');
-                await fsextra.chmod(dirname, 0o444);
-
-                const isReadonly = await utils.isDirReadonly(dirname);
-
-                expect(isReadonly).to.equal(true);
-            });
-        });
-
-        test('is not readonly', async () => {
-            const dirname = await fix.createDirectory('x/y/z/spam');
-
-            const isReadonly = await utils.isDirReadonly(dirname);
-
-            expect(isReadonly).to.equal(false);
-        });
-
-        test('fails if the file does not exist', async () => {
-            const promise = utils.isDirReadonly(DOES_NOT_EXIST);
-
-            await expect(promise).to.eventually.be.rejected;
-        });
-    });
-
     suite('getFileHash', () => {
         test('Getting hash for a file should return non-empty string', async () => {
             const filename = await fix.createFile('x/y/z/spam.py');
diff --git a/src/test/common/platform/filesystem.test.ts b/src/test/common/platform/filesystem.test.ts
new file mode 100644
index 000000000000..b7822d51c296
--- /dev/null
+++ b/src/test/common/platform/filesystem.test.ts
@@ -0,0 +1,113 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { expect } from 'chai';
+import * as fsextra from 'fs-extra';
+import {
+    FileSystemUtils, RawFileSystem
+} from '../../../client/common/platform/fileSystem';
+import {
+    IFileSystemUtils, IRawFileSystem
+} from '../../../client/common/platform/types';
+import {
+    DOES_NOT_EXIST, assertDoesNotExist, assertExists, FSFixture, WINDOWS
+} from './filesystem.functional.test';
+
+// Note: all functional tests that do not trigger the VS Code "fs" API
+// are found in filesystem.functional.test.ts.
+
+// tslint:disable:max-func-body-length chai-vague-errors
+
+suite('Raw FileSystem', () => {
+    let filesystem: IRawFileSystem;
+    let fix: FSFixture;
+    setup(() => {
+        filesystem = RawFileSystem.withDefaults();
+        fix = new FSFixture();
+    });
+    teardown(async () => {
+        await fix.cleanUp();
+    });
+
+    suite('rmtree', () => {
+        test('deletes the directory and everything in it', async () => {
+            const dirname = await fix.createDirectory('x');
+            const filename = await fix.createFile('x/y/z/spam.py');
+            await assertExists(filename);
+
+            await filesystem.rmtree(dirname);
+
+            await assertDoesNotExist(dirname);
+        });
+
+        test('fails if the directory does not exist', async () => {
+            const promise = filesystem.rmtree(DOES_NOT_EXIST);
+
+            await expect(promise).to.eventually.be.rejected;
+        });
+    });
+
+    suite('rmfile', () => {
+        test('deletes the file', async () => {
+            const filename = await fix.createFile('x/y/z/spam.py', '...');
+            await assertExists(filename);
+
+            await filesystem.rmfile(filename);
+
+            await assertDoesNotExist(filename);
+        });
+
+        test('fails if the file does not exist', async () => {
+            const promise = filesystem.rmfile(DOES_NOT_EXIST);
+
+            await expect(promise).to.eventually.be.rejected;
+        });
+    });
+});
+
+suite('FileSystem Utils', () => {
+    let utils: IFileSystemUtils;
+    let fix: FSFixture;
+    setup(() => {
+        utils = FileSystemUtils.withDefaults();
+        fix = new FSFixture();
+    });
+    teardown(async () => {
+        await fix.cleanUp();
+    });
+
+    suite('isDirReadonly', () => {
+        suite('non-Windows', () => {
+            suiteSetup(function () {
+                if (WINDOWS) {
+                    // tslint:disable-next-line:no-invalid-this
+                    this.skip();
+                }
+            });
+
+            // On Windows, chmod won't have any effect on the file itself.
+            test('is readonly', async () => {
+                const dirname = await fix.createDirectory('x/y/z/spam');
+                await fsextra.chmod(dirname, 0o444);
+
+                const isReadonly = await utils.isDirReadonly(dirname);
+
+                expect(isReadonly).to.equal(true);
+            });
+        });
+
+        test('is not readonly', async () => {
+            const dirname = await fix.createDirectory('x/y/z/spam');
+
+            const isReadonly = await utils.isDirReadonly(dirname);
+
+            expect(isReadonly).to.equal(false);
+        });
+
+        test('fails if the file does not exist', async () => {
+            const promise = utils.isDirReadonly(DOES_NOT_EXIST);
+
+            await expect(promise).to.eventually.be.rejected;
+        });
+    });
+});
diff --git a/src/test/common/platform/filesystem.unit.test.ts b/src/test/common/platform/filesystem.unit.test.ts
index ac5d7c096109..a7f5a8a225d6 100644
--- a/src/test/common/platform/filesystem.unit.test.ts
+++ b/src/test/common/platform/filesystem.unit.test.ts
@@ -4,7 +4,7 @@
 import { expect } from 'chai';
 import * as fsextra from 'fs-extra';
 import * as TypeMoq from 'typemoq';
-import { Disposable } from 'vscode';
+import { Disposable, Uri } from 'vscode';
 import {
     FileSystemPaths, FileSystemUtils, RawFileSystem, TempFileSystem
 } from '../../../client/common/platform/fileSystem';
@@ -19,18 +19,24 @@ import {
 //tslint:disable-next-line:no-any
 type TempCallback = (err: any, path: string, fd: number, cleanupCallback: () => void) => void;
 interface IRawFS {
+    // VS Code
+    delete(uri: Uri, options?: {recursive: boolean; useTrash: boolean}): Thenable<void>;
+
+    // node "fs"
+    //tslint:disable-next-line:no-any
+    open(filename: string, flags: number, callback: any): void;
+    //tslint:disable-next-line:no-any
+    close(fd: number, callback: any): void;
+
     // "fs-extra"
     chmod(filePath: string, mode: string): Promise<void>;
     readFile(path: string, encoding: string): Promise<string>;
     //tslint:disable-next-line:no-any
     writeFile(path: string, data: any, options: any): Promise<void>;
-    unlink(filename: string): Promise<void>;
     stat(filename: string): Promise<fsextra.Stats>;
     lstat(filename: string): Promise<fsextra.Stats>;
     mkdirp(dirname: string): Promise<void>;
-    rmdir(dirname: string): Promise<void>;
     readdir(dirname: string): Promise<string[]>;
-    remove(dirname: string): Promise<void>;
     statSync(filename: string): fsextra.Stats;
     readFileSync(path: string, encoding: string): string;
     createReadStream(src: string): fsextra.ReadStream;
@@ -235,6 +241,7 @@ suite('Raw FileSystem', () => {
     setup(() => {
         raw = TypeMoq.Mock.ofType<IRawFS>(undefined, TypeMoq.MockBehavior.Strict);
         filesystem = new RawFileSystem(
+            raw.object,
             raw.object,
             raw.object,
             raw.object
@@ -298,10 +305,7 @@ suite('Raw FileSystem', () => {
     suite('rmtree', () => {
         test('wraps the low-level function', async () => {
             const dirname = 'x/y/z/spam';
-            raw.setup(r => r.stat(dirname))
-                //tslint:disable-next-line:no-any
-                .returns(() => Promise.resolve({} as any as FileStat));
-            raw.setup(r => r.remove(dirname))
+            raw.setup(r => r.delete(Uri.file(dirname), { recursive: true, useTrash: false }))
                 .returns(() => Promise.resolve());
 
             await filesystem.rmtree(dirname);
@@ -311,7 +315,7 @@ suite('Raw FileSystem', () => {
 
         test('fails if the directory does not exist', async () => {
             const dirname = 'x/y/z/spam';
-            raw.setup(r => r.stat(dirname))
+            raw.setup(r => r.delete(Uri.file(dirname), { recursive: true, useTrash: false }))
                 .throws(new Error('file not found'));
 
             const promise = filesystem.rmtree(dirname);
@@ -323,7 +327,7 @@ suite('Raw FileSystem', () => {
     suite('rmfile', () => {
         test('wraps the low-level function', async () => {
             const filename = 'x/y/z/spam.py';
-            raw.setup(r => r.unlink(filename))
+            raw.setup(r => r.delete(Uri.file(filename), { recursive: false, useTrash: false }))
                 .returns(() => Promise.resolve());
 
             await filesystem.rmfile(filename);

From 80fd402f2bad2b2b3b64e07afd2b612f54fa321e Mon Sep 17 00:00:00 2001
From: Eric Snow <ericsnowcurrently@gmail.com>
Date: Tue, 22 Oct 2019 16:01:25 -0600
Subject: [PATCH 02/25] Move listdir() to the new API.

---
 src/client/common/platform/fileSystem.ts      |  47 ++------
 .../platform/filesystem.functional.test.ts    | 113 -----------------
 src/test/common/platform/filesystem.test.ts   | 114 ++++++++++++++++++
 .../common/platform/filesystem.unit.test.ts   |  64 ++--------
 4 files changed, 131 insertions(+), 207 deletions(-)

diff --git a/src/client/common/platform/fileSystem.ts b/src/client/common/platform/fileSystem.ts
index a3b5769c1a40..0c8f093ab21e 100644
--- a/src/client/common/platform/fileSystem.ts
+++ b/src/client/common/platform/fileSystem.ts
@@ -25,19 +25,6 @@ import {
 
 const ENCODING: string = 'utf8';
 
-// Determine the file type from the given file info.
-function getFileType(stat: FileStat): FileType {
-    if (stat.isFile()) {
-        return FileType.File;
-    } else if (stat.isDirectory()) {
-        return FileType.Directory;
-    } else if (stat.isSymbolicLink()) {
-        return FileType.SymbolicLink;
-    } else {
-        return FileType.Unknown;
-    }
-}
-
 // The parts of node's 'path' module used by FileSystemPath.
 interface INodePath {
     join(...filenames: string[]): string;
@@ -117,7 +104,7 @@ interface INewAPI {
     //copy(source: vscode.Uri, target: vscode.Uri, options?: {overwrite: boolean}): Thenable<void>;
     //createDirectory(uri: vscode.Uri): Thenable<void>;
     delete(uri: vscode.Uri, options?: {recursive: boolean; useTrash: boolean}): Thenable<void>;
-    //readDirectory(uri: vscode.Uri): Thenable<[string, FileType][]>;
+    readDirectory(uri: vscode.Uri): Thenable<[string, FileType][]>;
     //readFile(uri: vscode.Uri): Thenable<Uint8Array>;
     //rename(source: vscode.Uri, target: vscode.Uri, options?: {overwrite: boolean}): Thenable<void>;
     //stat(uri: vscode.Uri): Thenable<vscode.FileStat>;
@@ -139,7 +126,6 @@ interface IRawFSExtra {
     stat(filename: string): Promise<fsextra.Stats>;
     lstat(filename: string): Promise<fsextra.Stats>;
     mkdirp(dirname: string): Promise<void>;
-    readdir(dirname: string): Promise<string[]>;
 
     // non-async
     statSync(filename: string): fsextra.Stats;
@@ -148,18 +134,12 @@ interface IRawFSExtra {
     createWriteStream(dest: string): fsextra.WriteStream;
 }
 
-// The parts of IFileSystemPaths used by RawFileSystem.
-interface IRawPath {
-    join(...filenames: string[]): string;
-}
-
 // Later we will drop "FileSystem", switching usage to
 // "FileSystemUtils" and then rename "RawFileSystem" to "FileSystem".
 
 // The low-level filesystem operations used by the extension.
 export class RawFileSystem implements IRawFileSystem {
     constructor(
-        protected readonly path: IRawPath,
         protected readonly newapi: INewAPI,
         protected readonly nodefs: IRawFS,
         protected readonly fsExtra: IRawFSExtra
@@ -168,7 +148,6 @@ export class RawFileSystem implements IRawFileSystem {
     // Create a new object using common-case default values.
     public static withDefaults(): RawFileSystem{
         return new RawFileSystem(
-            FileSystemPaths.withDefaults(),
             vscode.workspace.fs,
             fs,
             fsextra
@@ -194,6 +173,11 @@ export class RawFileSystem implements IRawFileSystem {
         });
     }
 
+    public async listdir(dirname: string): Promise<[string, FileType][]> {
+        const uri = vscode.Uri.file(dirname);
+        return this.newapi.readDirectory(uri);
+    }
+
     //****************************
     // fs-extra
 
@@ -224,20 +208,6 @@ export class RawFileSystem implements IRawFileSystem {
         return this.fsExtra.lstat(filename);
     }
 
-    // Once we move to the VS Code API, this method becomes a trivial wrapper.
-    public async listdir(dirname: string): Promise<[string, FileType][]> {
-        const names: string[] = await this.fsExtra.readdir(dirname);
-        const promises = names
-            .map(name => {
-                 const filename = this.path.join(dirname, name);
-                 return this.lstat(filename)
-                     .then(stat => [name, getFileType(stat)] as [string, FileType])
-                     .catch(() => [name, FileType.Unknown] as [string, FileType]);
-            });
-        return Promise.all(promises);
-    }
-
-    // Once we move to the VS Code API, this method becomes a trivial wrapper.
     public async copyFile(src: string, dest: string): Promise<void> {
         const deferred = createDeferred<void>();
         const rs = this.fsExtra.createReadStream(src)
@@ -285,10 +255,9 @@ export class FileSystemUtils implements IFileSystemUtils {
     ) { }
     // Create a new object using common-case default values.
     public static withDefaults(): FileSystemUtils {
-        const paths = FileSystemPaths.withDefaults();
         return new FileSystemUtils(
-            new RawFileSystem(paths, vscode.workspace.fs, fs, fsextra),
-            paths,
+            RawFileSystem.withDefaults(),
+            FileSystemPaths.withDefaults(),
             TempFileSystem.withDefaults(),
             getHashString,
             util.promisify(glob)
diff --git a/src/test/common/platform/filesystem.functional.test.ts b/src/test/common/platform/filesystem.functional.test.ts
index 7451271dbcc4..1a66dc4921fe 100644
--- a/src/test/common/platform/filesystem.functional.test.ts
+++ b/src/test/common/platform/filesystem.functional.test.ts
@@ -415,64 +415,6 @@ suite('Raw FileSystem', () => {
         });
     });
 
-    suite('listdir', () => {
-        test('mixed', async () => {
-            // Create the target directory and its contents.
-            const dirname = await fix.createDirectory('x/y/z');
-            await fix.createFile('x/y/z/__init__.py', '');
-            const script = await fix.createFile('x/y/z/__main__.py', '<script here>');
-            await fix.createFile('x/y/z/spam.py', '...');
-            await fix.createSocket('x/y/z/ipc.sock');
-            await fix.createFile('x/y/z/eggs.py', '"""..."""');
-            await fix.createSymlink(
-                'x/y/z/info.py',
-                // Link to an ignored file.
-                await fix.createFile('x/_info.py', '<info here>') // source
-            );
-            await fix.createDirectory('x/y/z/w');
-            // Create other files and directories (should be ignored).
-            await fix.createSymlink(
-                'my-script.py',
-                // Link to a listed file.
-                script // source (__main__.py)
-            );
-            const ignored1 = await fix.createFile('x/__init__.py', '');
-            await fix.createFile('x/y/__init__.py', '');
-            await fix.createSymlink(
-                'x/y/z/w/__init__.py',
-                ignored1 // source (x/__init__.py)
-            );
-            await fix.createDirectory('x/y/z/w/data');
-            await fix.createFile('x/y/z/w/data/v1.json');
-
-            const entries = await filesystem.listdir(dirname);
-
-            expect(entries.sort()).to.deep.equal([
-                ['__init__.py', FileType.File],
-                ['__main__.py', FileType.File],
-                ['eggs.py', FileType.File],
-                ['info.py', FileType.SymbolicLink],
-                ['ipc.sock', FileType.Unknown],
-                ['spam.py', FileType.File],
-                ['w', FileType.Directory]
-            ]);
-        });
-
-        test('empty', async () => {
-            const dirname = await fix.createDirectory('x/y/z/eggs');
-
-            const entries = await filesystem.listdir(dirname);
-
-            expect(entries).to.deep.equal([]);
-        });
-
-        test('fails if the directory does not exist', async () => {
-            const promise = filesystem.listdir(DOES_NOT_EXIST);
-
-            await expect(promise).to.eventually.be.rejected;
-        });
-    });
-
     suite('copyFile', () => {
         test('the source file gets copied (same directory)', async () => {
             const data = '<content>';
@@ -783,61 +725,6 @@ suite('FileSystem Utils', () => {
         });
     });
 
-    suite('getSubDirectories', () => {
-        test('mixed types', async () => {
-            const symlinkSource = await fix.createFile('x/info.py');
-            const dirname = await fix.createDirectory('x/y/z/scripts');
-            const subdir1 = await fix.createDirectory('x/y/z/scripts/w');
-            await fix.createFile('x/y/z/scripts/spam.py');
-            const subdir2 = await fix.createDirectory('x/y/z/scripts/v');
-            await fix.createFile('x/y/z/scripts/eggs.py');
-            await fix.createSocket('x/y/z/scripts/spam.sock');
-            await fix.createSymlink('x/y/z/scripts/other', symlinkSource);
-            await fix.createFile('x/y/z/scripts/data.json');
-
-            const results = await utils.getSubDirectories(dirname);
-
-            expect(results.sort()).to.deep.equal([
-                subdir2,
-                subdir1
-            ]);
-        });
-
-        test('empty if the directory does not exist', async () => {
-            const entries = await utils.getSubDirectories(DOES_NOT_EXIST);
-
-            expect(entries).to.deep.equal([]);
-        });
-    });
-
-    suite('getFiles', () => {
-        test('mixed types', async () => {
-            const symlinkSource = await fix.createFile('x/info.py');
-            const dirname = await fix.createDirectory('x/y/z/scripts');
-            await fix.createDirectory('x/y/z/scripts/w');
-            const file1 = await fix.createFile('x/y/z/scripts/spam.py');
-            await fix.createDirectory('x/y/z/scripts/v');
-            const file2 = await fix.createFile('x/y/z/scripts/eggs.py');
-            await fix.createSocket('x/y/z/scripts/spam.sock');
-            await fix.createSymlink('x/y/z/scripts/other', symlinkSource);
-            const file3 = await fix.createFile('x/y/z/scripts/data.json');
-
-            const results = await utils.getFiles(dirname);
-
-            expect(results.sort()).to.deep.equal([
-                file3,
-                file2,
-                file1
-            ]);
-        });
-
-        test('empty if the directory does not exist', async () => {
-            const entries = await utils.getFiles(DOES_NOT_EXIST);
-
-            expect(entries).to.deep.equal([]);
-        });
-    });
-
     suite('getFileHash', () => {
         test('Getting hash for a file should return non-empty string', async () => {
             const filename = await fix.createFile('x/y/z/spam.py');
diff --git a/src/test/common/platform/filesystem.test.ts b/src/test/common/platform/filesystem.test.ts
index b7822d51c296..1410e2034933 100644
--- a/src/test/common/platform/filesystem.test.ts
+++ b/src/test/common/platform/filesystem.test.ts
@@ -7,6 +7,7 @@ import {
     FileSystemUtils, RawFileSystem
 } from '../../../client/common/platform/fileSystem';
 import {
+    FileType,
     IFileSystemUtils, IRawFileSystem
 } from '../../../client/common/platform/types';
 import {
@@ -63,6 +64,64 @@ suite('Raw FileSystem', () => {
             await expect(promise).to.eventually.be.rejected;
         });
     });
+
+    suite('listdir', () => {
+        test('mixed', async () => {
+            // Create the target directory and its contents.
+            const dirname = await fix.createDirectory('x/y/z');
+            await fix.createFile('x/y/z/__init__.py', '');
+            const script = await fix.createFile('x/y/z/__main__.py', '<script here>');
+            await fix.createFile('x/y/z/spam.py', '...');
+            await fix.createSocket('x/y/z/ipc.sock');
+            await fix.createFile('x/y/z/eggs.py', '"""..."""');
+            await fix.createSymlink(
+                'x/y/z/info.py',
+                // Link to an ignored file.
+                await fix.createFile('x/_info.py', '<info here>') // source
+            );
+            await fix.createDirectory('x/y/z/w');
+            // Create other files and directories (should be ignored).
+            await fix.createSymlink(
+                'my-script.py',
+                // Link to a listed file.
+                script // source (__main__.py)
+            );
+            const ignored1 = await fix.createFile('x/__init__.py', '');
+            await fix.createFile('x/y/__init__.py', '');
+            await fix.createSymlink(
+                'x/y/z/w/__init__.py',
+                ignored1 // source (x/__init__.py)
+            );
+            await fix.createDirectory('x/y/z/w/data');
+            await fix.createFile('x/y/z/w/data/v1.json');
+
+            const entries = await filesystem.listdir(dirname);
+
+            expect(entries.sort()).to.deep.equal([
+                ['__init__.py', FileType.File],
+                ['__main__.py', FileType.File],
+                ['eggs.py', FileType.File],
+                ['info.py', FileType.SymbolicLink],
+                ['ipc.sock', FileType.Unknown],
+                ['spam.py', FileType.File],
+                ['w', FileType.Directory]
+            ]);
+        });
+
+        test('empty', async () => {
+            const dirname = await fix.createDirectory('x/y/z/eggs');
+
+            const entries = await filesystem.listdir(dirname);
+
+            expect(entries).to.deep.equal([]);
+        });
+
+        test('fails if the directory does not exist', async () => {
+            const promise = filesystem.listdir(DOES_NOT_EXIST);
+
+            await expect(promise).to.eventually.be.rejected;
+        });
+    });
 });
 
 suite('FileSystem Utils', () => {
@@ -76,6 +135,61 @@ suite('FileSystem Utils', () => {
         await fix.cleanUp();
     });
 
+    suite('getSubDirectories', () => {
+        test('mixed types', async () => {
+            const symlinkSource = await fix.createFile('x/info.py');
+            const dirname = await fix.createDirectory('x/y/z/scripts');
+            const subdir1 = await fix.createDirectory('x/y/z/scripts/w');
+            await fix.createFile('x/y/z/scripts/spam.py');
+            const subdir2 = await fix.createDirectory('x/y/z/scripts/v');
+            await fix.createFile('x/y/z/scripts/eggs.py');
+            await fix.createSocket('x/y/z/scripts/spam.sock');
+            await fix.createSymlink('x/y/z/scripts/other', symlinkSource);
+            await fix.createFile('x/y/z/scripts/data.json');
+
+            const results = await utils.getSubDirectories(dirname);
+
+            expect(results.sort()).to.deep.equal([
+                subdir2,
+                subdir1
+            ]);
+        });
+
+        test('empty if the directory does not exist', async () => {
+            const entries = await utils.getSubDirectories(DOES_NOT_EXIST);
+
+            expect(entries).to.deep.equal([]);
+        });
+    });
+
+    suite('getFiles', () => {
+        test('mixed types', async () => {
+            const symlinkSource = await fix.createFile('x/info.py');
+            const dirname = await fix.createDirectory('x/y/z/scripts');
+            await fix.createDirectory('x/y/z/scripts/w');
+            const file1 = await fix.createFile('x/y/z/scripts/spam.py');
+            await fix.createDirectory('x/y/z/scripts/v');
+            const file2 = await fix.createFile('x/y/z/scripts/eggs.py');
+            await fix.createSocket('x/y/z/scripts/spam.sock');
+            await fix.createSymlink('x/y/z/scripts/other', symlinkSource);
+            const file3 = await fix.createFile('x/y/z/scripts/data.json');
+
+            const results = await utils.getFiles(dirname);
+
+            expect(results.sort()).to.deep.equal([
+                file3,
+                file2,
+                file1
+            ]);
+        });
+
+        test('empty if the directory does not exist', async () => {
+            const entries = await utils.getFiles(DOES_NOT_EXIST);
+
+            expect(entries).to.deep.equal([]);
+        });
+    });
+
     suite('isDirReadonly', () => {
         suite('non-Windows', () => {
             suiteSetup(function () {
diff --git a/src/test/common/platform/filesystem.unit.test.ts b/src/test/common/platform/filesystem.unit.test.ts
index a7f5a8a225d6..7d8bf34f22c6 100644
--- a/src/test/common/platform/filesystem.unit.test.ts
+++ b/src/test/common/platform/filesystem.unit.test.ts
@@ -21,6 +21,7 @@ type TempCallback = (err: any, path: string, fd: number, cleanupCallback: () =>
 interface IRawFS {
     // VS Code
     delete(uri: Uri, options?: {recursive: boolean; useTrash: boolean}): Thenable<void>;
+    readDirectory(uri: Uri): Thenable<[string, FileType][]>;
 
     // node "fs"
     //tslint:disable-next-line:no-any
@@ -36,7 +37,6 @@ interface IRawFS {
     stat(filename: string): Promise<fsextra.Stats>;
     lstat(filename: string): Promise<fsextra.Stats>;
     mkdirp(dirname: string): Promise<void>;
-    readdir(dirname: string): Promise<string[]>;
     statSync(filename: string): fsextra.Stats;
     readFileSync(path: string, encoding: string): string;
     createReadStream(src: string): fsextra.ReadStream;
@@ -241,7 +241,7 @@ suite('Raw FileSystem', () => {
     setup(() => {
         raw = TypeMoq.Mock.ofType<IRawFS>(undefined, TypeMoq.MockBehavior.Strict);
         filesystem = new RawFileSystem(
-            raw.object,
+            //raw.object,
             raw.object,
             raw.object,
             raw.object
@@ -380,42 +380,6 @@ suite('Raw FileSystem', () => {
     });
 
     suite('listdir', () => {
-        function setupStat(filename: string, ft: FileType) {
-            const stat = TypeMoq.Mock.ofType<FileStat>(undefined, TypeMoq.MockBehavior.Strict);
-            if (ft === FileType.File) {
-                stat.setup(s => s.isFile())
-                    .returns(() => true);
-            } else if (ft === FileType.Directory) {
-                stat.setup(s => s.isFile())
-                    .returns(() => false);
-                stat.setup(s => s.isDirectory())
-                    .returns(() => true);
-            } else if (ft === FileType.SymbolicLink) {
-                stat.setup(s => s.isFile())
-                    .returns(() => false);
-                stat.setup(s => s.isDirectory())
-                    .returns(() => false);
-                stat.setup(s => s.isSymbolicLink())
-                    .returns(() => true);
-            } else {
-                stat.setup(s => s.isFile())
-                    .returns(() => false);
-                stat.setup(s => s.isDirectory())
-                    .returns(() => false);
-                stat.setup(s => s.isSymbolicLink())
-                    .returns(() => false);
-            }
-            // This is necessary because passing "stat.object" to
-            // Promise.resolve() triggers the lookup.
-            //tslint:disable-next-line:no-any
-            stat.setup((s: any) => s.then)
-                .returns(() => undefined)
-                .verifiable(TypeMoq.Times.atLeast(0));
-            raw.setup(r => r.lstat(filename))
-                .returns(() => Promise.resolve(stat.object));
-            return stat;
-        }
-
         test('mixed', async () => {
             const dirname = 'x/y/z/spam';
             const expected: [string, FileType][] = [
@@ -424,40 +388,30 @@ suite('Raw FileSystem', () => {
                 ['spam.py', FileType.File],
                 ['other', FileType.SymbolicLink]
             ];
-            const names = expected.map(([name, _ft]) => name);
-            raw.setup(r => r.readdir(dirname))
-                .returns(() => Promise.resolve(names));
-            const stats: TypeMoq.IMock<FileStat>[] = [];
-            expected.forEach(([name, ft]) => {
-                const filename = `${dirname}/${name}`;
-                raw.setup(r => r.join(dirname, name))
-                    .returns(() => filename);
-                stats.push(
-                    setupStat(filename, ft));
-            });
+            raw.setup(r => r.readDirectory(Uri.file(dirname)))
+                .returns(() => Promise.resolve(expected));
 
             const entries = await filesystem.listdir(dirname);
 
             expect(entries).to.deep.equal(expected);
             verifyAll();
-            stats.forEach(stat => stat.verifyAll());
         });
 
         test('empty', async () => {
             const dirname = 'x/y/z/spam';
-            const names: string[] = [];
-            raw.setup(r => r.readdir(dirname))
-                .returns(() => Promise.resolve(names));
+            const expected: [string, FileType][] = [];
+            raw.setup(r => r.readDirectory(Uri.file(dirname)))
+                .returns(() => Promise.resolve(expected));
 
             const entries = await filesystem.listdir(dirname);
 
-            expect(entries).to.deep.equal([]);
+            expect(entries).to.deep.equal(expected);
             verifyAll();
         });
 
         test('fails if the low-level call fails', async () => {
             const dirname = 'x/y/z/spam';
-            raw.setup(r => r.readdir(dirname))
+            raw.setup(r => r.readDirectory(Uri.file(dirname)))
                 .throws(new Error('file not found'));
 
             const promise = filesystem.listdir(dirname);

From 3e4bdac71cb22c9bb692f87edd6e499181a3a5e1 Mon Sep 17 00:00:00 2001
From: Eric Snow <ericsnowcurrently@gmail.com>
Date: Wed, 23 Oct 2019 09:14:40 -0600
Subject: [PATCH 03/25] Move readText() to the new API.

---
 src/client/common/platform/fileSystem.ts      | 14 ++--
 .../platform/filesystem.functional.test.ts    | 57 ---------------
 src/test/common/platform/filesystem.test.ts   | 73 ++++++++++++++++++-
 .../common/platform/filesystem.unit.test.ts   | 14 ++--
 4 files changed, 88 insertions(+), 70 deletions(-)

diff --git a/src/client/common/platform/fileSystem.ts b/src/client/common/platform/fileSystem.ts
index 0c8f093ab21e..3c2b49c44751 100644
--- a/src/client/common/platform/fileSystem.ts
+++ b/src/client/common/platform/fileSystem.ts
@@ -105,7 +105,7 @@ interface INewAPI {
     //createDirectory(uri: vscode.Uri): Thenable<void>;
     delete(uri: vscode.Uri, options?: {recursive: boolean; useTrash: boolean}): Thenable<void>;
     readDirectory(uri: vscode.Uri): Thenable<[string, FileType][]>;
-    //readFile(uri: vscode.Uri): Thenable<Uint8Array>;
+    readFile(uri: vscode.Uri): Thenable<Uint8Array>;
     //rename(source: vscode.Uri, target: vscode.Uri, options?: {overwrite: boolean}): Thenable<void>;
     //stat(uri: vscode.Uri): Thenable<vscode.FileStat>;
     //writeFile(uri: vscode.Uri, content: Uint8Array): Thenable<void>;
@@ -120,7 +120,6 @@ interface IRawFS {
 // This is the parts of the 'fs-extra' module that we use in RawFileSystem.
 interface IRawFSExtra {
     chmod(filePath: string, mode: string | number): Promise<void>;
-    readFile(path: string, encoding: string): Promise<string>;
     //tslint:disable-next-line:no-any
     writeFile(path: string, data: any, options: any): Promise<void>;
     stat(filename: string): Promise<fsextra.Stats>;
@@ -157,6 +156,13 @@ export class RawFileSystem implements IRawFileSystem {
     //****************************
     // VS Code API
 
+    public async readText(filename: string): Promise<string> {
+        const uri = vscode.Uri.file(filename);
+        const data = Buffer.from(
+            await this.newapi.readFile(uri));
+        return data.toString(ENCODING);
+    }
+
     public async rmtree(dirname: string): Promise<void> {
         const uri = vscode.Uri.file(dirname);
         return this.newapi.delete(uri, {
@@ -181,10 +187,6 @@ export class RawFileSystem implements IRawFileSystem {
     //****************************
     // fs-extra
 
-    public async readText(filename: string): Promise<string> {
-        return this.fsExtra.readFile(filename, ENCODING);
-    }
-
     public async writeText(filename: string, data: {}): Promise<void> {
         const options: fsextra.WriteFileOptions = {
             encoding: ENCODING
diff --git a/src/test/common/platform/filesystem.functional.test.ts b/src/test/common/platform/filesystem.functional.test.ts
index 1a66dc4921fe..d674c6790874 100644
--- a/src/test/common/platform/filesystem.functional.test.ts
+++ b/src/test/common/platform/filesystem.functional.test.ts
@@ -199,45 +199,6 @@ suite('Raw FileSystem', () => {
         await fix.cleanUp();
     });
 
-    suite('readText', () => {
-        test('returns contents of a file', async () => {
-            const expected = '<some text>';
-            const filename = await fix.createFile('x/y/z/spam.py', expected);
-
-            const content = await filesystem.readText(filename);
-
-            expect(content).to.be.equal(expected);
-        });
-
-        test('always UTF-8', async () => {
-            const expected = '... 😁 ...';
-            const filename = await fix.createFile('x/y/z/spam.py', expected);
-
-            const text = await filesystem.readText(filename);
-
-            expect(text).to.equal(expected);
-        });
-
-        test('returns garbage if encoding is UCS-2', async () => {
-            const filename = await fix.resolve('spam.py');
-            // There are probably cases where this would fail too.
-            // However, the extension never has to deal with non-UTF8
-            // cases, so it doesn't matter too much.
-            const original = '... 😁 ...';
-            await fsextra.writeFile(filename, original, { encoding: 'ucs2' });
-
-            const text = await filesystem.readText(filename);
-
-            expect(text).to.equal('.\u0000.\u0000.\u0000 \u0000=�\u0001� \u0000.\u0000.\u0000.\u0000');
-        });
-
-        test('throws an exception if file does not exist', async () => {
-            const promise = filesystem.readText(DOES_NOT_EXIST);
-
-            await expect(promise).to.eventually.be.rejected;
-        });
-    });
-
     suite('writeText', () => {
         test('creates the file if missing', async () => {
             const filename = await fix.resolve('x/y/z/spam.py');
@@ -823,24 +784,6 @@ suite('FileSystem - legacy aliases', () => {
         }
     }
 
-    test('ReadFile returns contents of a file', async () => {
-        const file = __filename;
-        const filesystem = new FileSystem();
-        const expectedContents = await fsextra.readFile(file).then(buffer => buffer.toString());
-
-        const content = await filesystem.readFile(file);
-
-        expect(content).to.be.equal(expectedContents);
-    });
-
-    test('ReadFile throws an exception if file does not exist', async () => {
-        const filesystem = new FileSystem();
-
-        const readPromise = filesystem.readFile('xyz');
-
-        await expect(readPromise).to.be.rejectedWith();
-    });
-
     suite('Case sensitivity', () => {
         const path1 = 'c:\\users\\Peter Smith\\my documents\\test.txt';
         const path2 = 'c:\\USERS\\Peter Smith\\my documents\\test.TXT';
diff --git a/src/test/common/platform/filesystem.test.ts b/src/test/common/platform/filesystem.test.ts
index 1410e2034933..597e01361bfb 100644
--- a/src/test/common/platform/filesystem.test.ts
+++ b/src/test/common/platform/filesystem.test.ts
@@ -3,8 +3,9 @@
 
 import { expect } from 'chai';
 import * as fsextra from 'fs-extra';
+import * as path from 'path';
 import {
-    FileSystemUtils, RawFileSystem
+    FileSystem, FileSystemUtils, RawFileSystem
 } from '../../../client/common/platform/fileSystem';
 import {
     FileType,
@@ -30,6 +31,45 @@ suite('Raw FileSystem', () => {
         await fix.cleanUp();
     });
 
+    suite('readText', () => {
+        test('returns contents of a file', async () => {
+            const expected = '<some text>';
+            const filename = await fix.createFile('x/y/z/spam.py', expected);
+
+            const content = await filesystem.readText(filename);
+
+            expect(content).to.be.equal(expected);
+        });
+
+        test('always UTF-8', async () => {
+            const expected = '... 😁 ...';
+            const filename = await fix.createFile('x/y/z/spam.py', expected);
+
+            const text = await filesystem.readText(filename);
+
+            expect(text).to.equal(expected);
+        });
+
+        test('returns garbage if encoding is UCS-2', async () => {
+            const filename = await fix.resolve('spam.py');
+            // There are probably cases where this would fail too.
+            // However, the extension never has to deal with non-UTF8
+            // cases, so it doesn't matter too much.
+            const original = '... 😁 ...';
+            await fsextra.writeFile(filename, original, { encoding: 'ucs2' });
+
+            const text = await filesystem.readText(filename);
+
+            expect(text).to.equal('.\u0000.\u0000.\u0000 \u0000=�\u0001� \u0000.\u0000.\u0000.\u0000');
+        });
+
+        test('throws an exception if file does not exist', async () => {
+            const promise = filesystem.readText(DOES_NOT_EXIST);
+
+            await expect(promise).to.eventually.be.rejected;
+        });
+    });
+
     suite('rmtree', () => {
         test('deletes the directory and everything in it', async () => {
             const dirname = await fix.createDirectory('x');
@@ -225,3 +265,34 @@ suite('FileSystem Utils', () => {
         });
     });
 });
+
+suite('FileSystem - legacy aliases', () => {
+    const fileToAppendTo = path.join(__dirname, 'created_for_testing_dummy.txt');
+    setup(() => {
+        cleanTestFiles(); // This smells like functional testing...
+    });
+    teardown(cleanTestFiles);
+    function cleanTestFiles() {
+        if (fsextra.existsSync(fileToAppendTo)) {
+            fsextra.unlinkSync(fileToAppendTo);
+        }
+    }
+
+    test('ReadFile returns contents of a file', async () => {
+        const file = __filename;
+        const filesystem = new FileSystem();
+        const expectedContents = await fsextra.readFile(file).then(buffer => buffer.toString());
+
+        const content = await filesystem.readFile(file);
+
+        expect(content).to.be.equal(expectedContents);
+    });
+
+    test('ReadFile throws an exception if file does not exist', async () => {
+        const filesystem = new FileSystem();
+
+        const readPromise = filesystem.readFile('xyz');
+
+        await expect(readPromise).to.be.rejectedWith();
+    });
+});
diff --git a/src/test/common/platform/filesystem.unit.test.ts b/src/test/common/platform/filesystem.unit.test.ts
index 7d8bf34f22c6..03f21dda2e05 100644
--- a/src/test/common/platform/filesystem.unit.test.ts
+++ b/src/test/common/platform/filesystem.unit.test.ts
@@ -22,6 +22,7 @@ interface IRawFS {
     // VS Code
     delete(uri: Uri, options?: {recursive: boolean; useTrash: boolean}): Thenable<void>;
     readDirectory(uri: Uri): Thenable<[string, FileType][]>;
+    readFile(uri: Uri): Thenable<Uint8Array>;
 
     // node "fs"
     //tslint:disable-next-line:no-any
@@ -31,7 +32,6 @@ interface IRawFS {
 
     // "fs-extra"
     chmod(filePath: string, mode: string): Promise<void>;
-    readFile(path: string, encoding: string): Promise<string>;
     //tslint:disable-next-line:no-any
     writeFile(path: string, data: any, options: any): Promise<void>;
     stat(filename: string): Promise<fsextra.Stats>;
@@ -255,8 +255,9 @@ suite('Raw FileSystem', () => {
         test('wraps the low-level function', async () => {
             const filename = 'x/y/z/spam.py';
             const expected = '<text>';
-            raw.setup(r => r.readFile(filename, TypeMoq.It.isAny()))
-                .returns(() => Promise.resolve(expected));
+            const data = Buffer.from(expected);
+            raw.setup(r => r.readFile(Uri.file(filename)))
+                .returns(() => Promise.resolve(data));
 
             const text = await filesystem.readText(filename);
 
@@ -266,9 +267,10 @@ suite('Raw FileSystem', () => {
 
         test('always UTF-8', async () => {
             const filename = 'x/y/z/spam.py';
-            const expected = '<text>';
-            raw.setup(r => r.readFile(filename, 'utf8'))
-                .returns(() => Promise.resolve(expected));
+            const expected = '... 😁 ...';
+            const data = Buffer.from(expected);
+            raw.setup(r => r.readFile(Uri.file(filename)))
+                .returns(() => Promise.resolve(data));
 
             const text = await filesystem.readText(filename);
 

From 033e328166a374822b1c94e25c493e68919874ad Mon Sep 17 00:00:00 2001
From: Eric Snow <ericsnowcurrently@gmail.com>
Date: Tue, 29 Oct 2019 15:01:40 -0600
Subject: [PATCH 04/25] Use the new API for stat (async-only and not lstat).

---
 src/client/common/platform/fileSystem.ts      |  54 +++---
 src/client/common/platform/types.ts           |   5 +-
 .../platform/filesystem.functional.test.ts    | 170 ++++--------------
 src/test/common/platform/filesystem.test.ts   | 148 +++++++++++++++
 .../common/platform/filesystem.unit.test.ts   | 124 ++++++++++---
 5 files changed, 317 insertions(+), 184 deletions(-)

diff --git a/src/client/common/platform/fileSystem.ts b/src/client/common/platform/fileSystem.ts
index 3c2b49c44751..b4d1bf247b24 100644
--- a/src/client/common/platform/fileSystem.ts
+++ b/src/client/common/platform/fileSystem.ts
@@ -25,6 +25,23 @@ import {
 
 const ENCODING: string = 'utf8';
 
+function convertFileStat(stat: fsextra.Stats): FileStat {
+    let fileType = FileType.Unknown;
+    if (stat.isFile()) {
+        fileType = FileType.File;
+    } else if (stat.isDirectory()) {
+        fileType = FileType.Directory;
+    } else if (stat.isSymbolicLink()) {
+        fileType = FileType.SymbolicLink;
+    }
+    return {
+        type: fileType,
+        size: stat.size,
+        ctime: stat.ctimeMs,
+        mtime: stat.mtimeMs
+    };
+}
+
 // The parts of node's 'path' module used by FileSystemPath.
 interface INodePath {
     join(...filenames: string[]): string;
@@ -107,7 +124,7 @@ interface INewAPI {
     readDirectory(uri: vscode.Uri): Thenable<[string, FileType][]>;
     readFile(uri: vscode.Uri): Thenable<Uint8Array>;
     //rename(source: vscode.Uri, target: vscode.Uri, options?: {overwrite: boolean}): Thenable<void>;
-    //stat(uri: vscode.Uri): Thenable<vscode.FileStat>;
+    stat(uri: vscode.Uri): Thenable<FileStat>;
     //writeFile(uri: vscode.Uri, content: Uint8Array): Thenable<void>;
 }
 
@@ -122,7 +139,6 @@ interface IRawFSExtra {
     chmod(filePath: string, mode: string | number): Promise<void>;
     //tslint:disable-next-line:no-any
     writeFile(path: string, data: any, options: any): Promise<void>;
-    stat(filename: string): Promise<fsextra.Stats>;
     lstat(filename: string): Promise<fsextra.Stats>;
     mkdirp(dirname: string): Promise<void>;
 
@@ -179,6 +195,11 @@ export class RawFileSystem implements IRawFileSystem {
         });
     }
 
+    public async stat(filename: string): Promise<FileStat> {
+        const uri = vscode.Uri.file(filename);
+        return this.newapi.stat(uri);
+    }
+
     public async listdir(dirname: string): Promise<[string, FileType][]> {
         const uri = vscode.Uri.file(dirname);
         return this.newapi.readDirectory(uri);
@@ -202,12 +223,10 @@ export class RawFileSystem implements IRawFileSystem {
         return this.fsExtra.chmod(filename, mode);
     }
 
-    public async stat(filename: string): Promise<FileStat> {
-        return this.fsExtra.stat(filename);
-    }
-
     public async lstat(filename: string): Promise<FileStat> {
-        return this.fsExtra.lstat(filename);
+        // At the moment the new VS Code API does not seem to support lstat...
+        const stat = await this.fsExtra.lstat(filename);
+        return convertFileStat(stat);
     }
 
     public async copyFile(src: string, dest: string): Promise<void> {
@@ -230,7 +249,8 @@ export class RawFileSystem implements IRawFileSystem {
     // non-async (fs-extra)
 
     public statSync(filename: string): FileStat {
-        return this.fsExtra.statSync(filename);
+        const stat = this.fsExtra.statSync(filename);
+        return convertFileStat(stat);
     }
 
     public readTextSync(filename: string): string {
@@ -303,15 +323,11 @@ export class FileSystemUtils implements IFileSystemUtils {
         } catch (err) {
             return false;
         }
+
         if (fileType === undefined) {
             return true;
-        } else if (fileType === FileType.File) {
-            return stat.isFile();
-        } else if (fileType === FileType.Directory) {
-            return stat.isDirectory();
-        } else {
-            return false;
         }
+        return stat.type === fileType;
     }
     public async fileExists(filename: string): Promise<boolean> {
         return this.pathExists(filename, FileType.File);
@@ -353,7 +369,7 @@ export class FileSystemUtils implements IFileSystemUtils {
 
     public async getFileHash(filename: string): Promise<string> {
         const stat = await this.raw.lstat(filename);
-        const data = `${stat.ctimeMs}-${stat.mtimeMs}`;
+        const data = `${stat.ctime}-${stat.mtime}`;
         return this.getHash(data);
     }
 
@@ -434,12 +450,8 @@ export class FileSystem implements IFileSystem {
     //****************************
     // aliases
 
-    public async stat(filePath: string): Promise<vscode.FileStat> {
-        // Do not import vscode directly, as this isn't available in the Debugger Context.
-        // If stat is used in debugger context, it will fail, however theres a separate PR that will resolve this.
-        // tslint:disable-next-line: no-require-imports
-        const vsc = require('vscode');
-        return vsc.workspace.fs.stat(vscode.Uri.file(filePath));
+    public async stat(filePath: string): Promise<FileStat> {
+        return this.utils.raw.stat(filePath);
     }
 
     public async readFile(filename: string): Promise<string> {
diff --git a/src/client/common/platform/types.ts b/src/client/common/platform/types.ts
index 317540932e99..b9e0c56ba99d 100644
--- a/src/client/common/platform/types.ts
+++ b/src/client/common/platform/types.ts
@@ -4,7 +4,6 @@
 'use strict';
 
 import * as fs from 'fs';
-import * as fsextra from 'fs-extra';
 import { SemVer } from 'semver';
 import * as vscode from 'vscode';
 import { Architecture, OSType } from '../utils/platform';
@@ -52,7 +51,7 @@ export interface IFileSystemPaths {
 }
 
 export import FileType = vscode.FileType;
-export type FileStat = fsextra.Stats;
+export type FileStat = vscode.FileStat;
 export type WriteStream = fs.WriteStream;
 
 // Later we will drop "IFileSystem", switching usage to
@@ -157,7 +156,7 @@ export interface IFileSystem {
     search(globPattern: string): Promise<string[]>;
     arePathsSame(path1: string, path2: string): boolean;
 
-    stat(filePath: string): Promise<vscode.FileStat>;
+    stat(filePath: string): Promise<FileStat>;
     readFile(filename: string): Promise<string>;
     writeFile(filename: string, data: {}): Promise<void>;
     chmod(filename: string, mode: string): Promise<void>;
diff --git a/src/test/common/platform/filesystem.functional.test.ts b/src/test/common/platform/filesystem.functional.test.ts
index d674c6790874..f4c76550955e 100644
--- a/src/test/common/platform/filesystem.functional.test.ts
+++ b/src/test/common/platform/filesystem.functional.test.ts
@@ -313,47 +313,17 @@ suite('Raw FileSystem', () => {
         });
     });
 
-    suite('stat', () => {
-        test('gets the info for an existing file', async () => {
-            const filename = await fix.createFile('x/y/z/spam.py', '...');
-            const expected = await fsextra.stat(filename);
-
-            const stat = await filesystem.stat(filename);
-
-            expect(stat).to.deep.equal(expected);
-        });
-
-        test('gets the info for an existing directory', async () => {
-            const dirname = await fix.createDirectory('x/y/z/spam');
-            const expected = await fsextra.stat(dirname);
-
-            const stat = await filesystem.stat(dirname);
-
-            expect(stat).to.deep.equal(expected);
-        });
-
-        test('for symlinks, gets the info for the linked file', async () => {
-            const filename = await fix.createFile('x/y/z/spam.py', '...');
-            const symlink = await fix.createSymlink('x/y/z/eggs.py', filename);
-            const expected = await fsextra.stat(filename);
-
-            const stat = await filesystem.stat(symlink);
-
-            expect(stat).to.deep.equal(expected);
-        });
-
-        test('fails if the file does not exist', async () => {
-            const promise = filesystem.stat(DOES_NOT_EXIST);
-
-            await expect(promise).to.eventually.be.rejected;
-        });
-    });
-
     suite('lstat', () => {
         test('for symlinks, gives the link info', async () => {
             const filename = await fix.createFile('x/y/z/spam.py', '...');
             const symlink = await fix.createSymlink('x/y/z/eggs.py', filename);
-            const expected = await fsextra.lstat(symlink);
+            const old = await fsextra.lstat(symlink);
+            const expected = {
+                type: FileType.SymbolicLink,
+                size: old.size,
+                ctime: old.ctimeMs,
+                mtime: old.mtimeMs
+            };
 
             const stat = await filesystem.lstat(symlink);
 
@@ -362,7 +332,13 @@ suite('Raw FileSystem', () => {
 
         test('for normal files, gives the file info', async () => {
             const filename = await fix.createFile('x/y/z/spam.py', '...');
-            const expected = await fsextra.stat(filename);
+            const old = await fsextra.stat(filename);
+            const expected = {
+                type: FileType.File,
+                size: old.size,
+                ctime: old.ctimeMs,
+                mtime: old.mtimeMs
+            };
 
             const stat = await filesystem.lstat(filename);
 
@@ -431,7 +407,13 @@ suite('Raw FileSystem', () => {
     suite('statSync', () => {
         test('gets the info for an existing file', async () => {
             const filename = await fix.createFile('x/y/z/spam.py', '...');
-            const expected = await fsextra.stat(filename);
+            const old = await fsextra.stat(filename);
+            const expected = {
+                type: FileType.File,
+                size: old.size,
+                ctime: old.ctimeMs,
+                mtime: old.mtimeMs
+            };
 
             const stat = filesystem.statSync(filename);
 
@@ -440,7 +422,13 @@ suite('Raw FileSystem', () => {
 
         test('gets the info for an existing directory', async () => {
             const dirname = await fix.createDirectory('x/y/z/spam');
-            const expected = await fsextra.stat(dirname);
+            const old = await fsextra.stat(dirname);
+            const expected = {
+                type: FileType.Directory,
+                size: old.size,
+                ctime: old.ctimeMs,
+                mtime: old.mtimeMs
+            };
 
             const stat = filesystem.statSync(dirname);
 
@@ -450,7 +438,13 @@ suite('Raw FileSystem', () => {
         test('for symlinks, gets the info for the linked file', async () => {
             const filename = await fix.createFile('x/y/z/spam.py', '...');
             const symlink = await fix.createSymlink('x/y/z/eggs.py', filename);
-            const expected = await fsextra.stat(filename);
+            const old = await fsextra.stat(filename);
+            const expected = {
+                type: FileType.File,
+                size: old.size,
+                ctime: old.ctimeMs,
+                mtime: old.mtimeMs
+            };
 
             const stat = filesystem.statSync(symlink);
 
@@ -592,100 +586,6 @@ suite('FileSystem Utils', () => {
         });
     });
 
-    suite('pathExists', () => {
-        test('file missing (any)', async () => {
-            const exists = await utils.pathExists(DOES_NOT_EXIST);
-
-            expect(exists).to.equal(false);
-        });
-
-        Object.keys(FileType).forEach(ft => {
-            test(`file missing (${ft})`, async () => {
-                //tslint:disable-next-line:no-any
-                const exists = await utils.pathExists(DOES_NOT_EXIST, ft as any as FileType);
-
-                expect(exists).to.equal(false);
-            });
-        });
-
-        test('any', async () => {
-            const filename = await fix.createFile('x/y/z/spam.py');
-
-            const exists = await utils.pathExists(filename);
-
-            expect(exists).to.equal(true);
-        });
-
-        test('want file, got file', async () => {
-            const filename = await fix.createFile('x/y/z/spam.py');
-
-            const exists = await utils.pathExists(filename, FileType.File);
-
-            expect(exists).to.equal(true);
-        });
-
-        test('want file, not file', async () => {
-            const filename = await fix.createDirectory('x/y/z/spam.py');
-
-            const exists = await utils.pathExists(filename, FileType.File);
-
-            expect(exists).to.equal(false);
-        });
-
-        test('want directory, got directory', async () => {
-            const dirname = await fix.createDirectory('x/y/z/spam');
-
-            const exists = await utils.pathExists(dirname, FileType.Directory);
-
-            expect(exists).to.equal(true);
-        });
-
-        test('want directory, not directory', async () => {
-            const dirname = await fix.createFile('x/y/z/spam');
-
-            const exists = await utils.pathExists(dirname, FileType.Directory);
-
-            expect(exists).to.equal(false);
-        });
-
-        test('symlink', async () => {
-            const filename = await fix.createFile('x/y/z/spam.py', '...');
-            const symlink = await fix.createSymlink('x/y/z/eggs.py', filename);
-
-            const exists = await utils.pathExists(symlink, FileType.SymbolicLink);
-
-            expect(exists).to.equal(false);
-        });
-
-        test('unknown', async () => {
-            const sockFile = await fix.createSocket('x/y/z/ipc.sock');
-
-            const exists = await utils.pathExists(sockFile, FileType.Unknown);
-
-            expect(exists).to.equal(false);
-        });
-    });
-
-    suite('fileExists', () => {
-        test('want file, got file', async () => {
-            const filename = await fix.createFile('x/y/z/spam.py');
-
-            const exists = await utils.fileExists(filename);
-
-            expect(exists).to.equal(true);
-        });
-    });
-
-    suite('directoryExists', () => {
-        test('want directory, got directory', async () => {
-            const dirname = await fix.createDirectory('x/y/z/spam');
-
-            const exists = await utils.directoryExists(dirname);
-
-            expect(exists).to.equal(true);
-        });
-    });
-
     suite('getFileHash', () => {
         test('Getting hash for a file should return non-empty string', async () => {
             const filename = await fix.createFile('x/y/z/spam.py');
diff --git a/src/test/common/platform/filesystem.test.ts b/src/test/common/platform/filesystem.test.ts
index 597e01361bfb..63d375a9878e 100644
--- a/src/test/common/platform/filesystem.test.ts
+++ b/src/test/common/platform/filesystem.test.ts
@@ -105,6 +105,60 @@ suite('Raw FileSystem', () => {
         });
     });
 
+    suite('stat', () => {
+        test('gets the info for an existing file', async () => {
+            const filename = await fix.createFile('x/y/z/spam.py', '...');
+            const old = await fsextra.stat(filename);
+            const expected = {
+                type: FileType.File,
+                size: old.size,
+                ctime: old.ctimeMs,
+                mtime: old.mtimeMs
+            };
+
+            const stat = await filesystem.stat(filename);
+
+            expect(stat).to.deep.equal(expected);
+        });
+
+        test('gets the info for an existing directory', async () => {
+            const dirname = await fix.createDirectory('x/y/z/spam');
+            const old = await fsextra.stat(dirname);
+            const expected = {
+                type: FileType.Directory,
+                size: old.size,
+                ctime: old.ctimeMs,
+                mtime: old.mtimeMs
+            };
+
+            const stat = await filesystem.stat(dirname);
+
+            expect(stat).to.deep.equal(expected);
+        });
+
+        test('for symlinks, gets the info for the linked file', async () => {
+            const filename = await fix.createFile('x/y/z/spam.py', '...');
+            const symlink = await fix.createSymlink('x/y/z/eggs.py', filename);
+            const old = await fsextra.stat(filename);
+            const expected = {
+                type: FileType.SymbolicLink,
+                size: old.size,
+                ctime: old.ctimeMs,
+                mtime: old.mtimeMs
+            };
+
+            const stat = await filesystem.stat(symlink);
+
+            expect(stat).to.deep.equal(expected);
+        });
+
+        test('fails if the file does not exist', async () => {
+            const promise = filesystem.stat(DOES_NOT_EXIST);
+
+            await expect(promise).to.eventually.be.rejected;
+        });
+    });
+
     suite('listdir', () => {
         test('mixed', async () => {
             // Create the target directory and its contents.
@@ -175,6 +229,100 @@ suite('FileSystem Utils', () => {
         await fix.cleanUp();
     });
 
+    suite('pathExists', () => {
+        test('file missing (any)', async () => {
+            const exists = await utils.pathExists(DOES_NOT_EXIST);
+
+            expect(exists).to.equal(false);
+        });
+
+        Object.keys(FileType).forEach(ft => {
+            test(`file missing (${ft})`, async () => {
+                //tslint:disable-next-line:no-any
+                const exists = await utils.pathExists(DOES_NOT_EXIST, ft as any as FileType);
+
+                expect(exists).to.equal(false);
+            });
+        });
+
+        test('any', async () => {
+            const filename = await fix.createFile('x/y/z/spam.py');
+
+            const exists = await utils.pathExists(filename);
+
+            expect(exists).to.equal(true);
+        });
+
+        test('want file, got file', async () => {
+            const filename = await fix.createFile('x/y/z/spam.py');
+
+            const exists = await utils.pathExists(filename, FileType.File);
+
+            expect(exists).to.equal(true);
+        });
+
+        test('want file, not file', async () => {
+            const filename = await fix.createDirectory('x/y/z/spam.py');
+
+            const exists = await utils.pathExists(filename, FileType.File);
+
+            expect(exists).to.equal(false);
+        });
+
+        test('want directory, got directory', async () => {
+            const dirname = await fix.createDirectory('x/y/z/spam');
+
+            const exists = await utils.pathExists(dirname, FileType.Directory);
+
+            expect(exists).to.equal(true);
+        });
+
+        test('want directory, not directory', async () => {
+            const dirname = await fix.createFile('x/y/z/spam');
+
+            const exists = await utils.pathExists(dirname, FileType.Directory);
+
+            expect(exists).to.equal(false);
+        });
+
+        test('symlink', async () => {
+            const filename = await fix.createFile('x/y/z/spam.py', '...');
+            const symlink = await fix.createSymlink('x/y/z/eggs.py', filename);
+
+            const exists = await utils.pathExists(symlink, FileType.SymbolicLink);
+
+            expect(exists).to.equal(false);
+        });
+
+        test('unknown', async () => {
+            const sockFile = await fix.createSocket('x/y/z/ipc.sock');
+
+            const exists = await utils.pathExists(sockFile, FileType.Unknown);
+
+            expect(exists).to.equal(false);
+        });
+    });
+
+    suite('fileExists', () => {
+        test('want file, got file', async () => {
+            const filename = await fix.createFile('x/y/z/spam.py');
+
+            const exists = await utils.fileExists(filename);
+
+            expect(exists).to.equal(true);
+        });
+    });
+
+    suite('directoryExists', () => {
+        test('want directory, got directory', async () => {
+            const dirname = await fix.createDirectory('x/y/z/spam');
+
+            const exists = await utils.directoryExists(dirname);
+
+            expect(exists).to.equal(true);
+        });
+    });
+
     suite('getSubDirectories', () => {
         test('mixed types', async () => {
             const symlinkSource = await fix.createFile('x/info.py');
diff --git a/src/test/common/platform/filesystem.unit.test.ts b/src/test/common/platform/filesystem.unit.test.ts
index 03f21dda2e05..9f4dfad65361 100644
--- a/src/test/common/platform/filesystem.unit.test.ts
+++ b/src/test/common/platform/filesystem.unit.test.ts
@@ -23,6 +23,7 @@ interface IRawFS {
     delete(uri: Uri, options?: {recursive: boolean; useTrash: boolean}): Thenable<void>;
     readDirectory(uri: Uri): Thenable<[string, FileType][]>;
     readFile(uri: Uri): Thenable<Uint8Array>;
+    stat(uri: Uri): Thenable<FileStat>;
 
     // node "fs"
     //tslint:disable-next-line:no-any
@@ -34,7 +35,6 @@ interface IRawFS {
     chmod(filePath: string, mode: string): Promise<void>;
     //tslint:disable-next-line:no-any
     writeFile(path: string, data: any, options: any): Promise<void>;
-    stat(filename: string): Promise<fsextra.Stats>;
     lstat(filename: string): Promise<fsextra.Stats>;
     mkdirp(dirname: string): Promise<void>;
     statSync(filename: string): fsextra.Stats;
@@ -237,18 +237,76 @@ suite('FileSystem paths', () => {
 
 suite('Raw FileSystem', () => {
     let raw: TypeMoq.IMock<IRawFS>;
+    //let stat: TypeMoq.IMock<FileStat>;
+    let oldStat: TypeMoq.IMock<fsextra.Stats>;
     let filesystem: IRawFileSystem;
     setup(() => {
         raw = TypeMoq.Mock.ofType<IRawFS>(undefined, TypeMoq.MockBehavior.Strict);
+        //stat = TypeMoq.Mock.ofType<FileStat>(undefined, TypeMoq.MockBehavior.Strict);
+        oldStat = TypeMoq.Mock.ofType<fsextra.Stats>(undefined, TypeMoq.MockBehavior.Strict);
         filesystem = new RawFileSystem(
             //raw.object,
             raw.object,
             raw.object,
             raw.object
         );
+
+        // This is necessary because passing "stat.object" to
+        // Promise.resolve() triggers the lookup.
+        //tslint:disable-next-line:no-any
+        oldStat.setup((s: any) => s.then)
+            .returns(() => undefined)
+            .verifiable(TypeMoq.Times.atLeast(0));
     });
     function verifyAll() {
         raw.verifyAll();
+        //stat.verifyAll();
+        oldStat.verifyAll();
+    }
+
+    function setupOldStat(stat: FileStat, old?: TypeMoq.IMock<fsextra.Stats> | null) {
+        if (old === undefined) {
+            old = oldStat;
+        } else if (old === null) {
+            old = TypeMoq.Mock.ofType<fsextra.Stats>(undefined, TypeMoq.MockBehavior.Strict);
+        }
+
+        // This is necessary because passing "stat.object" to
+        // Promise.resolve() triggers the lookup.
+        //tslint:disable-next-line:no-any
+        old!.setup((s: any) => s.then)
+            .returns(() => undefined)
+            .verifiable(TypeMoq.Times.atLeast(0));
+
+        if (stat.type === FileType.File) {
+            old!.setup(s => s.isFile())
+                .returns(() => true);
+        } else {
+            old!.setup(s => s.isFile())
+                .returns(() => false);
+            if (stat.type === FileType.Directory) {
+                old!.setup(s => s.isDirectory())
+                    .returns(() => true);
+            } else {
+                old!.setup(s => s.isDirectory())
+                    .returns(() => false);
+                if (stat.type === FileType.SymbolicLink) {
+                    old!.setup(s => s.isSymbolicLink())
+                        .returns(() => true);
+                } else {
+                    old!.setup(s => s.isSymbolicLink())
+                        .returns(() => false);
+                }
+            }
+        }
+        old!.setup(s => s.size)
+            .returns(() => stat.size);
+        old!.setup(s => s.ctimeMs)
+            .returns(() => stat.ctime);
+        old!.setup(s => s.mtimeMs)
+            .returns(() => stat.mtime);
+
+        return old!;
     }
 
     suite('readText', () => {
@@ -355,8 +413,8 @@ suite('Raw FileSystem', () => {
         test('wraps the low-level function', async () => {
             const filename = 'x/y/z/spam.py';
             //tslint:disable-next-line:no-any
-            const expected: FileStat = {} as any;
-            raw.setup(r => r.stat(filename))
+            const expected: FileStat = { type: FileType.File } as any;
+            raw.setup(r => r.stat(Uri.file(filename)))
                 .returns(() => Promise.resolve(expected));
 
             const stat = await filesystem.stat(filename);
@@ -369,14 +427,20 @@ suite('Raw FileSystem', () => {
     suite('lstat', () => {
         test('wraps the low-level function', async () => {
             const filename = 'x/y/z/spam.py';
+            const expected: FileStat = {
+                type: FileType.File,
+                size: 10,
+                ctime: 101,
+                mtime: 102
             //tslint:disable-next-line:no-any
-            const expected: FileStat = {} as any;
+            } as any;
+            setupOldStat(expected);
             raw.setup(r => r.lstat(filename))
-                .returns(() => Promise.resolve(expected));
+                .returns(() => Promise.resolve(oldStat.object));
 
             const stat = await filesystem.lstat(filename);
 
-            expect(stat).to.equal(expected);
+            expect(stat).to.deep.equal(expected);
             verifyAll();
         });
     });
@@ -473,14 +537,20 @@ suite('Raw FileSystem', () => {
     suite('statSync', () => {
         test('wraps the low-level function', () => {
             const filename = 'x/y/z/spam.py';
+            const expected: FileStat = {
+                type: FileType.File,
+                size: 10,
+                ctime: 101,
+                mtime: 102
             //tslint:disable-next-line:no-any
-            const expected: FileStat = {} as any;
+            } as any;
+            setupOldStat(expected);
             raw.setup(r => r.statSync(filename))
-                .returns(() => expected);
+                .returns(() => oldStat.object);
 
             const stat = filesystem.statSync(filename);
 
-            expect(stat).to.equal(expected);
+            expect(stat).to.deep.equal(expected);
             verifyAll();
         });
     });
@@ -674,8 +744,8 @@ suite('FileSystem Utils', () => {
             const filename = 'x/y/z/spam.py';
             filesystem.setup(f => f.stat(filename))
                 .returns(() => Promise.resolve(stat.object));
-            stat.setup(s => s.isFile())
-                .returns(() => true);
+            stat.setup(s => s.type)
+                .returns(() => FileType.File);
 
             const exists = await utils.pathExists(filename, FileType.File);
 
@@ -687,8 +757,8 @@ suite('FileSystem Utils', () => {
             const filename = 'x/y/z/spam.py';
             filesystem.setup(f => f.stat(filename))
                 .returns(() => Promise.resolve(stat.object));
-            stat.setup(s => s.isFile())
-                .returns(() => false);
+            stat.setup(s => s.type)
+                .returns(() => FileType.Directory);
 
             const exists = await utils.pathExists(filename, FileType.File);
 
@@ -700,8 +770,8 @@ suite('FileSystem Utils', () => {
             const dirname = 'x/y/z/spam';
             filesystem.setup(f => f.stat(dirname))
                 .returns(() => Promise.resolve(stat.object));
-            stat.setup(s => s.isDirectory())
-                .returns(() => true);
+            stat.setup(s => s.type)
+                .returns(() => FileType.Directory);
 
             const exists = await utils.pathExists(dirname, FileType.Directory);
 
@@ -713,8 +783,8 @@ suite('FileSystem Utils', () => {
             const dirname = 'x/y/z/spam';
             filesystem.setup(f => f.stat(dirname))
                 .returns(() => Promise.resolve(stat.object));
-            stat.setup(s => s.isDirectory())
-                .returns(() => false);
+            stat.setup(s => s.type)
+                .returns(() => FileType.File);
 
             const exists = await utils.pathExists(dirname, FileType.Directory);
 
@@ -726,10 +796,12 @@ suite('FileSystem Utils', () => {
             const filename = 'x/y/z/spam.py';
             filesystem.setup(f => f.stat(filename))
                 .returns(() => Promise.resolve(stat.object));
+            stat.setup(s => s.type)
+                .returns(() => FileType.SymbolicLink);
 
             const exists = await utils.pathExists(filename, FileType.SymbolicLink);
 
-            expect(exists).to.equal(false);
+            expect(exists).to.equal(true);
             verifyAll();
         });
 
@@ -737,10 +809,12 @@ suite('FileSystem Utils', () => {
             const filename = 'x/y/z/spam.py';
             filesystem.setup(f => f.stat(filename))
                 .returns(() => Promise.resolve(stat.object));
+            stat.setup(s => s.type)
+                .returns(() => FileType.Unknown);
 
             const exists = await utils.pathExists(filename, FileType.Unknown);
 
-            expect(exists).to.equal(false);
+            expect(exists).to.equal(true);
             verifyAll();
         });
     });
@@ -750,8 +824,8 @@ suite('FileSystem Utils', () => {
             const filename = 'x/y/z/spam.py';
             filesystem.setup(f => f.stat(filename))
                 .returns(() => Promise.resolve(stat.object));
-            stat.setup(s => s.isFile())
-                .returns(() => true);
+            stat.setup(s => s.type)
+                .returns(() => FileType.File);
 
             const exists = await utils.fileExists(filename);
 
@@ -765,8 +839,8 @@ suite('FileSystem Utils', () => {
             const dirname = 'x/y/z/spam';
             filesystem.setup(f => f.stat(dirname))
                 .returns(() => Promise.resolve(stat.object));
-            stat.setup(s => s.isDirectory())
-                .returns(() => true);
+            stat.setup(s => s.type)
+                .returns(() => FileType.Directory);
 
             const exists = await utils.directoryExists(dirname);
 
@@ -921,9 +995,9 @@ suite('FileSystem Utils', () => {
             const filename = 'x/y/z/spam.py';
             filesystem.setup(f => f.lstat(filename))
                 .returns(() => Promise.resolve(stat.object));
-            stat.setup(s => s.ctimeMs)
+            stat.setup(s => s.ctime)
                 .returns(() => 101);
-            stat.setup(s => s.mtimeMs)
+            stat.setup(s => s.mtime)
                 .returns(() => 102);
             const expected = '<hash>';
             deps.setup(d => d.getHashString('101-102'))

From a4481018f47d36a146efcb8059a3b4917143911b Mon Sep 17 00:00:00 2001
From: Eric Snow <ericsnowcurrently@gmail.com>
Date: Tue, 29 Oct 2019 15:26:37 -0600
Subject: [PATCH 05/25] Use the new API for writeText().

---
 src/client/common/platform/fileSystem.ts      | 17 ++++-----
 .../platform/filesystem.functional.test.ts    | 36 -------------------
 src/test/common/platform/filesystem.test.ts   | 36 +++++++++++++++++++
 .../common/platform/filesystem.unit.test.ts   | 22 +++++++++---
 4 files changed, 60 insertions(+), 51 deletions(-)

diff --git a/src/client/common/platform/fileSystem.ts b/src/client/common/platform/fileSystem.ts
index b4d1bf247b24..d59e545be9c9 100644
--- a/src/client/common/platform/fileSystem.ts
+++ b/src/client/common/platform/fileSystem.ts
@@ -125,7 +125,7 @@ interface INewAPI {
     readFile(uri: vscode.Uri): Thenable<Uint8Array>;
     //rename(source: vscode.Uri, target: vscode.Uri, options?: {overwrite: boolean}): Thenable<void>;
     stat(uri: vscode.Uri): Thenable<FileStat>;
-    //writeFile(uri: vscode.Uri, content: Uint8Array): Thenable<void>;
+    writeFile(uri: vscode.Uri, content: Uint8Array): Thenable<void>;
 }
 
 // This is the parts of node's 'fs' module that we use in RawFileSystem.
@@ -137,8 +137,6 @@ interface IRawFS {
 // This is the parts of the 'fs-extra' module that we use in RawFileSystem.
 interface IRawFSExtra {
     chmod(filePath: string, mode: string | number): Promise<void>;
-    //tslint:disable-next-line:no-any
-    writeFile(path: string, data: any, options: any): Promise<void>;
     lstat(filename: string): Promise<fsextra.Stats>;
     mkdirp(dirname: string): Promise<void>;
 
@@ -179,6 +177,12 @@ export class RawFileSystem implements IRawFileSystem {
         return data.toString(ENCODING);
     }
 
+    public async writeText(filename: string, text: string): Promise<void> {
+        const uri = vscode.Uri.file(filename);
+        const data = Buffer.from(text);
+        await this.newapi.writeFile(uri, data);
+    }
+
     public async rmtree(dirname: string): Promise<void> {
         const uri = vscode.Uri.file(dirname);
         return this.newapi.delete(uri, {
@@ -208,13 +212,6 @@ export class RawFileSystem implements IRawFileSystem {
     //****************************
     // fs-extra
 
-    public async writeText(filename: string, data: {}): Promise<void> {
-        const options: fsextra.WriteFileOptions = {
-            encoding: ENCODING
-        };
-        await this.fsExtra.writeFile(filename, data, options);
-    }
-
     public async mkdirp(dirname: string): Promise<void> {
         return this.fsExtra.mkdirp(dirname);
     }
diff --git a/src/test/common/platform/filesystem.functional.test.ts b/src/test/common/platform/filesystem.functional.test.ts
index f4c76550955e..c665a1109f90 100644
--- a/src/test/common/platform/filesystem.functional.test.ts
+++ b/src/test/common/platform/filesystem.functional.test.ts
@@ -199,42 +199,6 @@ suite('Raw FileSystem', () => {
         await fix.cleanUp();
     });
 
-    suite('writeText', () => {
-        test('creates the file if missing', async () => {
-            const filename = await fix.resolve('x/y/z/spam.py');
-            await assertDoesNotExist(filename);
-            const data = 'line1\nline2\n';
-
-            await filesystem.writeText(filename, data);
-
-            const actual = await fsextra.readFile(filename)
-                .then(buffer => buffer.toString());
-            expect(actual).to.equal(data);
-        });
-
-        test('always UTF-8', async () => {
-            const filename = await fix.resolve('x/y/z/spam.py');
-            const data = '... 😁 ...';
-
-            await filesystem.writeText(filename, data);
-
-            const actual = await fsextra.readFile(filename)
-                .then(buffer => buffer.toString());
-            expect(actual).to.equal(data);
-        });
-
-        test('overwrites existing file', async () => {
-            const filename = await fix.createFile('x/y/z/spam.py', '...');
-            const data = 'line1\nline2\n';
-
-            await filesystem.writeText(filename, data);
-
-            const actual = await fsextra.readFile(filename)
-                .then(buffer => buffer.toString());
-            expect(actual).to.equal(data);
-        });
-    });
-
     suite('mkdirp', () => {
         test('creates the directory and all missing parents', async () => {
             await fix.createDirectory('x');
diff --git a/src/test/common/platform/filesystem.test.ts b/src/test/common/platform/filesystem.test.ts
index 63d375a9878e..3f09b1c8fcdb 100644
--- a/src/test/common/platform/filesystem.test.ts
+++ b/src/test/common/platform/filesystem.test.ts
@@ -70,6 +70,42 @@ suite('Raw FileSystem', () => {
         });
     });
 
+    suite('writeText', () => {
+        test('creates the file if missing', async () => {
+            const filename = await fix.resolve('x/y/z/spam.py');
+            await assertDoesNotExist(filename);
+            const data = 'line1\nline2\n';
+
+            await filesystem.writeText(filename, data);
+
+            const actual = await fsextra.readFile(filename)
+                .then(buffer => buffer.toString());
+            expect(actual).to.equal(data);
+        });
+
+        test('always UTF-8', async () => {
+            const filename = await fix.resolve('x/y/z/spam.py');
+            const data = '... 😁 ...';
+
+            await filesystem.writeText(filename, data);
+
+            const actual = await fsextra.readFile(filename)
+                .then(buffer => buffer.toString());
+            expect(actual).to.equal(data);
+        });
+
+        test('overwrites existing file', async () => {
+            const filename = await fix.createFile('x/y/z/spam.py', '...');
+            const data = 'line1\nline2\n';
+
+            await filesystem.writeText(filename, data);
+
+            const actual = await fsextra.readFile(filename)
+                .then(buffer => buffer.toString());
+            expect(actual).to.equal(data);
+        });
+    });
+
     suite('rmtree', () => {
         test('deletes the directory and everything in it', async () => {
             const dirname = await fix.createDirectory('x');
diff --git a/src/test/common/platform/filesystem.unit.test.ts b/src/test/common/platform/filesystem.unit.test.ts
index 9f4dfad65361..326cee2345f0 100644
--- a/src/test/common/platform/filesystem.unit.test.ts
+++ b/src/test/common/platform/filesystem.unit.test.ts
@@ -24,6 +24,7 @@ interface IRawFS {
     readDirectory(uri: Uri): Thenable<[string, FileType][]>;
     readFile(uri: Uri): Thenable<Uint8Array>;
     stat(uri: Uri): Thenable<FileStat>;
+    writeFile(uri: Uri, content: Uint8Array): Thenable<void>;
 
     // node "fs"
     //tslint:disable-next-line:no-any
@@ -33,8 +34,6 @@ interface IRawFS {
 
     // "fs-extra"
     chmod(filePath: string, mode: string): Promise<void>;
-    //tslint:disable-next-line:no-any
-    writeFile(path: string, data: any, options: any): Promise<void>;
     lstat(filename: string): Promise<fsextra.Stats>;
     mkdirp(dirname: string): Promise<void>;
     statSync(filename: string): fsextra.Stats;
@@ -340,11 +339,24 @@ suite('Raw FileSystem', () => {
     suite('writeText', () => {
         test('wraps the low-level function', async () => {
             const filename = 'x/y/z/spam.py';
-            const data = '<data>';
-            raw.setup(r => r.writeFile(filename, data, { encoding: 'utf8' }))
+            const text = '<data>';
+            const data = Buffer.from(text);
+            raw.setup(r => r.writeFile(Uri.file(filename), data))
+                .returns(() => Promise.resolve());
+
+            await filesystem.writeText(filename, text);
+
+            verifyAll();
+        });
+
+        test('always UTF-8', async () => {
+            const filename = 'x/y/z/spam.py';
+            const text = '... 😁 ...';
+            const data = Buffer.from(text);
+            raw.setup(r => r.writeFile(Uri.file(filename), data))
                 .returns(() => Promise.resolve());
 
-            await filesystem.writeText(filename, data);
+            await filesystem.writeText(filename, text);
 
             verifyAll();
         });

From 337f4aab32141baaf204fee4ec02d81ee6075445 Mon Sep 17 00:00:00 2001
From: Eric Snow <ericsnowcurrently@gmail.com>
Date: Tue, 29 Oct 2019 15:45:50 -0600
Subject: [PATCH 06/25] Use the new API for copyFile().

---
 src/client/common/platform/fileSystem.ts      | 29 ++++-------
 .../platform/filesystem.functional.test.ts    | 52 -------------------
 src/test/common/platform/filesystem.test.ts   | 52 +++++++++++++++++++
 .../common/platform/filesystem.unit.test.ts   | 43 ++-------------
 4 files changed, 66 insertions(+), 110 deletions(-)

diff --git a/src/client/common/platform/fileSystem.ts b/src/client/common/platform/fileSystem.ts
index d59e545be9c9..35aaefe6190d 100644
--- a/src/client/common/platform/fileSystem.ts
+++ b/src/client/common/platform/fileSystem.ts
@@ -12,7 +12,6 @@ import * as fspath from 'path';
 import * as tmpMod from 'tmp';
 import * as util from 'util';
 import * as vscode from 'vscode';
-import { createDeferred } from '../utils/async';
 import { getOSType, OSType } from '../utils/platform';
 import {
     FileStat, FileType,
@@ -118,7 +117,7 @@ export class TempFileSystem {
 
 // This is the parts of the vscode.workspace.fs API that we use here.
 interface INewAPI {
-    //copy(source: vscode.Uri, target: vscode.Uri, options?: {overwrite: boolean}): Thenable<void>;
+    copy(source: vscode.Uri, target: vscode.Uri, options?: {overwrite: boolean}): Thenable<void>;
     //createDirectory(uri: vscode.Uri): Thenable<void>;
     delete(uri: vscode.Uri, options?: {recursive: boolean; useTrash: boolean}): Thenable<void>;
     readDirectory(uri: vscode.Uri): Thenable<[string, FileType][]>;
@@ -143,8 +142,6 @@ interface IRawFSExtra {
     // non-async
     statSync(filename: string): fsextra.Stats;
     readFileSync(path: string, encoding: string): string;
-    createReadStream(src: string): fsextra.ReadStream;
-    createWriteStream(dest: string): fsextra.WriteStream;
 }
 
 // Later we will drop "FileSystem", switching usage to
@@ -209,6 +206,14 @@ export class RawFileSystem implements IRawFileSystem {
         return this.newapi.readDirectory(uri);
     }
 
+    public async copyFile(src: string, dest: string): Promise<void> {
+        const srcURI = vscode.Uri.file(src);
+        const destURI = vscode.Uri.file(dest);
+        await this.newapi.copy(srcURI, destURI, {
+            overwrite: true
+        });
+    }
+
     //****************************
     // fs-extra
 
@@ -226,22 +231,6 @@ export class RawFileSystem implements IRawFileSystem {
         return convertFileStat(stat);
     }
 
-    public async copyFile(src: string, dest: string): Promise<void> {
-        const deferred = createDeferred<void>();
-        const rs = this.fsExtra.createReadStream(src)
-            .on('error', (err) => {
-                deferred.reject(err);
-            });
-        const ws = this.fsExtra.createWriteStream(dest)
-            .on('error', (err) => {
-                deferred.reject(err);
-            }).on('close', () => {
-                deferred.resolve();
-            });
-        rs.pipe(ws);
-        return deferred.promise;
-    }
-
     //****************************
     // non-async (fs-extra)
 
diff --git a/src/test/common/platform/filesystem.functional.test.ts b/src/test/common/platform/filesystem.functional.test.ts
index c665a1109f90..6add0050d033 100644
--- a/src/test/common/platform/filesystem.functional.test.ts
+++ b/src/test/common/platform/filesystem.functional.test.ts
@@ -316,58 +316,6 @@ suite('Raw FileSystem', () => {
         });
     });
 
-    suite('copyFile', () => {
-        test('the source file gets copied (same directory)', async () => {
-            const data = '<content>';
-            const src = await fix.createFile('x/y/z/spam.py', data);
-            const dest = await fix.resolve('x/y/z/spam.py.bak');
-            await assertDoesNotExist(dest);
-
-            await filesystem.copyFile(src, dest);
-
-            const actual = await fsextra.readFile(dest)
-                .then(buffer => buffer.toString());
-            expect(actual).to.equal(data);
-            const original = await fsextra.readFile(src)
-                .then(buffer => buffer.toString());
-            expect(original).to.equal(data);
-        });
-
-        test('the source file gets copied (different directory)', async () => {
-            const data = '<content>';
-            const src = await fix.createFile('x/y/z/spam.py', data);
-            const dest = await fix.resolve('x/y/eggs.py');
-            await assertDoesNotExist(dest);
-
-            await filesystem.copyFile(src, dest);
-
-            const actual = await fsextra.readFile(dest)
-                .then(buffer => buffer.toString());
-            expect(actual).to.equal(data);
-            const original = await fsextra.readFile(src)
-                .then(buffer => buffer.toString());
-            expect(original).to.equal(data);
-        });
-
-        test('fails if the source does not exist', async () => {
-            const dest = await fix.resolve('x/spam.py');
-
-            const promise = filesystem.copyFile(DOES_NOT_EXIST, dest);
-
-            await expect(promise).to.eventually.be.rejected;
-        });
-
-        test('fails if the target parent directory does not exist', async () => {
-            const src = await fix.createFile('x/spam.py', '...');
-            const dest = await fix.resolve('y/eggs.py', false);
-            await assertDoesNotExist(path.dirname(dest));
-
-            const promise = filesystem.copyFile(src, dest);
-
-            await expect(promise).to.eventually.be.rejected;
-        });
-    });
-
     suite('statSync', () => {
         test('gets the info for an existing file', async () => {
             const filename = await fix.createFile('x/y/z/spam.py', '...');
diff --git a/src/test/common/platform/filesystem.test.ts b/src/test/common/platform/filesystem.test.ts
index 3f09b1c8fcdb..cab7be4d4684 100644
--- a/src/test/common/platform/filesystem.test.ts
+++ b/src/test/common/platform/filesystem.test.ts
@@ -252,6 +252,58 @@ suite('Raw FileSystem', () => {
             await expect(promise).to.eventually.be.rejected;
         });
     });
+
+    suite('copyFile', () => {
+        test('the source file gets copied (same directory)', async () => {
+            const data = '<content>';
+            const src = await fix.createFile('x/y/z/spam.py', data);
+            const dest = await fix.resolve('x/y/z/spam.py.bak');
+            await assertDoesNotExist(dest);
+
+            await filesystem.copyFile(src, dest);
+
+            const actual = await fsextra.readFile(dest)
+                .then(buffer => buffer.toString());
+            expect(actual).to.equal(data);
+            const original = await fsextra.readFile(src)
+                .then(buffer => buffer.toString());
+            expect(original).to.equal(data);
+        });
+
+        test('the source file gets copied (different directory)', async () => {
+            const data = '<content>';
+            const src = await fix.createFile('x/y/z/spam.py', data);
+            const dest = await fix.resolve('x/y/eggs.py');
+            await assertDoesNotExist(dest);
+
+            await filesystem.copyFile(src, dest);
+
+            const actual = await fsextra.readFile(dest)
+                .then(buffer => buffer.toString());
+            expect(actual).to.equal(data);
+            const original = await fsextra.readFile(src)
+                .then(buffer => buffer.toString());
+            expect(original).to.equal(data);
+        });
+
+        test('fails if the source does not exist', async () => {
+            const dest = await fix.resolve('x/spam.py');
+
+            const promise = filesystem.copyFile(DOES_NOT_EXIST, dest);
+
+            await expect(promise).to.eventually.be.rejected;
+        });
+
+        test('fails if the target parent directory does not exist', async () => {
+            const src = await fix.createFile('x/spam.py', '...');
+            const dest = await fix.resolve('y/eggs.py', false);
+            await assertDoesNotExist(path.dirname(dest));
+
+            const promise = filesystem.copyFile(src, dest);
+
+            await expect(promise).to.eventually.be.rejected;
+        });
+    });
 });
 
 suite('FileSystem Utils', () => {
diff --git a/src/test/common/platform/filesystem.unit.test.ts b/src/test/common/platform/filesystem.unit.test.ts
index 326cee2345f0..cedee1df0d98 100644
--- a/src/test/common/platform/filesystem.unit.test.ts
+++ b/src/test/common/platform/filesystem.unit.test.ts
@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 import { expect } from 'chai';
+import * as fs from 'fs';
 import * as fsextra from 'fs-extra';
 import * as TypeMoq from 'typemoq';
 import { Disposable, Uri } from 'vscode';
@@ -20,6 +21,7 @@ import {
 type TempCallback = (err: any, path: string, fd: number, cleanupCallback: () => void) => void;
 interface IRawFS {
     // VS Code
+    copy(source: Uri, target: Uri, options?: {overwrite: boolean}): Thenable<void>;
     delete(uri: Uri, options?: {recursive: boolean; useTrash: boolean}): Thenable<void>;
     readDirectory(uri: Uri): Thenable<[string, FileType][]>;
     readFile(uri: Uri): Thenable<Uint8Array>;
@@ -31,6 +33,7 @@ interface IRawFS {
     open(filename: string, flags: number, callback: any): void;
     //tslint:disable-next-line:no-any
     close(fd: number, callback: any): void;
+    createWriteStream(dest: string): fs.WriteStream;
 
     // "fs-extra"
     chmod(filePath: string, mode: string): Promise<void>;
@@ -38,8 +41,6 @@ interface IRawFS {
     mkdirp(dirname: string): Promise<void>;
     statSync(filename: string): fsextra.Stats;
     readFileSync(path: string, encoding: string): string;
-    createReadStream(src: string): fsextra.ReadStream;
-    createWriteStream(dest: string): fsextra.WriteStream;
 
     // fs paths (IFileSystemPaths)
     join(...filenames: string[]): string;
@@ -500,48 +501,14 @@ suite('Raw FileSystem', () => {
     });
 
     suite('copyFile', () => {
-        let rs: TypeMoq.IMock<fsextra.ReadStream>;
-        let ws: TypeMoq.IMock<fsextra.WriteStream>;
-        let done: () => void;
-        let finished: boolean;
-        setup(() => {
-            rs = TypeMoq.Mock.ofType<fsextra.ReadStream>(undefined, TypeMoq.MockBehavior.Strict);
-            ws = TypeMoq.Mock.ofType<fsextra.WriteStream>(undefined, TypeMoq.MockBehavior.Strict);
-
-            rs.setup(s => s.on('error', TypeMoq.It.isAny()))
-                .returns(() => rs.object);
-            finished = false;
-            done = () => {
-                throw Error();
-            };
-            rs.setup(s => s.pipe(TypeMoq.It.isAny()))
-                .callback(_r => {
-                    done();
-                    finished = true;
-                });
-
-            ws.setup(s => s.on('error', TypeMoq.It.isAny()))
-                .returns(() => ws.object);
-            ws.setup(s => s.on('close', TypeMoq.It.isAny()))
-                .callback((_e, cb) => {
-                    done = cb;
-                })
-                .returns(() => ws.object);
-        });
-
         test('read/write streams are used properly', async () => {
             const src = 'x/y/z/spam.py';
             const dest = 'x/y/z/spam.py.bak';
-            raw.setup(r => r.createReadStream(src))
-                .returns(() => rs.object);
-            raw.setup(r => r.createWriteStream(dest))
-                .returns(() => ws.object);
+            raw.setup(r => r.copy(Uri.file(src), Uri.file(dest), { overwrite: true }))
+                .returns(() => Promise.resolve());
 
             await filesystem.copyFile(src, dest);
 
-            expect(finished).to.equal(true);
-            rs.verifyAll();
-            ws.verifyAll();
             verifyAll();
         });
     });

From d95f92d5cc518d9de5ebebcaca5546bf7507cb5d Mon Sep 17 00:00:00 2001
From: Eric Snow <ericsnowcurrently@gmail.com>
Date: Wed, 30 Oct 2019 17:26:14 -0600
Subject: [PATCH 07/25] Use the new API for mkdirp().

---
 src/client/common/platform/fileSystem.ts      | 65 +++++++++++++--
 src/client/common/platform/types.ts           |  1 +
 .../platform/filesystem.functional.test.ts    | 22 -----
 src/test/common/platform/filesystem.test.ts   | 22 +++++
 .../common/platform/filesystem.unit.test.ts   | 81 ++++++++++++++-----
 src/test/vscode-mock.ts                       |  1 +
 6 files changed, 142 insertions(+), 50 deletions(-)

diff --git a/src/client/common/platform/fileSystem.ts b/src/client/common/platform/fileSystem.ts
index 35aaefe6190d..d07049bf0397 100644
--- a/src/client/common/platform/fileSystem.ts
+++ b/src/client/common/platform/fileSystem.ts
@@ -24,6 +24,17 @@ import {
 
 const ENCODING: string = 'utf8';
 
+const FILE_NOT_FOUND = vscode.FileSystemError.FileNotFound().name;
+const FILE_EXISTS = vscode.FileSystemError.FileExists().name;
+
+function isFileNotFoundError(err: Error): boolean {
+    return err.name === FILE_NOT_FOUND;
+}
+
+function isFileExistsError(err: Error): boolean {
+    return err.name === FILE_EXISTS;
+}
+
 function convertFileStat(stat: fsextra.Stats): FileStat {
     let fileType = FileType.Unknown;
     if (stat.isFile()) {
@@ -44,6 +55,7 @@ function convertFileStat(stat: fsextra.Stats): FileStat {
 // The parts of node's 'path' module used by FileSystemPath.
 interface INodePath {
     join(...filenames: string[]): string;
+    dirname(filename: string): string;
     normalize(filename: string): string;
 }
 
@@ -69,6 +81,10 @@ export class FileSystemPaths implements IFileSystemPaths {
         return this.raw.join(...filenames);
     }
 
+    public dirname(filename: string): string {
+        return this.raw.dirname(filename);
+    }
+
     public normCase(filename: string): string {
         filename = this.raw.normalize(filename);
         return this.isCaseSensitive ? filename.toUpperCase() : filename;
@@ -118,7 +134,7 @@ export class TempFileSystem {
 // This is the parts of the vscode.workspace.fs API that we use here.
 interface INewAPI {
     copy(source: vscode.Uri, target: vscode.Uri, options?: {overwrite: boolean}): Thenable<void>;
-    //createDirectory(uri: vscode.Uri): Thenable<void>;
+    createDirectory(uri: vscode.Uri): Thenable<void>;
     delete(uri: vscode.Uri, options?: {recursive: boolean; useTrash: boolean}): Thenable<void>;
     readDirectory(uri: vscode.Uri): Thenable<[string, FileType][]>;
     readFile(uri: vscode.Uri): Thenable<Uint8Array>;
@@ -137,19 +153,23 @@ interface IRawFS {
 interface IRawFSExtra {
     chmod(filePath: string, mode: string | number): Promise<void>;
     lstat(filename: string): Promise<fsextra.Stats>;
-    mkdirp(dirname: string): Promise<void>;
 
     // non-async
     statSync(filename: string): fsextra.Stats;
     readFileSync(path: string, encoding: string): string;
 }
 
+interface IRawPath {
+    dirname(filename: string): string;
+}
+
 // Later we will drop "FileSystem", switching usage to
 // "FileSystemUtils" and then rename "RawFileSystem" to "FileSystem".
 
 // The low-level filesystem operations used by the extension.
 export class RawFileSystem implements IRawFileSystem {
     constructor(
+        protected readonly path: IRawPath,
         protected readonly newapi: INewAPI,
         protected readonly nodefs: IRawFS,
         protected readonly fsExtra: IRawFSExtra
@@ -158,6 +178,7 @@ export class RawFileSystem implements IRawFileSystem {
     // Create a new object using common-case default values.
     public static withDefaults(): RawFileSystem{
         return new RawFileSystem(
+            FileSystemPaths.withDefaults(),
             vscode.workspace.fs,
             fs,
             fsextra
@@ -206,6 +227,37 @@ export class RawFileSystem implements IRawFileSystem {
         return this.newapi.readDirectory(uri);
     }
 
+    public async mkdirp(dirname: string): Promise<void> {
+        const stack = [dirname];
+        while (stack.length > 0) {
+            const current = stack.pop() || '';
+            const uri = vscode.Uri.file(current);
+            try {
+                await this.newapi.createDirectory(uri);
+            } catch (err) {
+                if (isFileExistsError(err)) {
+                    // already done!
+                    return;
+                }
+                // According to the docs, FileNotFound means the parent
+                // does not exist.
+                // See: https://code.visualstudio.com/api/references/vscode-api#FileSystemProvider
+                if (!isFileNotFoundError(err)) {
+                    // Fail for anything else.
+                    throw err; // re-throw
+                }
+                // Try creating the parent first.
+                const parent = this.path.dirname(current);
+                if (parent === '' || parent === current) {
+                    // This shouldn't ever happen.
+                    throw err;
+                }
+                stack.push(current);
+                stack.push(parent);
+            }
+        }
+    }
+
     public async copyFile(src: string, dest: string): Promise<void> {
         const srcURI = vscode.Uri.file(src);
         const destURI = vscode.Uri.file(dest);
@@ -217,10 +269,6 @@ export class RawFileSystem implements IRawFileSystem {
     //****************************
     // fs-extra
 
-    public async mkdirp(dirname: string): Promise<void> {
-        return this.fsExtra.mkdirp(dirname);
-    }
-
     public async chmod(filename: string, mode: string | number): Promise<void> {
         return this.fsExtra.chmod(filename, mode);
     }
@@ -263,9 +311,10 @@ export class FileSystemUtils implements IFileSystemUtils {
     ) { }
     // Create a new object using common-case default values.
     public static withDefaults(): FileSystemUtils {
+        const paths = FileSystemPaths.withDefaults();
         return new FileSystemUtils(
-            RawFileSystem.withDefaults(),
-            FileSystemPaths.withDefaults(),
+            new RawFileSystem(paths, vscode.workspace.fs, fs, fsextra),
+            paths,
             TempFileSystem.withDefaults(),
             getHashString,
             util.promisify(glob)
diff --git a/src/client/common/platform/types.ts b/src/client/common/platform/types.ts
index b9e0c56ba99d..91b15b5a7d86 100644
--- a/src/client/common/platform/types.ts
+++ b/src/client/common/platform/types.ts
@@ -47,6 +47,7 @@ export interface ITempFileSystem {
 
 export interface IFileSystemPaths {
     join(...filenames: string[]): string;
+    dirname(filename: string): string;
     normCase(filename: string): string;
 }
 
diff --git a/src/test/common/platform/filesystem.functional.test.ts b/src/test/common/platform/filesystem.functional.test.ts
index 6add0050d033..74f3e1f18b7e 100644
--- a/src/test/common/platform/filesystem.functional.test.ts
+++ b/src/test/common/platform/filesystem.functional.test.ts
@@ -199,28 +199,6 @@ suite('Raw FileSystem', () => {
         await fix.cleanUp();
     });
 
-    suite('mkdirp', () => {
-        test('creates the directory and all missing parents', async () => {
-            await fix.createDirectory('x');
-            // x/y, x/y/z, and x/y/z/spam are all missing.
-            const dirname = await fix.resolve('x/y/z/spam', false);
-            await assertDoesNotExist(dirname);
-
-            await filesystem.mkdirp(dirname);
-
-            await assertExists(dirname);
-        });
-
-        test('works if the directory already exists', async () => {
-            const dirname = await fix.createDirectory('spam');
-            await assertExists(dirname);
-
-            await filesystem.mkdirp(dirname);
-
-            await assertExists(dirname);
-        });
-    });
-
     suite('chmod (non-Windows)', () => {
         suiteSetup(function () {
             // On Windows, chmod won't have any effect on the file itself.
diff --git a/src/test/common/platform/filesystem.test.ts b/src/test/common/platform/filesystem.test.ts
index cab7be4d4684..369ad573cdff 100644
--- a/src/test/common/platform/filesystem.test.ts
+++ b/src/test/common/platform/filesystem.test.ts
@@ -253,6 +253,28 @@ suite('Raw FileSystem', () => {
         });
     });
 
+    suite('mkdirp', () => {
+        test('creates the directory and all missing parents', async () => {
+            await fix.createDirectory('x');
+            // x/y, x/y/z, and x/y/z/spam are all missing.
+            const dirname = await fix.resolve('x/y/z/spam', false);
+            await assertDoesNotExist(dirname);
+
+            await filesystem.mkdirp(dirname);
+
+            await assertExists(dirname);
+        });
+
+        test('works if the directory already exists', async () => {
+            const dirname = await fix.createDirectory('spam');
+            await assertExists(dirname);
+
+            await filesystem.mkdirp(dirname);
+
+            await assertExists(dirname);
+        });
+    });
+
     suite('copyFile', () => {
         test('the source file gets copied (same directory)', async () => {
             const data = '<content>';
diff --git a/src/test/common/platform/filesystem.unit.test.ts b/src/test/common/platform/filesystem.unit.test.ts
index cedee1df0d98..4d3aa3071b7a 100644
--- a/src/test/common/platform/filesystem.unit.test.ts
+++ b/src/test/common/platform/filesystem.unit.test.ts
@@ -5,7 +5,7 @@ import { expect } from 'chai';
 import * as fs from 'fs';
 import * as fsextra from 'fs-extra';
 import * as TypeMoq from 'typemoq';
-import { Disposable, Uri } from 'vscode';
+import { Disposable, FileSystemError, Uri } from 'vscode';
 import {
     FileSystemPaths, FileSystemUtils, RawFileSystem, TempFileSystem
 } from '../../../client/common/platform/fileSystem';
@@ -22,6 +22,7 @@ type TempCallback = (err: any, path: string, fd: number, cleanupCallback: () =>
 interface IRawFS {
     // VS Code
     copy(source: Uri, target: Uri, options?: {overwrite: boolean}): Thenable<void>;
+    createDirectory(uri: Uri): Thenable<void>;
     delete(uri: Uri, options?: {recursive: boolean; useTrash: boolean}): Thenable<void>;
     readDirectory(uri: Uri): Thenable<[string, FileType][]>;
     readFile(uri: Uri): Thenable<Uint8Array>;
@@ -38,12 +39,12 @@ interface IRawFS {
     // "fs-extra"
     chmod(filePath: string, mode: string): Promise<void>;
     lstat(filename: string): Promise<fsextra.Stats>;
-    mkdirp(dirname: string): Promise<void>;
     statSync(filename: string): fsextra.Stats;
     readFileSync(path: string, encoding: string): string;
 
     // fs paths (IFileSystemPaths)
     join(...filenames: string[]): string;
+    dirname(filename: string): string;
     normalize(filename: string): string;
 
     // "tmp"
@@ -97,10 +98,10 @@ suite('FileSystem - Temporary files', () => {
 
 suite('FileSystem paths', () => {
     let raw: TypeMoq.IMock<IRawFS>;
-    let path: IFileSystemPaths;
+    let paths: IFileSystemPaths;
     setup(() => {
         raw = TypeMoq.Mock.ofType<IRawFS>(undefined, TypeMoq.MockBehavior.Strict);
-        path = new FileSystemPaths(
+        paths = new FileSystemPaths(
             false, // isWindows
             raw.object
         );
@@ -115,7 +116,20 @@ suite('FileSystem paths', () => {
             raw.setup(r => r.join('x', 'y/z', 'spam.py'))
                 .returns(() => expected);
 
-            const result = path.join('x', 'y/z', 'spam.py');
+            const result = paths.join('x', 'y/z', 'spam.py');
+
+            expect(result).to.equal(expected);
+        });
+    });
+
+    suite('dirname', () => {
+        test('wraps low-level function', () => {
+            const filename = 'x/y/z/spam.py';
+            const expected = 'x/y/z';
+            raw.setup(r => r.dirname(filename))
+                .returns(() => expected);
+
+            const result = paths.dirname(filename);
 
             expect(result).to.equal(expected);
         });
@@ -126,12 +140,12 @@ suite('FileSystem paths', () => {
             const filename = 'x/y/z/spam.py';
             raw.setup(r => r.normalize(filename))
                 .returns(() => filename);
-            path = new FileSystemPaths(
+            paths = new FileSystemPaths(
                 false, // isWindows
                 raw.object
             );
 
-            const result = path.normCase(filename);
+            const result = paths.normCase(filename);
 
             expect(result).to.equal(filename);
             verifyAll();
@@ -142,12 +156,12 @@ suite('FileSystem paths', () => {
             const expected = 'X\\Y\\Z\\SPAM.PY';
             raw.setup(r => r.normalize(filename))
                 .returns(() => expected);
-            path = new FileSystemPaths(
+            paths = new FileSystemPaths(
                 true, // isWindows
                 raw.object
             );
 
-            const result = path.normCase(filename);
+            const result = paths.normCase(filename);
 
             expect(result).to.equal(expected);
             verifyAll();
@@ -158,12 +172,12 @@ suite('FileSystem paths', () => {
             const expected = filename;
             raw.setup(r => r.normalize(filename))
                 .returns(() => expected);
-            path = new FileSystemPaths(
+            paths = new FileSystemPaths(
                 false, // isWindows
                 raw.object
             );
 
-            const result = path.normCase(filename);
+            const result = paths.normCase(filename);
 
             expect(result).to.equal(expected);
             verifyAll();
@@ -174,12 +188,12 @@ suite('FileSystem paths', () => {
             const expected = 'X\\Y\\Z\\SPAM.PY';
             raw.setup(r => r.normalize(filename))
                 .returns(() => filename);
-            path = new FileSystemPaths(
+            paths = new FileSystemPaths(
                 true, // isWindows
                 raw.object
             );
 
-            const result = path.normCase(filename);
+            const result = paths.normCase(filename);
 
             expect(result).to.equal(expected);
             verifyAll();
@@ -190,12 +204,12 @@ suite('FileSystem paths', () => {
             const expected = 'X\\Y\\Z\\SPAM.PY';
             raw.setup(r => r.normalize(filename))
                 .returns(() => expected);
-            path = new FileSystemPaths(
+            paths = new FileSystemPaths(
                 true, // isWindows
                 raw.object
             );
 
-            const result = path.normCase(filename);
+            const result = paths.normCase(filename);
 
             expect(result).to.equal(expected);
             verifyAll();
@@ -206,12 +220,12 @@ suite('FileSystem paths', () => {
             const expected = 'x/y/z/spam.py';
             raw.setup(r => r.normalize(filename))
                 .returns(() => filename);
-            path = new FileSystemPaths(
+            paths = new FileSystemPaths(
                 false, // isWindows
                 raw.object
             );
 
-            const result = path.normCase(filename);
+            const result = paths.normCase(filename);
 
             expect(result).to.equal(expected);
             verifyAll();
@@ -222,12 +236,12 @@ suite('FileSystem paths', () => {
             const expected = 'X/Y/Z/SPAM.PY';
             raw.setup(r => r.normalize(filename))
                 .returns(() => expected);
-            path = new FileSystemPaths(
+            paths = new FileSystemPaths(
                 false, // isWindows
                 raw.object
             );
 
-            const result = path.normCase(filename);
+            const result = paths.normCase(filename);
 
             expect(result).to.equal(expected);
             verifyAll();
@@ -248,6 +262,7 @@ suite('Raw FileSystem', () => {
             //raw.object,
             raw.object,
             raw.object,
+            raw.object,
             raw.object
         );
 
@@ -366,8 +381,34 @@ suite('Raw FileSystem', () => {
     suite('mkdirp', () => {
         test('wraps the low-level function', async () => {
             const dirname = 'x/y/z/spam';
-            raw.setup(r => r.mkdirp(dirname))
+            raw.setup(r => r.createDirectory(Uri.file(dirname)))
+                .returns(() => Promise.resolve());
+
+            await filesystem.mkdirp(dirname);
+
+            verifyAll();
+        });
+
+        test('creates missing parent directories', async () => {
+            const dirname = 'x/y/z/spam';
+            raw.setup(r => r.createDirectory(Uri.file(dirname)))
+                .throws(FileSystemError.FileNotFound(dirname))
+                .verifiable(TypeMoq.Times.exactly(2));
+            raw.setup(r => r.dirname(dirname))
+                .returns(() => 'x/y/z');
+            raw.setup(r => r.createDirectory(Uri.file('x/y/z')))
+                .throws(FileSystemError.FileNotFound('x/y/z'))
+                .verifiable(TypeMoq.Times.exactly(2));
+            raw.setup(r => r.dirname('x/y/z'))
+                .returns(() => 'x/y');
+            raw.setup(r => r.createDirectory(Uri.file('x/y')))
                 .returns(() => Promise.resolve());
+            raw.setup(r => r.createDirectory(Uri.file('x/y/z')))
+                .returns(() => Promise.resolve())
+                .verifiable(TypeMoq.Times.exactly(2));
+            raw.setup(r => r.createDirectory(Uri.file(dirname)))
+                .returns(() => Promise.resolve())
+                .verifiable(TypeMoq.Times.exactly(2));
 
             await filesystem.mkdirp(dirname);
 
diff --git a/src/test/vscode-mock.ts b/src/test/vscode-mock.ts
index 18e56f318b40..1e3cb5721d74 100644
--- a/src/test/vscode-mock.ts
+++ b/src/test/vscode-mock.ts
@@ -83,6 +83,7 @@ mockedVSCode.DebugAdapterExecutable = vscodeMocks.vscMock.DebugAdapterExecutable
 mockedVSCode.DebugAdapterServer = vscodeMocks.vscMock.DebugAdapterServer;
 mockedVSCode.QuickInputButtons = vscodeMocks.vscMockExtHostedTypes.QuickInputButtons;
 mockedVSCode.FileType = vscodeMocks.vscMock.FileType;
+mockedVSCode.FileSystemError = vscodeMocks.vscMockExtHostedTypes.FileSystemError;
 
 // This API is used in src/client/telemetry/telemetry.ts
 const extensions = TypeMoq.Mock.ofType<typeof vscode.extensions>();

From 9815646157172ec4401fc9bcf25fa5292bcb59f7 Mon Sep 17 00:00:00 2001
From: Eric Snow <ericsnowcurrently@gmail.com>
Date: Mon, 4 Nov 2019 15:20:08 -0700
Subject: [PATCH 08/25] Add a NEWS entry.

---
 news/3 Code Health/6911.md | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 news/3 Code Health/6911.md

diff --git a/news/3 Code Health/6911.md b/news/3 Code Health/6911.md
new file mode 100644
index 000000000000..f7a40ecad97d
--- /dev/null
+++ b/news/3 Code Health/6911.md	
@@ -0,0 +1 @@
+Use the new VS Code filesystem API as much as possible.

From 5b8f6cfcfa577ba37d78563ed5ed495e1b4d7c7e Mon Sep 17 00:00:00 2001
From: Eric Snow <ericsnowcurrently@gmail.com>
Date: Mon, 4 Nov 2019 17:34:53 -0700
Subject: [PATCH 09/25] Fix the crypto tests.

---
 src/test/common/crypto.unit.test.ts | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/src/test/common/crypto.unit.test.ts b/src/test/common/crypto.unit.test.ts
index dfa6f1801dcd..e97b5b4adaed 100644
--- a/src/test/common/crypto.unit.test.ts
+++ b/src/test/common/crypto.unit.test.ts
@@ -4,19 +4,23 @@
 'use strict';
 
 import { assert, expect } from 'chai';
+import * as fsextra from 'fs-extra';
 import * as path from 'path';
 import { CryptoUtils } from '../../client/common/crypto';
-import { FileSystem } from '../../client/common/platform/fileSystem';
 import { EXTENSION_ROOT_DIR_FOR_TESTS } from '../constants';
 
 // tslint:disable-next-line: max-func-body-length
 suite('Crypto Utils', async () => {
     let crypto: CryptoUtils;
-    const fs = new FileSystem();
-    const file = path.join(EXTENSION_ROOT_DIR_FOR_TESTS, 'src', 'test', 'common', 'randomWords.txt');
     setup(() => {
         crypto = new CryptoUtils();
     });
+    async function getWordList(): Promise<string[]> {
+        const file = path.join(EXTENSION_ROOT_DIR_FOR_TESTS, 'src', 'test', 'common', 'randomWords.txt');
+        const words = await fsextra.readFile(file, 'utf8');
+        return words.split('\n');
+    }
+
     test('If hashFormat equals `number`, method createHash() returns a number', async () => {
         const hash = crypto.createHash('blabla', 'number');
         assert.typeOf(hash, 'number', 'Type should be a number');
@@ -52,8 +56,7 @@ suite('Crypto Utils', async () => {
         assert.notEqual(hash1, hash2, 'Hashes should be different strings');
     });
     test('If hashFormat equals `number`, ensure numbers are uniformly distributed on scale from 0 to 100', async () => {
-        const words = await fs.readFile(file);
-        const wordList = words.split('\n');
+        const wordList = await getWordList();
         const buckets: number[] = Array(100).fill(0);
         const hashes = Array(10).fill(0);
         for (const w of wordList) {
@@ -72,8 +75,7 @@ suite('Crypto Utils', async () => {
         }
     });
     test('If hashFormat equals `number`, on a scale of 0 to 100, small difference in the input on average produce large differences (about 33) in the output ', async () => {
-        const words = await fs.readFile(file);
-        const wordList = words.split('\n');
+        const wordList = await getWordList();
         const buckets: number[] = Array(100).fill(0);
         let hashes: number[] = [];
         let totalDifference = 0;

From 027cf5c17592276701502d8441892217faf19aac Mon Sep 17 00:00:00 2001
From: Eric Snow <ericsnowcurrently@gmail.com>
Date: Tue, 5 Nov 2019 15:16:39 -0700
Subject: [PATCH 10/25] Fix WorkspaceSymbolProvider tests.

---
 src/client/workspaceSymbols/provider.ts | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/client/workspaceSymbols/provider.ts b/src/client/workspaceSymbols/provider.ts
index 019bcd25592d..ee2460be6e8c 100644
--- a/src/client/workspaceSymbols/provider.ts
+++ b/src/client/workspaceSymbols/provider.ts
@@ -43,7 +43,13 @@ export class WorkspaceSymbolProvider implements IWorspaceSymbolProvider {
             .filter(generator => generator !== undefined && generator.enabled)
             .map(async generator => {
                 // load tags
-                const items = await parseTags(generator!.workspaceFolder.fsPath, generator!.tagFilePath, query, token);
+                const items = await parseTags(
+                    generator!.workspaceFolder.fsPath,
+                    generator!.tagFilePath,
+                    query,
+                    token,
+                    this.fs
+                );
                 if (!Array.isArray(items)) {
                     return [];
                 }

From 5c089b10cb273c62ea6a0a8a471cabf65805c0fa Mon Sep 17 00:00:00 2001
From: Eric Snow <ericsnowcurrently@gmail.com>
Date: Tue, 5 Nov 2019 16:28:42 -0700
Subject: [PATCH 11/25] Fix datascience functional tests.

---
 src/client/common/platform/fileSystem.ts      | 12 ++-
 .../datascience/dataScienceIocContainer.ts    |  1 +
 src/test/serviceRegistry.ts                   | 80 ++++++++++++++++++-
 3 files changed, 87 insertions(+), 6 deletions(-)

diff --git a/src/client/common/platform/fileSystem.ts b/src/client/common/platform/fileSystem.ts
index d07049bf0397..05492f7e5921 100644
--- a/src/client/common/platform/fileSystem.ts
+++ b/src/client/common/platform/fileSystem.ts
@@ -354,7 +354,7 @@ export class FileSystemUtils implements IFileSystemUtils {
     ): Promise<boolean> {
         let stat: FileStat;
         try {
-            stat = await this.raw.stat(filename);
+            stat = await this._stat(filename);
         } catch (err) {
             return false;
         }
@@ -395,7 +395,7 @@ export class FileSystemUtils implements IFileSystemUtils {
             tmpFile = await this.tmp.createFile('___vscpTest___', dirname);
         } catch {
             // Use a stat call to ensure the directory exists.
-            await this.raw.stat(dirname);
+            await this._stat(dirname);
             return true;
         }
         tmpFile.dispose();
@@ -412,6 +412,10 @@ export class FileSystemUtils implements IFileSystemUtils {
         const files = await this.globFile(globPattern);
         return Array.isArray(files) ? files : [];
     }
+
+    public async _stat(filename: string): Promise<FileStat> {
+        return this.raw.stat(filename);
+    }
 }
 
 // We *could* use ICryptoUtils, but it's a bit overkill, issue tracked
@@ -425,7 +429,7 @@ function getHashString(data: string): string {
 // more aliases (to cause less churn)
 @injectable()
 export class FileSystem implements IFileSystem {
-    private readonly utils: FileSystemUtils;
+    protected readonly utils: FileSystemUtils;
     constructor() {
         this.utils = FileSystemUtils.withDefaults();
     }
@@ -486,7 +490,7 @@ export class FileSystem implements IFileSystem {
     // aliases
 
     public async stat(filePath: string): Promise<FileStat> {
-        return this.utils.raw.stat(filePath);
+        return this.utils._stat(filePath);
     }
 
     public async readFile(filename: string): Promise<string> {
diff --git a/src/test/datascience/dataScienceIocContainer.ts b/src/test/datascience/dataScienceIocContainer.ts
index fd32cfb78932..9df188b5f8ad 100644
--- a/src/test/datascience/dataScienceIocContainer.ts
+++ b/src/test/datascience/dataScienceIocContainer.ts
@@ -298,6 +298,7 @@ export class DataScienceIocContainer extends UnitTestIocContainer {
 
     constructor() {
         super();
+        this.vscode = false;
         const isRollingBuild = process.env ? process.env.VSCODE_PYTHON_ROLLING !== undefined : false;
         this.shouldMockJupyter = !isRollingBuild;
         this.asyncRegistry = new AsyncDisposableRegistry();
diff --git a/src/test/serviceRegistry.ts b/src/test/serviceRegistry.ts
index 11335a1ba111..077ddf50913e 100644
--- a/src/test/serviceRegistry.ts
+++ b/src/test/serviceRegistry.ts
@@ -1,7 +1,9 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+import * as fsextra from 'fs-extra';
 import { Container } from 'inversify';
+import * as path from 'path';
 import { anything, instance, mock, when } from 'ts-mockito';
 import * as TypeMoq from 'typemoq';
 import { Disposable, Memento, OutputChannel } from 'vscode';
@@ -13,7 +15,7 @@ import { PathUtils } from '../client/common/platform/pathUtils';
 import { PlatformService } from '../client/common/platform/platformService';
 import { RegistryImplementation } from '../client/common/platform/registry';
 import { registerTypes as platformRegisterTypes } from '../client/common/platform/serviceRegistry';
-import { IFileSystem, IPlatformService, IRegistry } from '../client/common/platform/types';
+import { FileStat, FileType, IFileSystem, IPlatformService, IRegistry } from '../client/common/platform/types';
 import { BufferDecoder } from '../client/common/process/decoder';
 import { ProcessService } from '../client/common/process/proc';
 import { PythonExecutionFactory } from '../client/common/process/pythonExecutionFactory';
@@ -22,6 +24,7 @@ import { registerTypes as processRegisterTypes } from '../client/common/process/
 import { IBufferDecoder, IProcessServiceFactory, IPythonExecutionFactory, IPythonToolExecutionService } from '../client/common/process/types';
 import { registerTypes as commonRegisterTypes } from '../client/common/serviceRegistry';
 import { GLOBAL_MEMENTO, ICurrentProcess, IDisposableRegistry, ILogger, IMemento, IOutputChannel, IPathUtils, IsWindows, WORKSPACE_MEMENTO } from '../client/common/types';
+import { createDeferred } from '../client/common/utils/async';
 import { registerTypes as variableRegisterTypes } from '../client/common/variables/serviceRegistry';
 import { registerTypes as formattersRegisterTypes } from '../client/formatters/serviceRegistry';
 import { EnvironmentActivationService } from '../client/interpreter/activation/service';
@@ -58,7 +61,77 @@ import { MockMemento } from './mocks/mementos';
 import { MockProcessService } from './mocks/proc';
 import { MockProcess } from './mocks/process';
 
+// This is necessary for unit tests and functional tests, since they
+// do not run under VS Code so they do not have access to the actual
+// "vscode" namespace.
+class LegacyFileSystem extends FileSystem {
+    public async readFile(filename: string): Promise<string> {
+        return fsextra.readFile(filename, 'utf8');
+    }
+    public async writeFile(filename: string, data: {}): Promise<void> {
+        const options: fsextra.WriteFileOptions = {
+            encoding: 'utf8'
+        };
+        return fsextra.writeFile(filename, data, options);
+    }
+    public async deleteDirectory(dirname: string): Promise<void> {
+        return fsextra.stat(dirname)
+            .then(() => fsextra.remove(dirname));
+    }
+    public async deleteFile(filename: string): Promise<void> {
+        return fsextra.unlink(filename);
+    }
+    public async listdir(dirname: string): Promise<[string, FileType][]> {
+        const names: string[] = await fsextra.readdir(dirname);
+        const promises = names
+            .map(name => {
+                 const filename = path.join(dirname, name);
+                 return this.utils.raw.lstat(filename)
+                     .then(stat => [name, stat.type] as [string, FileType])
+                     .catch(() => [name, FileType.Unknown] as [string, FileType]);
+            });
+        return Promise.all(promises);
+    }
+    public async createDirectory(dirname: string): Promise<void> {
+        return fsextra.mkdirp(dirname);
+    }
+    public async copyFile(src: string, dest: string): Promise<void> {
+        const deferred = createDeferred<void>();
+        const rs = fsextra.createReadStream(src)
+            .on('error', (err) => {
+                deferred.reject(err);
+            });
+        const ws = fsextra.createWriteStream(dest)
+            .on('error', (err) => {
+                deferred.reject(err);
+            }).on('close', () => {
+                deferred.resolve();
+            });
+        rs.pipe(ws);
+        return deferred.promise;
+    }
+    protected async _stat(filePath: string): Promise<FileStat> {
+        const stat = await fsextra.stat(filePath);
+        let fileType = FileType.Unknown;
+        if (stat.isFile()) {
+            fileType = FileType.File;
+        } else if (stat.isDirectory()) {
+            fileType = FileType.Directory;
+        } else if (stat.isSymbolicLink()) {
+            fileType = FileType.SymbolicLink;
+        }
+        return {
+            type: fileType,
+            size: stat.size,
+            ctime: stat.ctimeMs,
+            mtime: stat.mtimeMs
+        };
+    }
+}
+
 export class IocContainer {
+    public vscode = true;
+
     public readonly serviceManager: IServiceManager;
     public readonly serviceContainer: IServiceContainer;
 
@@ -105,7 +178,10 @@ export class IocContainer {
     }
     public registerFileSystemTypes() {
         this.serviceManager.addSingleton<IPlatformService>(IPlatformService, PlatformService);
-        this.serviceManager.addSingleton<IFileSystem>(IFileSystem, FileSystem);
+        this.serviceManager.addSingleton<IFileSystem>(
+            IFileSystem,
+            this.vscode ? FileSystem : LegacyFileSystem
+        );
     }
     public registerProcessTypes() {
         processRegisterTypes(this.serviceManager);

From adc9d3da766991abb87f34f6019bf8051484ac80 Mon Sep 17 00:00:00 2001
From: Eric Snow <ericsnowcurrently@gmail.com>
Date: Wed, 6 Nov 2019 16:44:46 -0700
Subject: [PATCH 12/25] Make sure the DOES_NOT_EXIST file really does not
 exist.

---
 src/test/common/platform/filesystem.test.ts | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/test/common/platform/filesystem.test.ts b/src/test/common/platform/filesystem.test.ts
index 369ad573cdff..022dd1316406 100644
--- a/src/test/common/platform/filesystem.test.ts
+++ b/src/test/common/platform/filesystem.test.ts
@@ -23,9 +23,11 @@ import {
 suite('Raw FileSystem', () => {
     let filesystem: IRawFileSystem;
     let fix: FSFixture;
-    setup(() => {
+    setup(async () => {
         filesystem = RawFileSystem.withDefaults();
         fix = new FSFixture();
+
+        await assertDoesNotExist(DOES_NOT_EXIST);
     });
     teardown(async () => {
         await fix.cleanUp();

From fdf374a4416eb36a7a47b2f96c033ed15b81485b Mon Sep 17 00:00:00 2001
From: Eric Snow <ericsnowcurrently@gmail.com>
Date: Wed, 6 Nov 2019 16:49:17 -0700
Subject: [PATCH 13/25] Fix the listdir() system test.

---
 src/test/common/platform/filesystem.test.ts      | 4 ++--
 src/test/common/platform/filesystem.unit.test.ts | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/test/common/platform/filesystem.test.ts b/src/test/common/platform/filesystem.test.ts
index 022dd1316406..30c5da567547 100644
--- a/src/test/common/platform/filesystem.test.ts
+++ b/src/test/common/platform/filesystem.test.ts
@@ -233,8 +233,8 @@ suite('Raw FileSystem', () => {
                 ['__init__.py', FileType.File],
                 ['__main__.py', FileType.File],
                 ['eggs.py', FileType.File],
-                ['info.py', FileType.SymbolicLink],
-                ['ipc.sock', FileType.Unknown],
+                ['info.py', FileType.SymbolicLink | FileType.File],
+                ['ipc.sock', FileType.File], // This isn't "Unknown" for some reason.
                 ['spam.py', FileType.File],
                 ['w', FileType.Directory]
             ]);
diff --git a/src/test/common/platform/filesystem.unit.test.ts b/src/test/common/platform/filesystem.unit.test.ts
index 4d3aa3071b7a..896aa6dee545 100644
--- a/src/test/common/platform/filesystem.unit.test.ts
+++ b/src/test/common/platform/filesystem.unit.test.ts
@@ -506,7 +506,7 @@ suite('Raw FileSystem', () => {
                 ['dev1', FileType.Unknown],
                 ['w', FileType.Directory],
                 ['spam.py', FileType.File],
-                ['other', FileType.SymbolicLink]
+                ['other', FileType.SymbolicLink | FileType.File]
             ];
             raw.setup(r => r.readDirectory(Uri.file(dirname)))
                 .returns(() => Promise.resolve(expected));

From 1fc8d26d5ab32912f61404891971d4d9c3ce9737 Mon Sep 17 00:00:00 2001
From: Eric Snow <ericsnowcurrently@gmail.com>
Date: Wed, 6 Nov 2019 17:27:13 -0700
Subject: [PATCH 14/25] Fix the stat() system tests.

---
 src/test/common/platform/filesystem.test.ts | 36 ++++++++++-----------
 1 file changed, 17 insertions(+), 19 deletions(-)

diff --git a/src/test/common/platform/filesystem.test.ts b/src/test/common/platform/filesystem.test.ts
index 30c5da567547..aadc5733b05a 100644
--- a/src/test/common/platform/filesystem.test.ts
+++ b/src/test/common/platform/filesystem.test.ts
@@ -8,7 +8,7 @@ import {
     FileSystem, FileSystemUtils, RawFileSystem
 } from '../../../client/common/platform/fileSystem';
 import {
-    FileType,
+    FileStat, FileType,
     IFileSystemUtils, IRawFileSystem
 } from '../../../client/common/platform/types';
 import {
@@ -144,15 +144,23 @@ suite('Raw FileSystem', () => {
     });
 
     suite('stat', () => {
+        function convertStat(old: fsextra.Stats, filetype: FileType): FileStat {
+            return {
+                type: filetype,
+                size: old.size,
+                // XXX Apparently VS Code's new "fs" has granularity of seconds.
+                // So we round to the nearest integer.
+                // XXX ctime is showing up as 0.
+                ctime: 0,
+                //ctime: Math.round(old.ctimeMs),
+                mtime: Math.round(old.mtimeMs)
+            };
+        }
+
         test('gets the info for an existing file', async () => {
             const filename = await fix.createFile('x/y/z/spam.py', '...');
             const old = await fsextra.stat(filename);
-            const expected = {
-                type: FileType.File,
-                size: old.size,
-                ctime: old.ctimeMs,
-                mtime: old.mtimeMs
-            };
+            const expected = convertStat(old, FileType.File);
 
             const stat = await filesystem.stat(filename);
 
@@ -162,12 +170,7 @@ suite('Raw FileSystem', () => {
         test('gets the info for an existing directory', async () => {
             const dirname = await fix.createDirectory('x/y/z/spam');
             const old = await fsextra.stat(dirname);
-            const expected = {
-                type: FileType.Directory,
-                size: old.size,
-                ctime: old.ctimeMs,
-                mtime: old.mtimeMs
-            };
+            const expected = convertStat(old, FileType.Directory);
 
             const stat = await filesystem.stat(dirname);
 
@@ -178,12 +181,7 @@ suite('Raw FileSystem', () => {
             const filename = await fix.createFile('x/y/z/spam.py', '...');
             const symlink = await fix.createSymlink('x/y/z/eggs.py', filename);
             const old = await fsextra.stat(filename);
-            const expected = {
-                type: FileType.SymbolicLink,
-                size: old.size,
-                ctime: old.ctimeMs,
-                mtime: old.mtimeMs
-            };
+            const expected = convertStat(old, FileType.SymbolicLink | FileType.File);
 
             const stat = await filesystem.stat(symlink);
 

From 5e455f0a3c8feaac95063eb46aa9d547c9d4133f Mon Sep 17 00:00:00 2001
From: Eric Snow <ericsnowcurrently@gmail.com>
Date: Wed, 6 Nov 2019 17:30:09 -0700
Subject: [PATCH 15/25] Fix the getFiles() system tests.

---
 src/test/common/platform/filesystem.test.ts | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/test/common/platform/filesystem.test.ts b/src/test/common/platform/filesystem.test.ts
index aadc5733b05a..2964d1d0ce04 100644
--- a/src/test/common/platform/filesystem.test.ts
+++ b/src/test/common/platform/filesystem.test.ts
@@ -468,16 +468,17 @@ suite('FileSystem Utils', () => {
             const file1 = await fix.createFile('x/y/z/scripts/spam.py');
             await fix.createDirectory('x/y/z/scripts/v');
             const file2 = await fix.createFile('x/y/z/scripts/eggs.py');
-            await fix.createSocket('x/y/z/scripts/spam.sock');
+            const file3 = await fix.createSocket('x/y/z/scripts/spam.sock');
             await fix.createSymlink('x/y/z/scripts/other', symlinkSource);
-            const file3 = await fix.createFile('x/y/z/scripts/data.json');
+            const file4 = await fix.createFile('x/y/z/scripts/data.json');
 
             const results = await utils.getFiles(dirname);
 
             expect(results.sort()).to.deep.equal([
-                file3,
+                file4,
                 file2,
-                file1
+                file1,
+                file3
             ]);
         });
 

From 35c5b1b22691d8c24370ba8c32fae34e0588774a Mon Sep 17 00:00:00 2001
From: Eric Snow <ericsnowcurrently@gmail.com>
Date: Thu, 7 Nov 2019 15:54:29 -0700
Subject: [PATCH 16/25] Work around upstream bugs in the new "fs" API.

---
 src/client/common/platform/fileSystem.ts      | 26 +++++-
 src/test/common/platform/filesystem.test.ts   |  9 +-
 .../common/platform/filesystem.unit.test.ts   | 83 ++++++++++++-------
 3 files changed, 84 insertions(+), 34 deletions(-)

diff --git a/src/client/common/platform/fileSystem.ts b/src/client/common/platform/fileSystem.ts
index 05492f7e5921..c7b6752cca2c 100644
--- a/src/client/common/platform/fileSystem.ts
+++ b/src/client/common/platform/fileSystem.ts
@@ -21,6 +21,7 @@ import {
 } from './types';
 
 // tslint:disable:max-classes-per-file
+// tslint:disable:no-suspicious-comment
 
 const ENCODING: string = 'utf8';
 
@@ -203,6 +204,11 @@ export class RawFileSystem implements IRawFileSystem {
 
     public async rmtree(dirname: string): Promise<void> {
         const uri = vscode.Uri.file(dirname);
+        // TODO (https://github.com/microsoft/vscode/issues/84177)
+        //   The docs say "throws - FileNotFound when uri doesn't exist".
+        //   However, it happily does nothing (at least for remote-over-SSH).
+        //   So we have to manually stat, just to be sure.
+        await this.newapi.stat(uri);
         return this.newapi.delete(uri, {
             recursive: true,
             useTrash: false
@@ -228,6 +234,9 @@ export class RawFileSystem implements IRawFileSystem {
     }
 
     public async mkdirp(dirname: string): Promise<void> {
+        // TODO https://github.com/microsoft/vscode/issues/84175
+        //   Hopefully VS Code provides this method in their API
+        //   so we don't have to roll our own.
         const stack = [dirname];
         while (stack.length > 0) {
             const current = stack.pop() || '';
@@ -261,6 +270,12 @@ export class RawFileSystem implements IRawFileSystem {
     public async copyFile(src: string, dest: string): Promise<void> {
         const srcURI = vscode.Uri.file(src);
         const destURI = vscode.Uri.file(dest);
+        // TODO (https://github.com/microsoft/vscode/issues/84177)
+        //   The docs say "throws - FileNotFound when parent of
+        //   destination doesn't exist".  However, it happily creates
+        //   the parent directory (at least for remote-over-SSH).
+        //   So we have to manually stat, just to be sure.
+        await this.newapi.stat(vscode.Uri.file(this.path.dirname(dest)));
         await this.newapi.copy(srcURI, destURI, {
             overwrite: true
         });
@@ -270,11 +285,14 @@ export class RawFileSystem implements IRawFileSystem {
     // fs-extra
 
     public async chmod(filename: string, mode: string | number): Promise<void> {
+        // TODO https://github.com/microsoft/vscode/issues/84175
+        //   This functionality has been requested for the VS Code API.
         return this.fsExtra.chmod(filename, mode);
     }
 
     public async lstat(filename: string): Promise<FileStat> {
-        // At the moment the new VS Code API does not seem to support lstat...
+        // TODO https://github.com/microsoft/vscode/issues/84175
+        //   This functionality has been requested for the VS Code API.
         const stat = await this.fsExtra.lstat(filename);
         return convertFileStat(stat);
     }
@@ -283,11 +301,15 @@ export class RawFileSystem implements IRawFileSystem {
     // non-async (fs-extra)
 
     public statSync(filename: string): FileStat {
+        // TODO https://github.com/microsoft/vscode/issues/84175
+        //   This functionality has been requested for the VS Code API.
         const stat = this.fsExtra.statSync(filename);
         return convertFileStat(stat);
     }
 
     public readTextSync(filename: string): string {
+        // TODO https://github.com/microsoft/vscode/issues/84175
+        //   This functionality has been requested for the VS Code API.
         return this.fsExtra.readFileSync(filename, ENCODING);
     }
 
@@ -295,6 +317,8 @@ export class RawFileSystem implements IRawFileSystem {
     // non-async (fs)
 
     public createWriteStream(filename: string): WriteStream {
+        // TODO https://github.com/microsoft/vscode/issues/84175
+        //   This functionality has been requested for the VS Code API.
         return this.nodefs.createWriteStream(filename);
     }
 }
diff --git a/src/test/common/platform/filesystem.test.ts b/src/test/common/platform/filesystem.test.ts
index 2964d1d0ce04..626d8e71d189 100644
--- a/src/test/common/platform/filesystem.test.ts
+++ b/src/test/common/platform/filesystem.test.ts
@@ -19,6 +19,7 @@ import {
 // are found in filesystem.functional.test.ts.
 
 // tslint:disable:max-func-body-length chai-vague-errors
+// tslint:disable:no-suspicious-comment
 
 suite('Raw FileSystem', () => {
     let filesystem: IRawFileSystem;
@@ -148,9 +149,11 @@ suite('Raw FileSystem', () => {
             return {
                 type: filetype,
                 size: old.size,
-                // XXX Apparently VS Code's new "fs" has granularity of seconds.
-                // So we round to the nearest integer.
-                // XXX ctime is showing up as 0.
+                // TODO (https://github.com/microsoft/vscode/issues/84177)
+                //   FileStat.ctime and FileStat.mtime only have 1-second resolution.
+                //   So for now we round to the nearest integer.
+                // TODO (https://github.com/microsoft/vscode/issues/84177)
+                //   FileStat.ctime is consistently 0 instead of the actual ctime.
                 ctime: 0,
                 //ctime: Math.round(old.ctimeMs),
                 mtime: Math.round(old.mtimeMs)
diff --git a/src/test/common/platform/filesystem.unit.test.ts b/src/test/common/platform/filesystem.unit.test.ts
index 896aa6dee545..b40657244dd3 100644
--- a/src/test/common/platform/filesystem.unit.test.ts
+++ b/src/test/common/platform/filesystem.unit.test.ts
@@ -17,6 +17,28 @@ import {
 
 // tslint:disable:max-func-body-length chai-vague-errors
 
+function createMockStat(): TypeMoq.IMock<FileStat> {
+    const stat = TypeMoq.Mock.ofType<FileStat>(undefined, TypeMoq.MockBehavior.Strict);
+    // This is necessary because passing "mock.object" to
+    // Promise.resolve() triggers the lookup.
+    //tslint:disable-next-line:no-any
+    stat.setup((s: any) => s.then)
+        .returns(() => undefined)
+        .verifiable(TypeMoq.Times.atLeast(0));
+    return stat;
+}
+
+function createMockLegacyStat(): TypeMoq.IMock<fsextra.Stats> {
+    const stat = TypeMoq.Mock.ofType<fsextra.Stats>(undefined, TypeMoq.MockBehavior.Strict);
+    // This is necessary because passing "mock.object" to
+    // Promise.resolve() triggers the lookup.
+    //tslint:disable-next-line:no-any
+    stat.setup((s: any) => s.then)
+        .returns(() => undefined)
+        .verifiable(TypeMoq.Times.atLeast(0));
+    return stat;
+}
+
 //tslint:disable-next-line:no-any
 type TempCallback = (err: any, path: string, fd: number, cleanupCallback: () => void) => void;
 interface IRawFS {
@@ -251,31 +273,20 @@ suite('FileSystem paths', () => {
 
 suite('Raw FileSystem', () => {
     let raw: TypeMoq.IMock<IRawFS>;
-    //let stat: TypeMoq.IMock<FileStat>;
     let oldStat: TypeMoq.IMock<fsextra.Stats>;
     let filesystem: IRawFileSystem;
     setup(() => {
         raw = TypeMoq.Mock.ofType<IRawFS>(undefined, TypeMoq.MockBehavior.Strict);
-        //stat = TypeMoq.Mock.ofType<FileStat>(undefined, TypeMoq.MockBehavior.Strict);
-        oldStat = TypeMoq.Mock.ofType<fsextra.Stats>(undefined, TypeMoq.MockBehavior.Strict);
+        oldStat = createMockLegacyStat();
         filesystem = new RawFileSystem(
-            //raw.object,
             raw.object,
             raw.object,
             raw.object,
             raw.object
         );
-
-        // This is necessary because passing "stat.object" to
-        // Promise.resolve() triggers the lookup.
-        //tslint:disable-next-line:no-any
-        oldStat.setup((s: any) => s.then)
-            .returns(() => undefined)
-            .verifiable(TypeMoq.Times.atLeast(0));
     });
     function verifyAll() {
         raw.verifyAll();
-        //stat.verifyAll();
         oldStat.verifyAll();
     }
 
@@ -283,16 +294,9 @@ suite('Raw FileSystem', () => {
         if (old === undefined) {
             old = oldStat;
         } else if (old === null) {
-            old = TypeMoq.Mock.ofType<fsextra.Stats>(undefined, TypeMoq.MockBehavior.Strict);
+            old = createMockLegacyStat();
         }
 
-        // This is necessary because passing "stat.object" to
-        // Promise.resolve() triggers the lookup.
-        //tslint:disable-next-line:no-any
-        old!.setup((s: any) => s.then)
-            .returns(() => undefined)
-            .verifiable(TypeMoq.Times.atLeast(0));
-
         if (stat.type === FileType.File) {
             old!.setup(s => s.isFile())
                 .returns(() => true);
@@ -419,22 +423,28 @@ suite('Raw FileSystem', () => {
     suite('rmtree', () => {
         test('wraps the low-level function', async () => {
             const dirname = 'x/y/z/spam';
-            raw.setup(r => r.delete(Uri.file(dirname), { recursive: true, useTrash: false }))
+            const uri = Uri.file(dirname);
+            const stat = createMockStat();
+            raw.setup(r => r.stat(uri))
+                .returns(() => Promise.resolve(stat.object));
+            raw.setup(r => r.delete(uri, { recursive: true, useTrash: false }))
                 .returns(() => Promise.resolve());
 
             await filesystem.rmtree(dirname);
 
             verifyAll();
+            stat.verifyAll();
         });
 
         test('fails if the directory does not exist', async () => {
             const dirname = 'x/y/z/spam';
-            raw.setup(r => r.delete(Uri.file(dirname), { recursive: true, useTrash: false }))
+            raw.setup(r => r.stat(Uri.file(dirname)))
                 .throws(new Error('file not found'));
 
             const promise = filesystem.rmtree(dirname);
 
             await expect(promise).to.eventually.be.rejected;
+            verifyAll();
         });
     });
 
@@ -545,12 +555,32 @@ suite('Raw FileSystem', () => {
         test('read/write streams are used properly', async () => {
             const src = 'x/y/z/spam.py';
             const dest = 'x/y/z/spam.py.bak';
+            raw.setup(r => r.dirname(dest))
+                .returns(() => 'x/y/z');
+            const stat = createMockStat();
+            raw.setup(r => r.stat(Uri.file('x/y/z')))
+                .returns(() => Promise.resolve(stat.object));
             raw.setup(r => r.copy(Uri.file(src), Uri.file(dest), { overwrite: true }))
                 .returns(() => Promise.resolve());
 
             await filesystem.copyFile(src, dest);
 
             verifyAll();
+            stat.verifyAll();
+        });
+
+        test('fails if the parent directory does not exist', async () => {
+            const src = '/tmp/spam.py';
+            const dest = '/tmp/__does_not_exist__/spam.py';
+            raw.setup(r => r.dirname(dest))
+                .returns(() => '/tmp/__does_not_exist__');
+            raw.setup(r => r.stat(Uri.file('/tmp/__does_not_exist__')))
+                .throws(new Error('file not found'));
+
+            const promise = filesystem.copyFile(src, dest);
+
+            await expect(promise).to.eventually.be.rejected;
+            verifyAll();
         });
     });
 
@@ -630,7 +660,7 @@ suite('FileSystem Utils', () => {
     let deps: TypeMoq.IMock<IDeps>;
     let utils: IFileSystemUtils;
     setup(() => {
-        stat = TypeMoq.Mock.ofType<FileStat>(undefined, TypeMoq.MockBehavior.Strict);
+        stat = createMockStat();
         filesystem = TypeMoq.Mock.ofType<IRawFileSystem>(undefined, TypeMoq.MockBehavior.Strict);
         path = TypeMoq.Mock.ofType<IFileSystemPaths>(undefined, TypeMoq.MockBehavior.Strict);
         tmp = TypeMoq.Mock.ofType<ITempFileSystem>(undefined, TypeMoq.MockBehavior.Strict);
@@ -642,13 +672,6 @@ suite('FileSystem Utils', () => {
             ((data: string) => deps.object.getHashString(data)),
             ((p: string) => deps.object.glob(p))
         );
-
-        // This is necessary because passing "stat.object" to
-        // Promise.resolve() triggers the lookup.
-        //tslint:disable-next-line:no-any
-        stat.setup((s: any) => s.then)
-            .returns(() => undefined)
-            .verifiable(TypeMoq.Times.atLeast(0));
     });
     function verifyAll() {
         filesystem.verifyAll();

From 838a8a5f2efa742e86a6866934fd75db96405619 Mon Sep 17 00:00:00 2001
From: Eric Snow <ericsnowcurrently@gmail.com>
Date: Tue, 12 Nov 2019 15:11:49 -0700
Subject: [PATCH 17/25] Drop a dead comment.

---
 src/client/common/platform/fileSystem.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/client/common/platform/fileSystem.ts b/src/client/common/platform/fileSystem.ts
index c7b6752cca2c..f852e9519295 100644
--- a/src/client/common/platform/fileSystem.ts
+++ b/src/client/common/platform/fileSystem.ts
@@ -133,13 +133,14 @@ export class TempFileSystem {
 }
 
 // This is the parts of the vscode.workspace.fs API that we use here.
+// See: https://code.visualstudio.com/api/references/vscode-api#FileSystem
+// Note that we have used all the API functions *except* "rename()".
 interface INewAPI {
     copy(source: vscode.Uri, target: vscode.Uri, options?: {overwrite: boolean}): Thenable<void>;
     createDirectory(uri: vscode.Uri): Thenable<void>;
     delete(uri: vscode.Uri, options?: {recursive: boolean; useTrash: boolean}): Thenable<void>;
     readDirectory(uri: vscode.Uri): Thenable<[string, FileType][]>;
     readFile(uri: vscode.Uri): Thenable<Uint8Array>;
-    //rename(source: vscode.Uri, target: vscode.Uri, options?: {overwrite: boolean}): Thenable<void>;
     stat(uri: vscode.Uri): Thenable<FileStat>;
     writeFile(uri: vscode.Uri, content: Uint8Array): Thenable<void>;
 }

From 06125c2f57d41bf0e22e888b7dc0043e3dd4f975 Mon Sep 17 00:00:00 2001
From: Eric Snow <ericsnowcurrently@gmail.com>
Date: Tue, 12 Nov 2019 15:15:41 -0700
Subject: [PATCH 18/25] newapi -> vscfs

---
 src/client/common/platform/fileSystem.ts | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/client/common/platform/fileSystem.ts b/src/client/common/platform/fileSystem.ts
index f852e9519295..2f2fadb32f15 100644
--- a/src/client/common/platform/fileSystem.ts
+++ b/src/client/common/platform/fileSystem.ts
@@ -135,7 +135,7 @@ export class TempFileSystem {
 // This is the parts of the vscode.workspace.fs API that we use here.
 // See: https://code.visualstudio.com/api/references/vscode-api#FileSystem
 // Note that we have used all the API functions *except* "rename()".
-interface INewAPI {
+interface IVSCodeFileSystemAPI {
     copy(source: vscode.Uri, target: vscode.Uri, options?: {overwrite: boolean}): Thenable<void>;
     createDirectory(uri: vscode.Uri): Thenable<void>;
     delete(uri: vscode.Uri, options?: {recursive: boolean; useTrash: boolean}): Thenable<void>;
@@ -172,7 +172,7 @@ interface IRawPath {
 export class RawFileSystem implements IRawFileSystem {
     constructor(
         protected readonly path: IRawPath,
-        protected readonly newapi: INewAPI,
+        protected readonly vscfs: IVSCodeFileSystemAPI,
         protected readonly nodefs: IRawFS,
         protected readonly fsExtra: IRawFSExtra
     ) { }
@@ -193,14 +193,14 @@ export class RawFileSystem implements IRawFileSystem {
     public async readText(filename: string): Promise<string> {
         const uri = vscode.Uri.file(filename);
         const data = Buffer.from(
-            await this.newapi.readFile(uri));
+            await this.vscfs.readFile(uri));
         return data.toString(ENCODING);
     }
 
     public async writeText(filename: string, text: string): Promise<void> {
         const uri = vscode.Uri.file(filename);
         const data = Buffer.from(text);
-        await this.newapi.writeFile(uri, data);
+        await this.vscfs.writeFile(uri, data);
     }
 
     public async rmtree(dirname: string): Promise<void> {
@@ -209,8 +209,8 @@ export class RawFileSystem implements IRawFileSystem {
         //   The docs say "throws - FileNotFound when uri doesn't exist".
         //   However, it happily does nothing (at least for remote-over-SSH).
         //   So we have to manually stat, just to be sure.
-        await this.newapi.stat(uri);
-        return this.newapi.delete(uri, {
+        await this.vscfs.stat(uri);
+        return this.vscfs.delete(uri, {
             recursive: true,
             useTrash: false
         });
@@ -218,7 +218,7 @@ export class RawFileSystem implements IRawFileSystem {
 
     public async rmfile(filename: string): Promise<void> {
         const uri = vscode.Uri.file(filename);
-        return this.newapi.delete(uri, {
+        return this.vscfs.delete(uri, {
             recursive: false,
             useTrash: false
         });
@@ -226,12 +226,12 @@ export class RawFileSystem implements IRawFileSystem {
 
     public async stat(filename: string): Promise<FileStat> {
         const uri = vscode.Uri.file(filename);
-        return this.newapi.stat(uri);
+        return this.vscfs.stat(uri);
     }
 
     public async listdir(dirname: string): Promise<[string, FileType][]> {
         const uri = vscode.Uri.file(dirname);
-        return this.newapi.readDirectory(uri);
+        return this.vscfs.readDirectory(uri);
     }
 
     public async mkdirp(dirname: string): Promise<void> {
@@ -243,7 +243,7 @@ export class RawFileSystem implements IRawFileSystem {
             const current = stack.pop() || '';
             const uri = vscode.Uri.file(current);
             try {
-                await this.newapi.createDirectory(uri);
+                await this.vscfs.createDirectory(uri);
             } catch (err) {
                 if (isFileExistsError(err)) {
                     // already done!
@@ -276,8 +276,8 @@ export class RawFileSystem implements IRawFileSystem {
         //   destination doesn't exist".  However, it happily creates
         //   the parent directory (at least for remote-over-SSH).
         //   So we have to manually stat, just to be sure.
-        await this.newapi.stat(vscode.Uri.file(this.path.dirname(dest)));
-        await this.newapi.copy(srcURI, destURI, {
+        await this.vscfs.stat(vscode.Uri.file(this.path.dirname(dest)));
+        await this.vscfs.copy(srcURI, destURI, {
             overwrite: true
         });
     }

From abac978e7d8dee13de580fb2cdd38481c1aaedf3 Mon Sep 17 00:00:00 2001
From: Eric Snow <ericsnowcurrently@gmail.com>
Date: Tue, 12 Nov 2019 15:25:08 -0700
Subject: [PATCH 19/25] Clarify about the "vscode" flag in IocContainer.

---
 src/test/datascience/dataScienceIocContainer.ts | 2 +-
 src/test/serviceRegistry.ts                     | 8 ++++++--
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/test/datascience/dataScienceIocContainer.ts b/src/test/datascience/dataScienceIocContainer.ts
index 9df188b5f8ad..ee93c8f30096 100644
--- a/src/test/datascience/dataScienceIocContainer.ts
+++ b/src/test/datascience/dataScienceIocContainer.ts
@@ -298,7 +298,7 @@ export class DataScienceIocContainer extends UnitTestIocContainer {
 
     constructor() {
         super();
-        this.vscode = false;
+        this.useVSCodeAPI = false;
         const isRollingBuild = process.env ? process.env.VSCODE_PYTHON_ROLLING !== undefined : false;
         this.shouldMockJupyter = !isRollingBuild;
         this.asyncRegistry = new AsyncDisposableRegistry();
diff --git a/src/test/serviceRegistry.ts b/src/test/serviceRegistry.ts
index 077ddf50913e..9ed6cc31a462 100644
--- a/src/test/serviceRegistry.ts
+++ b/src/test/serviceRegistry.ts
@@ -130,7 +130,11 @@ class LegacyFileSystem extends FileSystem {
 }
 
 export class IocContainer {
-    public vscode = true;
+    // This may be set (before any registration happens) to indicate
+    // whether or not IOC should depend on the VS Code API (e.g. the
+    // "vscode" module).  So in "functional" tests, this should be set
+    // to "false".
+    public useVSCodeAPI = true;
 
     public readonly serviceManager: IServiceManager;
     public readonly serviceContainer: IServiceContainer;
@@ -180,7 +184,7 @@ export class IocContainer {
         this.serviceManager.addSingleton<IPlatformService>(IPlatformService, PlatformService);
         this.serviceManager.addSingleton<IFileSystem>(
             IFileSystem,
-            this.vscode ? FileSystem : LegacyFileSystem
+            this.useVSCodeAPI ? FileSystem : LegacyFileSystem
         );
     }
     public registerProcessTypes() {

From 14aeeb501cdc7edd7b852703802103009a01782b Mon Sep 17 00:00:00 2001
From: Eric Snow <ericsnowcurrently@gmail.com>
Date: Tue, 12 Nov 2019 15:29:12 -0700
Subject: [PATCH 20/25] Simplify some test setup.

---
 .../common/platform/filesystem.unit.test.ts   | 30 ++++++++++---------
 1 file changed, 16 insertions(+), 14 deletions(-)

diff --git a/src/test/common/platform/filesystem.unit.test.ts b/src/test/common/platform/filesystem.unit.test.ts
index b40657244dd3..9f333ce058be 100644
--- a/src/test/common/platform/filesystem.unit.test.ts
+++ b/src/test/common/platform/filesystem.unit.test.ts
@@ -300,23 +300,25 @@ suite('Raw FileSystem', () => {
         if (stat.type === FileType.File) {
             old!.setup(s => s.isFile())
                 .returns(() => true);
+        } else if (stat.type === FileType.Directory) {
+            old!.setup(s => s.isFile())
+                .returns(() => false);
+            old!.setup(s => s.isDirectory())
+                .returns(() => true);
+        } else if (stat.type === FileType.SymbolicLink) {
+            old!.setup(s => s.isFile())
+                .returns(() => false);
+            old!.setup(s => s.isDirectory())
+                .returns(() => false);
+            old!.setup(s => s.isSymbolicLink())
+                .returns(() => true);
         } else {
             old!.setup(s => s.isFile())
                 .returns(() => false);
-            if (stat.type === FileType.Directory) {
-                old!.setup(s => s.isDirectory())
-                    .returns(() => true);
-            } else {
-                old!.setup(s => s.isDirectory())
-                    .returns(() => false);
-                if (stat.type === FileType.SymbolicLink) {
-                    old!.setup(s => s.isSymbolicLink())
-                        .returns(() => true);
-                } else {
-                    old!.setup(s => s.isSymbolicLink())
-                        .returns(() => false);
-                }
-            }
+            old!.setup(s => s.isDirectory())
+                .returns(() => false);
+            old!.setup(s => s.isSymbolicLink())
+                .returns(() => false);
         }
         old!.setup(s => s.size)
             .returns(() => stat.size);

From 81fe4d62c113cb34a7de62b05a6e8fab18190216 Mon Sep 17 00:00:00 2001
From: Eric Snow <ericsnowcurrently@gmail.com>
Date: Wed, 13 Nov 2019 17:00:29 -0700
Subject: [PATCH 21/25] lint

---
 src/test/common/platform/filesystem.test.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/test/common/platform/filesystem.test.ts b/src/test/common/platform/filesystem.test.ts
index 626d8e71d189..937b46ef515e 100644
--- a/src/test/common/platform/filesystem.test.ts
+++ b/src/test/common/platform/filesystem.test.ts
@@ -12,7 +12,7 @@ import {
     IFileSystemUtils, IRawFileSystem
 } from '../../../client/common/platform/types';
 import {
-    DOES_NOT_EXIST, assertDoesNotExist, assertExists, FSFixture, WINDOWS
+    assertDoesNotExist, assertExists, DOES_NOT_EXIST, FSFixture, WINDOWS
 } from './filesystem.functional.test';
 
 // Note: all functional tests that do not trigger the VS Code "fs" API

From 45da615e34d2bb468a42f803836a28ca53ba46d9 Mon Sep 17 00:00:00 2001
From: Eric Snow <ericsnowcurrently@gmail.com>
Date: Tue, 26 Nov 2019 10:18:40 -0700
Subject: [PATCH 22/25] Support passing args to withDefaults().

---
 src/client/common/platform/fileSystem.ts | 33 ++++++++++++++++--------
 1 file changed, 22 insertions(+), 11 deletions(-)

diff --git a/src/client/common/platform/fileSystem.ts b/src/client/common/platform/fileSystem.ts
index 2f2fadb32f15..d2d430c50ee6 100644
--- a/src/client/common/platform/fileSystem.ts
+++ b/src/client/common/platform/fileSystem.ts
@@ -178,12 +178,17 @@ export class RawFileSystem implements IRawFileSystem {
     ) { }
 
     // Create a new object using common-case default values.
-    public static withDefaults(): RawFileSystem{
+    public static withDefaults(
+        path?: IRawPath,
+        vscfs?: IVSCodeFileSystemAPI,
+        nodefs?: IRawFS,
+        fsExtra?: IRawFSExtra
+    ): RawFileSystem{
         return new RawFileSystem(
-            FileSystemPaths.withDefaults(),
-            vscode.workspace.fs,
-            fs,
-            fsextra
+            path || FileSystemPaths.withDefaults(),
+            vscfs || vscode.workspace.fs,
+            nodefs || fs,
+            fsExtra || fsextra
         );
     }
 
@@ -335,14 +340,20 @@ export class FileSystemUtils implements IFileSystemUtils {
         protected readonly globFile: (pat: string) => Promise<string[]>
     ) { }
     // Create a new object using common-case default values.
-    public static withDefaults(): FileSystemUtils {
-        const paths = FileSystemPaths.withDefaults();
+    public static withDefaults(
+        raw?: IRawFileSystem,
+        path?: IFileSystemPaths,
+        tmp?: ITempFileSystem,
+        getHash?: (data: string) => string,
+        globFile?: (pat: string) => Promise<string[]>
+    ): FileSystemUtils {
+        const paths = path || FileSystemPaths.withDefaults();
         return new FileSystemUtils(
-            new RawFileSystem(paths, vscode.workspace.fs, fs, fsextra),
+            raw || RawFileSystem.withDefaults(paths),
             paths,
-            TempFileSystem.withDefaults(),
-            getHashString,
-            util.promisify(glob)
+            tmp || TempFileSystem.withDefaults(),
+            getHash || getHashString,
+            globFile || util.promisify(glob)
         );
     }
 

From 81e7ae3d943c3869d4b2d943b92915f3f12e8890 Mon Sep 17 00:00:00 2001
From: Eric Snow <ericsnowcurrently@gmail.com>
Date: Tue, 26 Nov 2019 10:28:19 -0700
Subject: [PATCH 23/25] path -> paths

---
 src/client/common/platform/fileSystem.ts | 24 ++++++++++++------------
 src/client/common/platform/types.ts      |  2 +-
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/client/common/platform/fileSystem.ts b/src/client/common/platform/fileSystem.ts
index d2d430c50ee6..33545a46a3e9 100644
--- a/src/client/common/platform/fileSystem.ts
+++ b/src/client/common/platform/fileSystem.ts
@@ -171,7 +171,7 @@ interface IRawPath {
 // The low-level filesystem operations used by the extension.
 export class RawFileSystem implements IRawFileSystem {
     constructor(
-        protected readonly path: IRawPath,
+        protected readonly paths: IRawPath,
         protected readonly vscfs: IVSCodeFileSystemAPI,
         protected readonly nodefs: IRawFS,
         protected readonly fsExtra: IRawFSExtra
@@ -179,13 +179,13 @@ export class RawFileSystem implements IRawFileSystem {
 
     // Create a new object using common-case default values.
     public static withDefaults(
-        path?: IRawPath,
+        paths?: IRawPath,
         vscfs?: IVSCodeFileSystemAPI,
         nodefs?: IRawFS,
         fsExtra?: IRawFSExtra
     ): RawFileSystem{
         return new RawFileSystem(
-            path || FileSystemPaths.withDefaults(),
+            paths || FileSystemPaths.withDefaults(),
             vscfs || vscode.workspace.fs,
             nodefs || fs,
             fsExtra || fsextra
@@ -262,7 +262,7 @@ export class RawFileSystem implements IRawFileSystem {
                     throw err; // re-throw
                 }
                 // Try creating the parent first.
-                const parent = this.path.dirname(current);
+                const parent = this.paths.dirname(current);
                 if (parent === '' || parent === current) {
                     // This shouldn't ever happen.
                     throw err;
@@ -281,7 +281,7 @@ export class RawFileSystem implements IRawFileSystem {
         //   destination doesn't exist".  However, it happily creates
         //   the parent directory (at least for remote-over-SSH).
         //   So we have to manually stat, just to be sure.
-        await this.vscfs.stat(vscode.Uri.file(this.path.dirname(dest)));
+        await this.vscfs.stat(vscode.Uri.file(this.paths.dirname(dest)));
         await this.vscfs.copy(srcURI, destURI, {
             overwrite: true
         });
@@ -334,7 +334,7 @@ export class RawFileSystem implements IRawFileSystem {
 export class FileSystemUtils implements IFileSystemUtils {
     constructor(
         public readonly raw: IRawFileSystem,
-        public readonly path: IFileSystemPaths,
+        public readonly paths: IFileSystemPaths,
         public readonly tmp: ITempFileSystem,
         protected readonly getHash: (data: string) => string,
         protected readonly globFile: (pat: string) => Promise<string[]>
@@ -342,12 +342,12 @@ export class FileSystemUtils implements IFileSystemUtils {
     // Create a new object using common-case default values.
     public static withDefaults(
         raw?: IRawFileSystem,
-        path?: IFileSystemPaths,
+        paths?: IFileSystemPaths,
         tmp?: ITempFileSystem,
         getHash?: (data: string) => string,
         globFile?: (pat: string) => Promise<string[]>
     ): FileSystemUtils {
-        const paths = path || FileSystemPaths.withDefaults();
+        paths = paths || FileSystemPaths.withDefaults();
         return new FileSystemUtils(
             raw || RawFileSystem.withDefaults(paths),
             paths,
@@ -379,8 +379,8 @@ export class FileSystemUtils implements IFileSystemUtils {
         if (path1 === path2) {
             return true;
         }
-        path1 = this.path.normCase(path1);
-        path2 = this.path.normCase(path2);
+        path1 = this.paths.normCase(path1);
+        path2 = this.paths.normCase(path2);
         return path1 === path2;
     }
 
@@ -417,12 +417,12 @@ export class FileSystemUtils implements IFileSystemUtils {
     public async getSubDirectories(dirname: string): Promise<string[]> {
         return (await this.listdir(dirname))
             .filter(([_name, fileType]) => fileType === FileType.Directory)
-            .map(([name, _fileType]) => this.path.join(dirname, name));
+            .map(([name, _fileType]) => this.paths.join(dirname, name));
     }
     public async getFiles(dirname: string): Promise<string[]> {
         return (await this.listdir(dirname))
             .filter(([_name, fileType]) => fileType === FileType.File)
-            .map(([name, _fileType]) => this.path.join(dirname, name));
+            .map(([name, _fileType]) => this.paths.join(dirname, name));
     }
 
     public async isDirReadonly(dirname: string): Promise<boolean> {
diff --git a/src/client/common/platform/types.ts b/src/client/common/platform/types.ts
index 91b15b5a7d86..880f87b90175 100644
--- a/src/client/common/platform/types.ts
+++ b/src/client/common/platform/types.ts
@@ -104,7 +104,7 @@ export interface IRawFileSystem {
 export const IFileSystemUtils = Symbol('IFileSystemUtils');
 export interface IFileSystemUtils {
     readonly raw: IRawFileSystem;
-    readonly path: IFileSystemPaths;
+    readonly paths: IFileSystemPaths;
     readonly tmp: ITempFileSystem;
 
     //***********************

From faa1c662eee63eb7dec1329434a0183d55ccd9e7 Mon Sep 17 00:00:00 2001
From: Eric Snow <ericsnowcurrently@gmail.com>
Date: Tue, 26 Nov 2019 10:37:55 -0700
Subject: [PATCH 24/25] fs -> fs-extra.

---
 src/client/common/platform/fileSystem.ts         | 16 ++--------------
 src/test/common/platform/filesystem.unit.test.ts |  9 +--------
 2 files changed, 3 insertions(+), 22 deletions(-)

diff --git a/src/client/common/platform/fileSystem.ts b/src/client/common/platform/fileSystem.ts
index 33545a46a3e9..8fddce2e32e7 100644
--- a/src/client/common/platform/fileSystem.ts
+++ b/src/client/common/platform/fileSystem.ts
@@ -4,7 +4,6 @@
 'use strict';
 
 import { createHash } from 'crypto';
-import * as fs from 'fs';
 import * as fsextra from 'fs-extra';
 import * as glob from 'glob';
 import { injectable } from 'inversify';
@@ -145,12 +144,6 @@ interface IVSCodeFileSystemAPI {
     writeFile(uri: vscode.Uri, content: Uint8Array): Thenable<void>;
 }
 
-// This is the parts of node's 'fs' module that we use in RawFileSystem.
-interface IRawFS {
-    // non-async
-    createWriteStream(filePath: string): fs.WriteStream;
-}
-
 // This is the parts of the 'fs-extra' module that we use in RawFileSystem.
 interface IRawFSExtra {
     chmod(filePath: string, mode: string | number): Promise<void>;
@@ -159,6 +152,7 @@ interface IRawFSExtra {
     // non-async
     statSync(filename: string): fsextra.Stats;
     readFileSync(path: string, encoding: string): string;
+    createWriteStream(filePath: string): fsextra.WriteStream;
 }
 
 interface IRawPath {
@@ -173,7 +167,6 @@ export class RawFileSystem implements IRawFileSystem {
     constructor(
         protected readonly paths: IRawPath,
         protected readonly vscfs: IVSCodeFileSystemAPI,
-        protected readonly nodefs: IRawFS,
         protected readonly fsExtra: IRawFSExtra
     ) { }
 
@@ -181,13 +174,11 @@ export class RawFileSystem implements IRawFileSystem {
     public static withDefaults(
         paths?: IRawPath,
         vscfs?: IVSCodeFileSystemAPI,
-        nodefs?: IRawFS,
         fsExtra?: IRawFSExtra
     ): RawFileSystem{
         return new RawFileSystem(
             paths || FileSystemPaths.withDefaults(),
             vscfs || vscode.workspace.fs,
-            nodefs || fs,
             fsExtra || fsextra
         );
     }
@@ -319,13 +310,10 @@ export class RawFileSystem implements IRawFileSystem {
         return this.fsExtra.readFileSync(filename, ENCODING);
     }
 
-    //****************************
-    // non-async (fs)
-
     public createWriteStream(filename: string): WriteStream {
         // TODO https://github.com/microsoft/vscode/issues/84175
         //   This functionality has been requested for the VS Code API.
-        return this.nodefs.createWriteStream(filename);
+        return this.fsExtra.createWriteStream(filename);
     }
 }
 
diff --git a/src/test/common/platform/filesystem.unit.test.ts b/src/test/common/platform/filesystem.unit.test.ts
index 9f333ce058be..bedecb2d74c3 100644
--- a/src/test/common/platform/filesystem.unit.test.ts
+++ b/src/test/common/platform/filesystem.unit.test.ts
@@ -51,18 +51,12 @@ interface IRawFS {
     stat(uri: Uri): Thenable<FileStat>;
     writeFile(uri: Uri, content: Uint8Array): Thenable<void>;
 
-    // node "fs"
-    //tslint:disable-next-line:no-any
-    open(filename: string, flags: number, callback: any): void;
-    //tslint:disable-next-line:no-any
-    close(fd: number, callback: any): void;
-    createWriteStream(dest: string): fs.WriteStream;
-
     // "fs-extra"
     chmod(filePath: string, mode: string): Promise<void>;
     lstat(filename: string): Promise<fsextra.Stats>;
     statSync(filename: string): fsextra.Stats;
     readFileSync(path: string, encoding: string): string;
+    createWriteStream(dest: string): fs.WriteStream;
 
     // fs paths (IFileSystemPaths)
     join(...filenames: string[]): string;
@@ -279,7 +273,6 @@ suite('Raw FileSystem', () => {
         raw = TypeMoq.Mock.ofType<IRawFS>(undefined, TypeMoq.MockBehavior.Strict);
         oldStat = createMockLegacyStat();
         filesystem = new RawFileSystem(
-            raw.object,
             raw.object,
             raw.object,
             raw.object

From d9e54d2859b57c056dbbe5aa20256b999ccc61c1 Mon Sep 17 00:00:00 2001
From: Eric Snow <ericsnowcurrently@gmail.com>
Date: Tue, 26 Nov 2019 10:39:36 -0700
Subject: [PATCH 25/25] Fix LegacyFileSystem.

---
 src/client/common/platform/fileSystem.ts |  2 +-
 src/test/serviceRegistry.ts              | 68 ++++++++++++++----------
 2 files changed, 42 insertions(+), 28 deletions(-)

diff --git a/src/client/common/platform/fileSystem.ts b/src/client/common/platform/fileSystem.ts
index 8fddce2e32e7..24f26a1f13d5 100644
--- a/src/client/common/platform/fileSystem.ts
+++ b/src/client/common/platform/fileSystem.ts
@@ -453,7 +453,7 @@ function getHashString(data: string): string {
 // more aliases (to cause less churn)
 @injectable()
 export class FileSystem implements IFileSystem {
-    protected readonly utils: FileSystemUtils;
+    protected utils: FileSystemUtils;
     constructor() {
         this.utils = FileSystemUtils.withDefaults();
     }
diff --git a/src/test/serviceRegistry.ts b/src/test/serviceRegistry.ts
index 9ed6cc31a462..91ab8a5ef8d8 100644
--- a/src/test/serviceRegistry.ts
+++ b/src/test/serviceRegistry.ts
@@ -10,7 +10,9 @@ import { Disposable, Memento, OutputChannel } from 'vscode';
 import { STANDARD_OUTPUT_CHANNEL } from '../client/common/constants';
 import { Logger } from '../client/common/logger';
 import { IS_WINDOWS } from '../client/common/platform/constants';
-import { FileSystem } from '../client/common/platform/fileSystem';
+import {
+    FileSystem, FileSystemPaths, FileSystemUtils, RawFileSystem
+} from '../client/common/platform/fileSystem';
 import { PathUtils } from '../client/common/platform/pathUtils';
 import { PlatformService } from '../client/common/platform/platformService';
 import { RegistryImplementation } from '../client/common/platform/registry';
@@ -64,35 +66,51 @@ import { MockProcess } from './mocks/process';
 // This is necessary for unit tests and functional tests, since they
 // do not run under VS Code so they do not have access to the actual
 // "vscode" namespace.
-class LegacyFileSystem extends FileSystem {
-    public async readFile(filename: string): Promise<string> {
+class LegacyRawFileSystem extends RawFileSystem {
+    public async readText(filename: string): Promise<string> {
         return fsextra.readFile(filename, 'utf8');
     }
-    public async writeFile(filename: string, data: {}): Promise<void> {
-        const options: fsextra.WriteFileOptions = {
+    public async writeText(filename: string, text: string): Promise<void> {
+        return fsextra.writeFile(filename, text, {
             encoding: 'utf8'
-        };
-        return fsextra.writeFile(filename, data, options);
+        });
     }
-    public async deleteDirectory(dirname: string): Promise<void> {
+    public async rmtree(dirname: string): Promise<void> {
         return fsextra.stat(dirname)
             .then(() => fsextra.remove(dirname));
     }
-    public async deleteFile(filename: string): Promise<void> {
+    public async rmfile(filename: string): Promise<void> {
         return fsextra.unlink(filename);
     }
+    public async stat(filename: string): Promise<FileStat> {
+        const stat = await fsextra.stat(filename);
+        let fileType = FileType.Unknown;
+        if (stat.isFile()) {
+            fileType = FileType.File;
+        } else if (stat.isDirectory()) {
+            fileType = FileType.Directory;
+        } else if (stat.isSymbolicLink()) {
+            fileType = FileType.SymbolicLink;
+        }
+        return {
+            type: fileType,
+            size: stat.size,
+            ctime: stat.ctimeMs,
+            mtime: stat.mtimeMs
+        };
+    }
     public async listdir(dirname: string): Promise<[string, FileType][]> {
         const names: string[] = await fsextra.readdir(dirname);
         const promises = names
             .map(name => {
                  const filename = path.join(dirname, name);
-                 return this.utils.raw.lstat(filename)
+                 return this.lstat(filename)
                      .then(stat => [name, stat.type] as [string, FileType])
                      .catch(() => [name, FileType.Unknown] as [string, FileType]);
             });
         return Promise.all(promises);
     }
-    public async createDirectory(dirname: string): Promise<void> {
+    public async mkdirp(dirname: string): Promise<void> {
         return fsextra.mkdirp(dirname);
     }
     public async copyFile(src: string, dest: string): Promise<void> {
@@ -110,22 +128,18 @@ class LegacyFileSystem extends FileSystem {
         rs.pipe(ws);
         return deferred.promise;
     }
-    protected async _stat(filePath: string): Promise<FileStat> {
-        const stat = await fsextra.stat(filePath);
-        let fileType = FileType.Unknown;
-        if (stat.isFile()) {
-            fileType = FileType.File;
-        } else if (stat.isDirectory()) {
-            fileType = FileType.Directory;
-        } else if (stat.isSymbolicLink()) {
-            fileType = FileType.SymbolicLink;
-        }
-        return {
-            type: fileType,
-            size: stat.size,
-            ctime: stat.ctimeMs,
-            mtime: stat.mtimeMs
-        };
+}
+class LegacyFileSystem extends FileSystem {
+    constructor() {
+        super();
+        const paths = FileSystemPaths.withDefaults();
+        const raw = new LegacyRawFileSystem(
+            paths,
+            // tslint:disable-next-line:no-any
+            undefined as any,
+            fsextra
+        );
+        this.utils = FileSystemUtils.withDefaults(raw, paths);
     }
 }