https://github.com/Microsoft/TypeScript
Tip revision: 32210356e7ef145d01d82a0f2042262e804cc8a3 authored by TypeScript Bot on 17 June 2021, 00:00:02 UTC
Bump version to 4.3.4 and LKG
Bump version to 4.3.4 and LKG
Tip revision: 3221035
vfsUtil.ts
namespace vfs {
/**
* Posix-style path to the TypeScript compiler build outputs (including tsc.js, lib.d.ts, etc.)
*/
export const builtFolder = "/.ts";
/**
* Posix-style path to additional mountable folders (./tests/projects in this repo)
*/
export const projectsFolder = "/.projects";
/**
* Posix-style path to additional test libraries
*/
export const testLibFolder = "/.lib";
/**
* Posix-style path to sources under test
*/
export const srcFolder = "/.src";
// file type
const S_IFMT = 0o170000; // file type
const S_IFSOCK = 0o140000; // socket
const S_IFLNK = 0o120000; // symbolic link
const S_IFREG = 0o100000; // regular file
const S_IFBLK = 0o060000; // block device
const S_IFDIR = 0o040000; // directory
const S_IFCHR = 0o020000; // character device
const S_IFIFO = 0o010000; // FIFO
let devCount = 0; // A monotonically increasing count of device ids
let inoCount = 0; // A monotonically increasing count of inodes
export interface DiffOptions {
includeChangedFileWithSameContent?: boolean;
baseIsNotShadowRoot?: boolean;
}
/**
* Represents a virtual POSIX-like file system.
*/
export class FileSystem {
/** Indicates whether the file system is case-sensitive (`false`) or case-insensitive (`true`). */
public readonly ignoreCase: boolean;
/** Gets the comparison function used to compare two paths. */
public readonly stringComparer: (a: string, b: string) => number;
// lazy-initialized state that should be mutable even if the FileSystem is frozen.
private _lazy: {
links?: collections.SortedMap<string, Inode>;
shadows?: Map<number, Inode>;
meta?: collections.Metadata;
} = {};
private _cwd: string; // current working directory
private _time: number | Date | (() => number | Date);
private _shadowRoot: FileSystem | undefined;
private _dirStack: string[] | undefined;
constructor(ignoreCase: boolean, options: FileSystemOptions = {}) {
const { time = -1, files, meta } = options;
this.ignoreCase = ignoreCase;
this.stringComparer = this.ignoreCase ? vpath.compareCaseInsensitive : vpath.compareCaseSensitive;
this._time = time;
if (meta) {
for (const key of Object.keys(meta)) {
this.meta.set(key, meta[key]);
}
}
if (files) {
this._applyFiles(files, /*dirname*/ "");
}
let cwd = options.cwd;
if ((!cwd || !vpath.isRoot(cwd)) && this._lazy.links) {
const iterator = collections.getIterator(this._lazy.links.keys());
try {
for (let i = collections.nextResult(iterator); i; i = collections.nextResult(iterator)) {
const name = i.value;
cwd = cwd ? vpath.resolve(name, cwd) : name;
break;
}
}
finally {
collections.closeIterator(iterator);
}
}
if (cwd) {
vpath.validate(cwd, vpath.ValidationFlags.Absolute);
this.mkdirpSync(cwd);
}
this._cwd = cwd || "";
}
/**
* Gets metadata for this `FileSystem`.
*/
public get meta(): collections.Metadata {
if (!this._lazy.meta) {
this._lazy.meta = new collections.Metadata(this._shadowRoot ? this._shadowRoot.meta : undefined);
}
return this._lazy.meta;
}
/**
* Gets a value indicating whether the file system is read-only.
*/
public get isReadonly() {
return Object.isFrozen(this);
}
/**
* Makes the file system read-only.
*/
public makeReadonly() {
Object.freeze(this);
return this;
}
/**
* Gets the file system shadowed by this file system.
*/
public get shadowRoot() {
return this._shadowRoot;
}
/**
* Snapshots the current file system, effectively shadowing itself. This is useful for
* generating file system patches using `.diff()` from one snapshot to the next. Performs
* no action if this file system is read-only.
*/
public snapshot() {
if (this.isReadonly) return;
const fs = new FileSystem(this.ignoreCase, { time: this._time });
fs._lazy = this._lazy;
fs._cwd = this._cwd;
fs._time = this._time;
fs._shadowRoot = this._shadowRoot;
fs._dirStack = this._dirStack;
fs.makeReadonly();
this._lazy = {};
this._shadowRoot = fs;
}
/**
* Gets a shadow copy of this file system. Changes to the shadow copy do not affect the
* original, allowing multiple copies of the same core file system without multiple copies
* of the same data.
*/
public shadow(ignoreCase = this.ignoreCase) {
if (!this.isReadonly) throw new Error("Cannot shadow a mutable file system.");
if (ignoreCase && !this.ignoreCase) throw new Error("Cannot create a case-insensitive file system from a case-sensitive one.");
const fs = new FileSystem(ignoreCase, { time: this._time });
fs._shadowRoot = this;
fs._cwd = this._cwd;
return fs;
}
/**
* Gets or sets the timestamp (in milliseconds) used for file status, returning the previous timestamp.
*
* @link http://pubs.opengroup.org/onlinepubs/9699919799/functions/time.html
*/
public time(value?: number | Date | (() => number | Date)): number {
if (value !== undefined && this.isReadonly) throw createIOError("EPERM");
let result = this._time;
if (typeof result === "function") result = result();
if (typeof result === "object") result = result.getTime();
if (result === -1) result = Date.now();
if (value !== undefined) {
this._time = value;
}
return result;
}
/**
* Gets the metadata object for a path.
* @param path
*/
public filemeta(path: string): collections.Metadata {
const { node } = this._walk(this._resolve(path));
if (!node) throw createIOError("ENOENT");
return this._filemeta(node);
}
private _filemeta(node: Inode): collections.Metadata {
if (!node.meta) {
const parentMeta = node.shadowRoot && this._shadowRoot && this._shadowRoot._filemeta(node.shadowRoot);
node.meta = new collections.Metadata(parentMeta);
}
return node.meta;
}
/**
* Get the pathname of the current working directory.
*
* @link - http://pubs.opengroup.org/onlinepubs/9699919799/functions/getcwd.html
*/
public cwd() {
if (!this._cwd) throw new Error("The current working directory has not been set.");
const { node } = this._walk(this._cwd);
if (!node) throw createIOError("ENOENT");
if (!isDirectory(node)) throw createIOError("ENOTDIR");
return this._cwd;
}
/**
* Changes the current working directory.
*
* @link http://pubs.opengroup.org/onlinepubs/9699919799/functions/chdir.html
*/
public chdir(path: string) {
if (this.isReadonly) throw createIOError("EPERM");
path = this._resolve(path);
const { node } = this._walk(path);
if (!node) throw createIOError("ENOENT");
if (!isDirectory(node)) throw createIOError("ENOTDIR");
this._cwd = path;
}
/**
* Pushes the current directory onto the directory stack and changes the current working directory to the supplied path.
*/
public pushd(path?: string) {
if (this.isReadonly) throw createIOError("EPERM");
if (path) path = this._resolve(path);
if (this._cwd) {
if (!this._dirStack) this._dirStack = [];
this._dirStack.push(this._cwd);
}
if (path && path !== this._cwd) {
this.chdir(path);
}
}
/**
* Pops the previous directory from the location stack and changes the current directory to that directory.
*/
public popd() {
if (this.isReadonly) throw createIOError("EPERM");
const path = this._dirStack && this._dirStack.pop();
if (path) {
this.chdir(path);
}
}
/**
* Update the file system with a set of files.
*/
public apply(files: FileSet) {
this._applyFiles(files, this._cwd);
}
/**
* Scan file system entries along a path. If `path` is a symbolic link, it is dereferenced.
* @param path The path at which to start the scan.
* @param axis The axis along which to traverse.
* @param traversal The traversal scheme to use.
*/
public scanSync(path: string, axis: Axis, traversal: Traversal) {
path = this._resolve(path);
const results: string[] = [];
this._scan(path, this._stat(this._walk(path)), axis, traversal, /*noFollow*/ false, results);
return results;
}
/**
* Scan file system entries along a path.
* @param path The path at which to start the scan.
* @param axis The axis along which to traverse.
* @param traversal The traversal scheme to use.
*/
public lscanSync(path: string, axis: Axis, traversal: Traversal) {
path = this._resolve(path);
const results: string[] = [];
this._scan(path, this._stat(this._walk(path, /*noFollow*/ true)), axis, traversal, /*noFollow*/ true, results);
return results;
}
private _scan(path: string, stats: Stats, axis: Axis, traversal: Traversal, noFollow: boolean, results: string[]) {
if (axis === "ancestors-or-self" || axis === "self" || axis === "descendants-or-self") {
if (!traversal.accept || traversal.accept(path, stats)) {
results.push(path);
}
}
if (axis === "ancestors-or-self" || axis === "ancestors") {
const dirname = vpath.dirname(path);
if (dirname !== path) {
try {
const stats = this._stat(this._walk(dirname, noFollow));
if (!traversal.traverse || traversal.traverse(dirname, stats)) {
this._scan(dirname, stats, "ancestors-or-self", traversal, noFollow, results);
}
}
catch { /*ignored*/ }
}
}
if (axis === "descendants-or-self" || axis === "descendants") {
if (stats.isDirectory() && (!traversal.traverse || traversal.traverse(path, stats))) {
for (const file of this.readdirSync(path)) {
try {
const childpath = vpath.combine(path, file);
const stats = this._stat(this._walk(childpath, noFollow));
this._scan(childpath, stats, "descendants-or-self", traversal, noFollow, results);
}
catch { /*ignored*/ }
}
}
}
}
/**
* Mounts a physical or virtual file system at a location in this virtual file system.
*
* @param source The path in the physical (or other virtual) file system.
* @param target The path in this virtual file system.
* @param resolver An object used to resolve files in `source`.
*/
public mountSync(source: string, target: string, resolver: FileSystemResolver) {
if (this.isReadonly) throw createIOError("EROFS");
source = vpath.validate(source, vpath.ValidationFlags.Absolute);
const { parent, links, node: existingNode, basename } = this._walk(this._resolve(target), /*noFollow*/ true);
if (existingNode) throw createIOError("EEXIST");
const time = this.time();
const node = this._mknod(parent ? parent.dev : ++devCount, S_IFDIR, /*mode*/ 0o777, time);
node.source = source;
node.resolver = resolver;
this._addLink(parent, links, basename, node, time);
}
/**
* Recursively remove all files and directories underneath the provided path.
*/
public rimrafSync(path: string) {
try {
const stats = this.lstatSync(path);
if (stats.isFile() || stats.isSymbolicLink()) {
this.unlinkSync(path);
}
else if (stats.isDirectory()) {
for (const file of this.readdirSync(path)) {
this.rimrafSync(vpath.combine(path, file));
}
this.rmdirSync(path);
}
}
catch (e) {
if (e.code === "ENOENT") return;
throw e;
}
}
/**
* Make a directory and all of its parent paths (if they don't exist).
*/
public mkdirpSync(path: string) {
path = this._resolve(path);
const result = this._walk(path, /*noFollow*/ true, (error, result) => {
if (error.code === "ENOENT") {
this._mkdir(result);
return "retry";
}
return "throw";
});
if (!result.node) this._mkdir(result);
}
public getFileListing(): string {
let result = "";
const printLinks = (dirname: string | undefined, links: collections.SortedMap<string, Inode>) => {
const iterator = collections.getIterator(links);
try {
for (let i = collections.nextResult(iterator); i; i = collections.nextResult(iterator)) {
const [name, node] = i.value;
const path = dirname ? vpath.combine(dirname, name) : name;
const marker = vpath.compare(this._cwd, path, this.ignoreCase) === 0 ? "*" : " ";
if (result) result += "\n";
result += marker;
if (isDirectory(node)) {
result += vpath.addTrailingSeparator(path);
printLinks(path, this._getLinks(node));
}
else if (isFile(node)) {
result += path;
}
else if (isSymlink(node)) {
result += path + " -> " + node.symlink;
}
}
}
finally {
collections.closeIterator(iterator);
}
};
printLinks(/*dirname*/ undefined, this._getRootLinks());
return result;
}
/**
* Print diagnostic information about the structure of the file system to the console.
*/
public debugPrint(): void {
console.log(this.getFileListing());
}
// POSIX API (aligns with NodeJS "fs" module API)
/**
* Determines whether a path exists.
*/
public existsSync(path: string) {
const result = this._walk(this._resolve(path), /*noFollow*/ true, () => "stop");
return result !== undefined && result.node !== undefined;
}
/**
* Get file status. If `path` is a symbolic link, it is dereferenced.
*
* @link http://pubs.opengroup.org/onlinepubs/9699919799/functions/stat.html
*
* NOTE: do not rename this method as it is intended to align with the same named export of the "fs" module.
*/
public statSync(path: string) {
return this._stat(this._walk(this._resolve(path)));
}
/**
* Change file access times
*
* NOTE: do not rename this method as it is intended to align with the same named export of the "fs" module.
*/
public utimesSync(path: string, atime: Date, mtime: Date) {
if (this.isReadonly) throw createIOError("EROFS");
if (!isFinite(+atime) || !isFinite(+mtime)) throw createIOError("EINVAL");
const entry = this._walk(this._resolve(path));
if (!entry || !entry.node) {
throw createIOError("ENOENT");
}
entry.node.atimeMs = +atime;
entry.node.mtimeMs = +mtime;
entry.node.ctimeMs = this.time();
}
/**
* Get file status. If `path` is a symbolic link, it is dereferenced.
*
* @link http://pubs.opengroup.org/onlinepubs/9699919799/functions/lstat.html
*
* NOTE: do not rename this method as it is intended to align with the same named export of the "fs" module.
*/
public lstatSync(path: string) {
return this._stat(this._walk(this._resolve(path), /*noFollow*/ true));
}
private _stat(entry: WalkResult) {
const node = entry.node;
if (!node) throw createIOError(`ENOENT`, entry.realpath);
return new Stats(
node.dev,
node.ino,
node.mode,
node.nlink,
/*rdev*/ 0,
/*size*/ isFile(node) ? this._getSize(node) : isSymlink(node) ? node.symlink.length : 0,
/*blksize*/ 4096,
/*blocks*/ 0,
node.atimeMs,
node.mtimeMs,
node.ctimeMs,
node.birthtimeMs,
);
}
/**
* Read a directory. If `path` is a symbolic link, it is dereferenced.
*
* @link http://pubs.opengroup.org/onlinepubs/9699919799/functions/readdir.html
*
* NOTE: do not rename this method as it is intended to align with the same named export of the "fs" module.
*/
public readdirSync(path: string) {
const { node } = this._walk(this._resolve(path));
if (!node) throw createIOError("ENOENT");
if (!isDirectory(node)) throw createIOError("ENOTDIR");
return Array.from(this._getLinks(node).keys());
}
/**
* Make a directory.
*
* @link http://pubs.opengroup.org/onlinepubs/9699919799/functions/mkdir.html
*
* NOTE: do not rename this method as it is intended to align with the same named export of the "fs" module.
*/
public mkdirSync(path: string) {
if (this.isReadonly) throw createIOError("EROFS");
this._mkdir(this._walk(this._resolve(path), /*noFollow*/ true));
}
private _mkdir({ parent, links, node: existingNode, basename }: WalkResult) {
if (existingNode) throw createIOError("EEXIST");
const time = this.time();
const node = this._mknod(parent ? parent.dev : ++devCount, S_IFDIR, /*mode*/ 0o777, time);
this._addLink(parent, links, basename, node, time);
}
/**
* Remove a directory.
*
* @link http://pubs.opengroup.org/onlinepubs/9699919799/functions/rmdir.html
*
* NOTE: do not rename this method as it is intended to align with the same named export of the "fs" module.
*/
public rmdirSync(path: string) {
if (this.isReadonly) throw createIOError("EROFS");
path = this._resolve(path);
const { parent, links, node, basename } = this._walk(path, /*noFollow*/ true);
if (!parent) throw createIOError("EPERM");
if (!isDirectory(node)) throw createIOError("ENOTDIR");
if (this._getLinks(node).size !== 0) throw createIOError("ENOTEMPTY");
this._removeLink(parent, links, basename, node);
}
/**
* Link one file to another file (also known as a "hard link").
*
* @link http://pubs.opengroup.org/onlinepubs/9699919799/functions/link.html
*
* NOTE: do not rename this method as it is intended to align with the same named export of the "fs" module.
*/
public linkSync(oldpath: string, newpath: string) {
if (this.isReadonly) throw createIOError("EROFS");
const { node } = this._walk(this._resolve(oldpath));
if (!node) throw createIOError("ENOENT");
if (isDirectory(node)) throw createIOError("EPERM");
const { parent, links, basename, node: existingNode } = this._walk(this._resolve(newpath), /*noFollow*/ true);
if (!parent) throw createIOError("EPERM");
if (existingNode) throw createIOError("EEXIST");
this._addLink(parent, links, basename, node);
}
/**
* Remove a directory entry.
*
* @link http://pubs.opengroup.org/onlinepubs/9699919799/functions/unlink.html
*
* NOTE: do not rename this method as it is intended to align with the same named export of the "fs" module.
*/
public unlinkSync(path: string) {
if (this.isReadonly) throw createIOError("EROFS");
const { parent, links, node, basename } = this._walk(this._resolve(path), /*noFollow*/ true);
if (!parent) throw createIOError("EPERM");
if (!node) throw createIOError("ENOENT");
if (isDirectory(node)) throw createIOError("EISDIR");
this._removeLink(parent, links, basename, node);
}
/**
* Rename a file.
*
* @link http://pubs.opengroup.org/onlinepubs/9699919799/functions/rename.html
*
* NOTE: do not rename this method as it is intended to align with the same named export of the "fs" module.
*/
public renameSync(oldpath: string, newpath: string) {
if (this.isReadonly) throw createIOError("EROFS");
const { parent: oldParent, links: oldParentLinks, node, basename: oldBasename } = this._walk(this._resolve(oldpath), /*noFollow*/ true);
if (!oldParent) throw createIOError("EPERM");
if (!node) throw createIOError("ENOENT");
const { parent: newParent, links: newParentLinks, node: existingNode, basename: newBasename } = this._walk(this._resolve(newpath), /*noFollow*/ true);
if (!newParent) throw createIOError("EPERM");
const time = this.time();
if (existingNode) {
if (isDirectory(node)) {
if (!isDirectory(existingNode)) throw createIOError("ENOTDIR");
// if both old and new arguments point to the same directory, just pass. So we could rename /src/a/1 to /src/A/1 in Win.
// if not and the directory pointed by the new path is not empty, throw an error.
if (this.stringComparer(oldpath, newpath) !== 0 && this._getLinks(existingNode).size > 0) throw createIOError("ENOTEMPTY");
}
else {
if (isDirectory(existingNode)) throw createIOError("EISDIR");
}
this._removeLink(newParent, newParentLinks, newBasename, existingNode, time);
}
this._replaceLink(oldParent, oldParentLinks, oldBasename, newParent, newParentLinks, newBasename, node, time);
}
/**
* Make a symbolic link.
*
* @link http://pubs.opengroup.org/onlinepubs/9699919799/functions/symlink.html
*
* NOTE: do not rename this method as it is intended to align with the same named export of the "fs" module.
*/
public symlinkSync(target: string, linkpath: string) {
if (this.isReadonly) throw createIOError("EROFS");
const { parent, links, node: existingNode, basename } = this._walk(this._resolve(linkpath), /*noFollow*/ true);
if (!parent) throw createIOError("EPERM");
if (existingNode) throw createIOError("EEXIST");
const time = this.time();
const node = this._mknod(parent.dev, S_IFLNK, /*mode*/ 0o666, time);
node.symlink = vpath.validate(target, vpath.ValidationFlags.RelativeOrAbsolute);
this._addLink(parent, links, basename, node, time);
}
/**
* Resolve a pathname.
*
* @link http://pubs.opengroup.org/onlinepubs/9699919799/functions/realpath.html
*
* NOTE: do not rename this method as it is intended to align with the same named export of the "fs" module.
*/
public realpathSync(path: string) {
const { realpath } = this._walk(this._resolve(path));
return realpath;
}
/**
* Read from a file.
*
* NOTE: do not rename this method as it is intended to align with the same named export of the "fs" module.
*/
public readFileSync(path: string, encoding?: null): Buffer;
/**
* Read from a file.
*
* NOTE: do not rename this method as it is intended to align with the same named export of the "fs" module.
*/
public readFileSync(path: string, encoding: BufferEncoding): string;
/**
* Read from a file.
*
* NOTE: do not rename this method as it is intended to align with the same named export of the "fs" module.
*/
public readFileSync(path: string, encoding?: BufferEncoding | null): string | Buffer;
public readFileSync(path: string, encoding: BufferEncoding | null = null) { // eslint-disable-line no-null/no-null
const { node } = this._walk(this._resolve(path));
if (!node) throw createIOError("ENOENT");
if (isDirectory(node)) throw createIOError("EISDIR");
if (!isFile(node)) throw createIOError("EBADF");
const buffer = this._getBuffer(node).slice();
return encoding ? buffer.toString(encoding) : buffer;
}
/**
* Write to a file.
*
* NOTE: do not rename this method as it is intended to align with the same named export of the "fs" module.
*/
// eslint-disable-next-line no-null/no-null
public writeFileSync(path: string, data: string | Buffer, encoding: string | null = null) {
if (this.isReadonly) throw createIOError("EROFS");
const { parent, links, node: existingNode, basename } = this._walk(this._resolve(path), /*noFollow*/ false);
if (!parent) throw createIOError("EPERM");
const time = this.time();
let node = existingNode;
if (!node) {
node = this._mknod(parent.dev, S_IFREG, 0o666, time);
this._addLink(parent, links, basename, node, time);
}
if (isDirectory(node)) throw createIOError("EISDIR");
if (!isFile(node)) throw createIOError("EBADF");
node.buffer = Buffer.isBuffer(data) ? data.slice() : ts.sys.bufferFrom!("" + data, encoding || "utf8") as Buffer;
node.size = node.buffer.byteLength;
node.mtimeMs = time;
node.ctimeMs = time;
}
/**
* Generates a `FileSet` patch containing all the entries in this `FileSystem` that are not in `base`.
* @param base The base file system. If not provided, this file system's `shadowRoot` is used (if present).
*/
public diff(base?: FileSystem | undefined, options: DiffOptions = {}) {
if (!base && !options.baseIsNotShadowRoot) base = this.shadowRoot;
const differences: FileSet = {};
const hasDifferences = base ?
FileSystem.rootDiff(differences, this, base, options) :
FileSystem.trackCreatedInodes(differences, this, this._getRootLinks());
return hasDifferences ? differences : undefined;
}
/**
* Generates a `FileSet` patch containing all the entries in `changed` that are not in `base`.
*/
public static diff(changed: FileSystem, base: FileSystem, options: DiffOptions = {}) {
const differences: FileSet = {};
return FileSystem.rootDiff(differences, changed, base, options) ?
differences :
undefined;
}
private static diffWorker(container: FileSet, changed: FileSystem, changedLinks: ReadonlyMap<string, Inode> | undefined, base: FileSystem, baseLinks: ReadonlyMap<string, Inode> | undefined, options: DiffOptions) {
if (changedLinks && !baseLinks) return FileSystem.trackCreatedInodes(container, changed, changedLinks);
if (baseLinks && !changedLinks) return FileSystem.trackDeletedInodes(container, baseLinks);
if (changedLinks && baseLinks) {
let hasChanges = false;
// track base items missing in changed
baseLinks.forEach((node, basename) => {
if (!changedLinks.has(basename)) {
container[basename] = isDirectory(node) ? new Rmdir() : new Unlink();
hasChanges = true;
}
});
// track changed items missing or differing in base
changedLinks.forEach((changedNode, basename) => {
const baseNode = baseLinks.get(basename);
if (baseNode) {
if (isDirectory(changedNode) && isDirectory(baseNode)) {
return hasChanges = FileSystem.directoryDiff(container, basename, changed, changedNode, base, baseNode, options) || hasChanges;
}
if (isFile(changedNode) && isFile(baseNode)) {
return hasChanges = FileSystem.fileDiff(container, basename, changed, changedNode, base, baseNode, options) || hasChanges;
}
if (isSymlink(changedNode) && isSymlink(baseNode)) {
return hasChanges = FileSystem.symlinkDiff(container, basename, changedNode, baseNode) || hasChanges;
}
}
return hasChanges = FileSystem.trackCreatedInode(container, basename, changed, changedNode) || hasChanges;
});
return hasChanges;
}
return false;
}
private static rootDiff(container: FileSet, changed: FileSystem, base: FileSystem, options: DiffOptions) {
while (!changed._lazy.links && changed._shadowRoot) changed = changed._shadowRoot;
while (!base._lazy.links && base._shadowRoot) base = base._shadowRoot;
// no difference if the file systems are the same reference
if (changed === base) return false;
// no difference if the root links are empty and unshadowed
if (!changed._lazy.links && !changed._shadowRoot && !base._lazy.links && !base._shadowRoot) return false;
return FileSystem.diffWorker(container, changed, changed._getRootLinks(), base, base._getRootLinks(), options);
}
private static directoryDiff(container: FileSet, basename: string, changed: FileSystem, changedNode: DirectoryInode, base: FileSystem, baseNode: DirectoryInode, options: DiffOptions) {
while (!changedNode.links && changedNode.shadowRoot) changedNode = changedNode.shadowRoot;
while (!baseNode.links && baseNode.shadowRoot) baseNode = baseNode.shadowRoot;
// no difference if the nodes are the same reference
if (changedNode === baseNode) return false;
// no difference if both nodes are non shadowed and have no entries
if (isEmptyNonShadowedDirectory(changedNode) && isEmptyNonShadowedDirectory(baseNode)) return false;
// no difference if both nodes are unpopulated and point to the same mounted file system
if (!changedNode.links && !baseNode.links &&
changedNode.resolver && changedNode.source !== undefined &&
baseNode.resolver === changedNode.resolver && baseNode.source === changedNode.source) return false;
// no difference if both nodes have identical children
const children: FileSet = {};
if (!FileSystem.diffWorker(children, changed, changed._getLinks(changedNode), base, base._getLinks(baseNode), options)) {
return false;
}
container[basename] = new Directory(children);
return true;
}
private static fileDiff(container: FileSet, basename: string, changed: FileSystem, changedNode: FileInode, base: FileSystem, baseNode: FileInode, options: DiffOptions) {
while (!changedNode.buffer && changedNode.shadowRoot) changedNode = changedNode.shadowRoot;
while (!baseNode.buffer && baseNode.shadowRoot) baseNode = baseNode.shadowRoot;
// no difference if the nodes are the same reference
if (changedNode === baseNode) return false;
// no difference if both nodes are non shadowed and have no entries
if (isEmptyNonShadowedFile(changedNode) && isEmptyNonShadowedFile(baseNode)) return false;
// no difference if both nodes are unpopulated and point to the same mounted file system
if (!changedNode.buffer && !baseNode.buffer &&
changedNode.resolver && changedNode.source !== undefined &&
baseNode.resolver === changedNode.resolver && baseNode.source === changedNode.source) return false;
const changedBuffer = changed._getBuffer(changedNode);
const baseBuffer = base._getBuffer(baseNode);
// no difference if both buffers are the same reference
if (changedBuffer === baseBuffer) return false;
// no difference if both buffers are identical
if (Buffer.compare(changedBuffer, baseBuffer) === 0) {
if (!options.includeChangedFileWithSameContent) return false;
container[basename] = new SameFileContentFile(changedBuffer);
return true;
}
container[basename] = new File(changedBuffer);
return true;
}
private static symlinkDiff(container: FileSet, basename: string, changedNode: SymlinkInode, baseNode: SymlinkInode) {
// no difference if the nodes are the same reference
if (changedNode.symlink === baseNode.symlink) return false;
container[basename] = new Symlink(changedNode.symlink);
return true;
}
private static trackCreatedInode(container: FileSet, basename: string, changed: FileSystem, node: Inode) {
if (isDirectory(node)) {
const children: FileSet = {};
FileSystem.trackCreatedInodes(children, changed, changed._getLinks(node));
container[basename] = new Directory(children);
}
else if (isSymlink(node)) {
container[basename] = new Symlink(node.symlink);
}
else {
container[basename] = new File(node.buffer || "");
}
return true;
}
private static trackCreatedInodes(container: FileSet, changed: FileSystem, changedLinks: ReadonlyMap<string, Inode>) {
// no difference if links are empty
if (!changedLinks.size) return false;
changedLinks.forEach((node, basename) => { FileSystem.trackCreatedInode(container, basename, changed, node); });
return true;
}
private static trackDeletedInodes(container: FileSet, baseLinks: ReadonlyMap<string, Inode>) {
// no difference if links are empty
if (!baseLinks.size) return false;
baseLinks.forEach((node, basename) => { container[basename] = isDirectory(node) ? new Rmdir() : new Unlink(); });
return true;
}
private _mknod(dev: number, type: typeof S_IFREG, mode: number, time?: number): FileInode;
private _mknod(dev: number, type: typeof S_IFDIR, mode: number, time?: number): DirectoryInode;
private _mknod(dev: number, type: typeof S_IFLNK, mode: number, time?: number): SymlinkInode;
private _mknod(dev: number, type: number, mode: number, time = this.time()) {
return <Inode>{
dev,
ino: ++inoCount,
mode: (mode & ~S_IFMT & ~0o022 & 0o7777) | (type & S_IFMT),
atimeMs: time,
mtimeMs: time,
ctimeMs: time,
birthtimeMs: time,
nlink: 0
};
}
private _addLink(parent: DirectoryInode | undefined, links: collections.SortedMap<string, Inode>, name: string, node: Inode, time = this.time()) {
links.set(name, node);
node.nlink++;
node.ctimeMs = time;
if (parent) parent.mtimeMs = time;
if (!parent && !this._cwd) this._cwd = name;
}
private _removeLink(parent: DirectoryInode | undefined, links: collections.SortedMap<string, Inode>, name: string, node: Inode, time = this.time()) {
links.delete(name);
node.nlink--;
node.ctimeMs = time;
if (parent) parent.mtimeMs = time;
}
private _replaceLink(oldParent: DirectoryInode, oldLinks: collections.SortedMap<string, Inode>, oldName: string, newParent: DirectoryInode, newLinks: collections.SortedMap<string, Inode>, newName: string, node: Inode, time: number) {
if (oldParent !== newParent) {
this._removeLink(oldParent, oldLinks, oldName, node, time);
this._addLink(newParent, newLinks, newName, node, time);
}
else {
oldLinks.delete(oldName);
oldLinks.set(newName, node);
oldParent.mtimeMs = time;
newParent.mtimeMs = time;
}
}
private _getRootLinks() {
if (!this._lazy.links) {
this._lazy.links = new collections.SortedMap<string, Inode>(this.stringComparer);
if (this._shadowRoot) {
this._copyShadowLinks(this._shadowRoot._getRootLinks(), this._lazy.links);
}
this._lazy.links = this._lazy.links;
}
return this._lazy.links;
}
private _getLinks(node: DirectoryInode) {
if (!node.links) {
const links = new collections.SortedMap<string, Inode>(this.stringComparer);
const { source, resolver } = node;
if (source && resolver) {
node.source = undefined;
node.resolver = undefined;
for (const name of resolver.readdirSync(source)) {
const path = vpath.combine(source, name);
const stats = resolver.statSync(path);
switch (stats.mode & S_IFMT) {
case S_IFDIR:
const dir = this._mknod(node.dev, S_IFDIR, 0o777);
dir.source = vpath.combine(source, name);
dir.resolver = resolver;
this._addLink(node, links, name, dir);
break;
case S_IFREG:
const file = this._mknod(node.dev, S_IFREG, 0o666);
file.source = vpath.combine(source, name);
file.resolver = resolver;
file.size = stats.size;
this._addLink(node, links, name, file);
break;
}
}
}
else if (this._shadowRoot && node.shadowRoot) {
this._copyShadowLinks(this._shadowRoot._getLinks(node.shadowRoot), links);
}
node.links = links;
}
return node.links;
}
private _getShadow(root: DirectoryInode): DirectoryInode;
private _getShadow(root: Inode): Inode;
private _getShadow(root: Inode) {
const shadows = this._lazy.shadows || (this._lazy.shadows = new Map<number, Inode>());
let shadow = shadows.get(root.ino);
if (!shadow) {
shadow = <Inode>{
dev: root.dev,
ino: root.ino,
mode: root.mode,
atimeMs: root.atimeMs,
mtimeMs: root.mtimeMs,
ctimeMs: root.ctimeMs,
birthtimeMs: root.birthtimeMs,
nlink: root.nlink,
shadowRoot: root
};
if (isSymlink(root)) (<SymlinkInode>shadow).symlink = root.symlink;
shadows.set(shadow.ino, shadow);
}
return shadow;
}
private _copyShadowLinks(source: ReadonlyMap<string, Inode>, target: collections.SortedMap<string, Inode>) {
const iterator = collections.getIterator(source);
try {
for (let i = collections.nextResult(iterator); i; i = collections.nextResult(iterator)) {
const [name, root] = i.value;
target.set(name, this._getShadow(root));
}
}
finally {
collections.closeIterator(iterator);
}
}
private _getSize(node: FileInode): number {
if (node.buffer) return node.buffer.byteLength;
if (node.size !== undefined) return node.size;
if (node.source && node.resolver) return node.size = node.resolver.statSync(node.source).size;
if (this._shadowRoot && node.shadowRoot) return node.size = this._shadowRoot._getSize(node.shadowRoot);
return 0;
}
private _getBuffer(node: FileInode): Buffer {
if (!node.buffer) {
const { source, resolver } = node;
if (source && resolver) {
node.source = undefined;
node.resolver = undefined;
node.size = undefined;
node.buffer = resolver.readFileSync(source);
}
else if (this._shadowRoot && node.shadowRoot) {
node.buffer = this._shadowRoot._getBuffer(node.shadowRoot);
}
else {
node.buffer = Buffer.allocUnsafe(0);
}
}
return node.buffer;
}
/**
* Walk a path to its end.
*
* @param path The path to follow.
* @param noFollow A value indicating whether to *not* dereference a symbolic link at the
* end of a path.
*
* @link http://man7.org/linux/man-pages/man7/path_resolution.7.html
*/
private _walk(path: string, noFollow?: boolean, onError?: (error: NodeJS.ErrnoException, fragment: WalkResult) => "retry" | "throw"): WalkResult;
private _walk(path: string, noFollow?: boolean, onError?: (error: NodeJS.ErrnoException, fragment: WalkResult) => "stop" | "retry" | "throw"): WalkResult | undefined;
private _walk(path: string, noFollow?: boolean, onError?: (error: NodeJS.ErrnoException, fragment: WalkResult) => "stop" | "retry" | "throw"): WalkResult | undefined {
let links = this._getRootLinks();
let parent: DirectoryInode | undefined;
let components = vpath.parse(path);
let step = 0;
let depth = 0;
let retry = false;
while (true) {
if (depth >= 40) throw createIOError("ELOOP");
const lastStep = step === components.length - 1;
let basename = components[step];
const linkEntry = links.getEntry(basename);
if (linkEntry) {
components[step] = basename = linkEntry[0];
}
const node = linkEntry?.[1];
if (lastStep && (noFollow || !isSymlink(node))) {
return { realpath: vpath.format(components), basename, parent, links, node };
}
if (node === undefined) {
if (trapError(createIOError("ENOENT"), node)) continue;
return undefined;
}
if (isSymlink(node)) {
const dirname = vpath.format(components.slice(0, step));
const symlink = vpath.resolve(dirname, node.symlink);
links = this._getRootLinks();
parent = undefined;
components = vpath.parse(symlink).concat(components.slice(step + 1));
step = 0;
depth++;
retry = false;
continue;
}
if (isDirectory(node)) {
links = this._getLinks(node);
parent = node;
step++;
retry = false;
continue;
}
if (trapError(createIOError("ENOTDIR"), node)) continue;
return undefined;
}
function trapError(error: NodeJS.ErrnoException, node?: Inode) {
const realpath = vpath.format(components.slice(0, step + 1));
const basename = components[step];
const result = !retry && onError ? onError(error, { realpath, basename, parent, links, node }) : "throw";
if (result === "stop") return false;
if (result === "retry") {
retry = true;
return true;
}
throw error;
}
}
/**
* Resolve a path relative to the current working directory.
*/
private _resolve(path: string) {
return this._cwd
? vpath.resolve(this._cwd, vpath.validate(path, vpath.ValidationFlags.RelativeOrAbsolute | vpath.ValidationFlags.AllowWildcard))
: vpath.validate(path, vpath.ValidationFlags.Absolute | vpath.ValidationFlags.AllowWildcard);
}
private _applyFiles(files: FileSet, dirname: string) {
const deferred: [Symlink | Link | Mount, string][] = [];
this._applyFilesWorker(files, dirname, deferred);
for (const [entry, path] of deferred) {
this.mkdirpSync(vpath.dirname(path));
this.pushd(vpath.dirname(path));
if (entry instanceof Symlink) {
if (this.stringComparer(vpath.dirname(path), path) === 0) {
throw new TypeError("Roots cannot be symbolic links.");
}
this.symlinkSync(vpath.resolve(dirname, entry.symlink), path);
this._applyFileExtendedOptions(path, entry);
}
else if (entry instanceof Link) {
if (this.stringComparer(vpath.dirname(path), path) === 0) {
throw new TypeError("Roots cannot be hard links.");
}
this.linkSync(entry.path, path);
}
else {
this.mountSync(entry.source, path, entry.resolver);
this._applyFileExtendedOptions(path, entry);
}
this.popd();
}
}
private _applyFileExtendedOptions(path: string, entry: Directory | File | Symlink | Mount) {
const { meta } = entry;
if (meta !== undefined) {
const filemeta = this.filemeta(path);
for (const key of Object.keys(meta)) {
filemeta.set(key, meta[key]);
}
}
}
private _applyFilesWorker(files: FileSet, dirname: string, deferred: [Symlink | Link | Mount, string][]) {
for (const key of Object.keys(files)) {
const value = normalizeFileSetEntry(files[key]);
const path = dirname ? vpath.resolve(dirname, key) : key;
vpath.validate(path, vpath.ValidationFlags.Absolute);
// eslint-disable-next-line no-null/no-null
if (value === null || value === undefined || value instanceof Rmdir || value instanceof Unlink) {
if (this.stringComparer(vpath.dirname(path), path) === 0) {
throw new TypeError("Roots cannot be deleted.");
}
this.rimrafSync(path);
}
else if (value instanceof File) {
if (this.stringComparer(vpath.dirname(path), path) === 0) {
throw new TypeError("Roots cannot be files.");
}
this.mkdirpSync(vpath.dirname(path));
this.writeFileSync(path, value.data, value.encoding);
this._applyFileExtendedOptions(path, value);
}
else if (value instanceof Directory) {
this.mkdirpSync(path);
this._applyFileExtendedOptions(path, value);
this._applyFilesWorker(value.files, path, deferred);
}
else {
deferred.push([value, path]);
}
}
}
}
export interface FileSystemOptions {
// Sets the initial timestamp for new files and directories, or the function used
// to calculate timestamps.
time?: number | Date | (() => number | Date);
// A set of file system entries to initially add to the file system.
files?: FileSet;
// Sets the initial working directory for the file system.
cwd?: string;
// Sets initial metadata attached to the file system.
meta?: Record<string, any>;
}
export interface FileSystemCreateOptions extends FileSystemOptions {
// Sets the documents to add to the file system.
documents?: readonly documents.TextDocument[];
}
export type Axis = "ancestors" | "ancestors-or-self" | "self" | "descendants-or-self" | "descendants";
export interface Traversal {
/** A function called to choose whether to continue to traverse to either ancestors or descendants. */
traverse?(path: string, stats: Stats): boolean;
/** A function called to choose whether to accept a path as part of the result. */
accept?(path: string, stats: Stats): boolean;
}
export interface FileSystemResolver {
statSync(path: string): { mode: number; size: number; };
readdirSync(path: string): string[];
readFileSync(path: string): Buffer;
}
export interface FileSystemResolverHost {
useCaseSensitiveFileNames(): boolean;
getAccessibleFileSystemEntries(path: string): ts.FileSystemEntries;
directoryExists(path: string): boolean;
fileExists(path: string): boolean;
getFileSize(path: string): number;
readFile(path: string): string | undefined;
getWorkspaceRoot(): string;
}
export function createResolver(host: FileSystemResolverHost): FileSystemResolver {
return {
readdirSync(path: string): string[] {
const { files, directories } = host.getAccessibleFileSystemEntries(path);
return directories.concat(files);
},
statSync(path: string): { mode: number; size: number; } {
if (host.directoryExists(path)) {
return { mode: S_IFDIR | 0o777, size: 0 };
}
else if (host.fileExists(path)) {
return { mode: S_IFREG | 0o666, size: host.getFileSize(path) };
}
else {
throw new Error("ENOENT: path does not exist");
}
},
readFileSync(path: string): Buffer {
return ts.sys.bufferFrom!(host.readFile(path)!, "utf8") as Buffer; // TODO: GH#18217
}
};
}
/**
* Create a virtual file system from a physical file system using the following path mappings:
*
* - `/.ts` is a directory mapped to `${workspaceRoot}/built/local`
* - `/.lib` is a directory mapped to `${workspaceRoot}/tests/lib`
* - `/.src` is a virtual directory to be used for tests.
*
* Unless overridden, `/.src` will be the current working directory for the virtual file system.
*/
export function createFromFileSystem(host: FileSystemResolverHost, ignoreCase: boolean, { documents, files, cwd, time, meta }: FileSystemCreateOptions = {}) {
const fs = getBuiltLocal(host, ignoreCase).shadow();
if (meta) {
for (const key of Object.keys(meta)) {
fs.meta.set(key, meta[key]);
}
}
if (time) {
fs.time(time);
}
if (cwd) {
fs.mkdirpSync(cwd);
fs.chdir(cwd);
}
if (documents) {
for (const document of documents) {
fs.mkdirpSync(vpath.dirname(document.file));
fs.writeFileSync(document.file, document.text, "utf8");
fs.filemeta(document.file).set("document", document);
// Add symlinks
const symlink = document.meta.get("symlink");
if (symlink) {
for (const link of symlink.split(",").map(link => link.trim())) {
fs.mkdirpSync(vpath.dirname(link));
fs.symlinkSync(vpath.resolve(fs.cwd(), document.file), link);
}
}
}
}
if (files) {
fs.apply(files);
}
return fs;
}
export class Stats {
public dev: number;
public ino: number;
public mode: number;
public nlink: number;
public uid: number;
public gid: number;
public rdev: number;
public size: number;
public blksize: number;
public blocks: number;
public atimeMs: number;
public mtimeMs: number;
public ctimeMs: number;
public birthtimeMs: number;
public atime: Date;
public mtime: Date;
public ctime: Date;
public birthtime: Date;
constructor();
constructor(dev: number, ino: number, mode: number, nlink: number, rdev: number, size: number, blksize: number, blocks: number, atimeMs: number, mtimeMs: number, ctimeMs: number, birthtimeMs: number);
constructor(dev = 0, ino = 0, mode = 0, nlink = 0, rdev = 0, size = 0, blksize = 0, blocks = 0, atimeMs = 0, mtimeMs = 0, ctimeMs = 0, birthtimeMs = 0) {
this.dev = dev;
this.ino = ino;
this.mode = mode;
this.nlink = nlink;
this.uid = 0;
this.gid = 0;
this.rdev = rdev;
this.size = size;
this.blksize = blksize;
this.blocks = blocks;
this.atimeMs = atimeMs;
this.mtimeMs = mtimeMs;
this.ctimeMs = ctimeMs;
this.birthtimeMs = birthtimeMs;
this.atime = new Date(this.atimeMs);
this.mtime = new Date(this.mtimeMs);
this.ctime = new Date(this.ctimeMs);
this.birthtime = new Date(this.birthtimeMs);
}
public isFile() { return (this.mode & S_IFMT) === S_IFREG; }
public isDirectory() { return (this.mode & S_IFMT) === S_IFDIR; }
public isSymbolicLink() { return (this.mode & S_IFMT) === S_IFLNK; }
public isBlockDevice() { return (this.mode & S_IFMT) === S_IFBLK; }
public isCharacterDevice() { return (this.mode & S_IFMT) === S_IFCHR; }
public isFIFO() { return (this.mode & S_IFMT) === S_IFIFO; }
public isSocket() { return (this.mode & S_IFMT) === S_IFSOCK; }
}
export const IOErrorMessages = Object.freeze({
EACCES: "access denied",
EIO: "an I/O error occurred",
ENOENT: "no such file or directory",
EEXIST: "file already exists",
ELOOP: "too many symbolic links encountered",
ENOTDIR: "no such directory",
EISDIR: "path is a directory",
EBADF: "invalid file descriptor",
EINVAL: "invalid value",
ENOTEMPTY: "directory not empty",
EPERM: "operation not permitted",
EROFS: "file system is read-only"
});
export function createIOError(code: keyof typeof IOErrorMessages, details = "") {
const err: NodeJS.ErrnoException = new Error(`${code}: ${IOErrorMessages[code]} ${details}`);
err.code = code;
if (Error.captureStackTrace) Error.captureStackTrace(err, createIOError);
return err;
}
/**
* A template used to populate files, directories, links, etc. in a virtual file system.
*/
export interface FileSet {
[name: string]: DirectoryLike | FileLike | Link | Symlink | Mount | Rmdir | Unlink | null | undefined;
}
export type DirectoryLike = FileSet | Directory;
export type FileLike = File | Buffer | string;
/** Extended options for a directory in a `FileSet` */
export class Directory {
public readonly files: FileSet;
public readonly meta: Record<string, any> | undefined;
constructor(files: FileSet, { meta }: { meta?: Record<string, any> } = {}) {
this.files = files;
this.meta = meta;
}
}
/** Extended options for a file in a `FileSet` */
export class File {
public readonly data: Buffer | string;
public readonly encoding: string | undefined;
public readonly meta: Record<string, any> | undefined;
constructor(data: Buffer | string, { meta, encoding }: { encoding?: string, meta?: Record<string, any> } = {}) {
this.data = data;
this.encoding = encoding;
this.meta = meta;
}
}
export class SameFileContentFile extends File {
constructor(data: Buffer | string, metaAndEncoding?: { encoding?: string, meta?: Record<string, any> }) {
super(data, metaAndEncoding);
}
}
/** Extended options for a hard link in a `FileSet` */
export class Link {
public readonly path: string;
constructor(path: string) {
this.path = path;
}
}
/** Removes a directory in a `FileSet` */
export class Rmdir {
public _rmdirBrand?: never; // brand necessary for proper type guards
}
/** Unlinks a file in a `FileSet` */
export class Unlink {
public _unlinkBrand?: never; // brand necessary for proper type guards
}
/** Extended options for a symbolic link in a `FileSet` */
export class Symlink {
public readonly symlink: string;
public readonly meta: Record<string, any> | undefined;
constructor(symlink: string, { meta }: { meta?: Record<string, any> } = {}) {
this.symlink = symlink;
this.meta = meta;
}
}
/** Extended options for mounting a virtual copy of an external file system via a `FileSet` */
export class Mount {
public readonly source: string;
public readonly resolver: FileSystemResolver;
public readonly meta: Record<string, any> | undefined;
constructor(source: string, resolver: FileSystemResolver, { meta }: { meta?: Record<string, any> } = {}) {
this.source = source;
this.resolver = resolver;
this.meta = meta;
}
}
// a generic POSIX inode
type Inode = FileInode | DirectoryInode | SymlinkInode;
interface FileInode {
dev: number; // device id
ino: number; // inode id
mode: number; // file mode
atimeMs: number; // access time
mtimeMs: number; // modified time
ctimeMs: number; // status change time
birthtimeMs: number; // creation time
nlink: number; // number of hard links
size?: number;
buffer?: Buffer;
source?: string;
resolver?: FileSystemResolver;
shadowRoot?: FileInode;
meta?: collections.Metadata;
}
interface DirectoryInode {
dev: number; // device id
ino: number; // inode id
mode: number; // file mode
atimeMs: number; // access time
mtimeMs: number; // modified time
ctimeMs: number; // status change time
birthtimeMs: number; // creation time
nlink: number; // number of hard links
links?: collections.SortedMap<string, Inode>;
source?: string;
resolver?: FileSystemResolver;
shadowRoot?: DirectoryInode;
meta?: collections.Metadata;
}
interface SymlinkInode {
dev: number; // device id
ino: number; // inode id
mode: number; // file mode
atimeMs: number; // access time
mtimeMs: number; // modified time
ctimeMs: number; // status change time
birthtimeMs: number; // creation time
nlink: number; // number of hard links
symlink: string;
shadowRoot?: SymlinkInode;
meta?: collections.Metadata;
}
function isEmptyNonShadowedDirectory(node: DirectoryInode) {
return !node.links && !node.shadowRoot && !node.resolver && !node.source;
}
function isEmptyNonShadowedFile(node: FileInode) {
return !node.buffer && !node.shadowRoot && !node.resolver && !node.source;
}
function isFile(node: Inode | undefined): node is FileInode {
return node !== undefined && (node.mode & S_IFMT) === S_IFREG;
}
function isDirectory(node: Inode | undefined): node is DirectoryInode {
return node !== undefined && (node.mode & S_IFMT) === S_IFDIR;
}
function isSymlink(node: Inode | undefined): node is SymlinkInode {
return node !== undefined && (node.mode & S_IFMT) === S_IFLNK;
}
interface WalkResult {
realpath: string;
basename: string;
parent: DirectoryInode | undefined;
links: collections.SortedMap<string, Inode>;
node: Inode | undefined;
}
let builtLocalHost: FileSystemResolverHost | undefined;
let builtLocalCI: FileSystem | undefined;
let builtLocalCS: FileSystem | undefined;
function getBuiltLocal(host: FileSystemResolverHost, ignoreCase: boolean): FileSystem {
if (builtLocalHost !== host) {
builtLocalCI = undefined;
builtLocalCS = undefined;
builtLocalHost = host;
}
if (!builtLocalCI) {
const resolver = createResolver(host);
builtLocalCI = new FileSystem(/*ignoreCase*/ true, {
files: {
[builtFolder]: new Mount(vpath.resolve(host.getWorkspaceRoot(), "built/local"), resolver),
[testLibFolder]: new Mount(vpath.resolve(host.getWorkspaceRoot(), "tests/lib"), resolver),
[projectsFolder]: new Mount(vpath.resolve(host.getWorkspaceRoot(), "tests/projects"), resolver),
[srcFolder]: {}
},
cwd: srcFolder,
meta: { defaultLibLocation: builtFolder }
});
builtLocalCI.makeReadonly();
}
if (ignoreCase) return builtLocalCI;
if (!builtLocalCS) {
builtLocalCS = builtLocalCI.shadow(/*ignoreCase*/ false);
builtLocalCS.makeReadonly();
}
return builtLocalCS;
}
/* eslint-disable no-null/no-null */
function normalizeFileSetEntry(value: FileSet[string]) {
if (value === undefined ||
value === null ||
value instanceof Directory ||
value instanceof File ||
value instanceof Link ||
value instanceof Symlink ||
value instanceof Mount ||
value instanceof Rmdir ||
value instanceof Unlink) {
return value;
}
return typeof value === "string" || Buffer.isBuffer(value) ? new File(value) : new Directory(value);
}
export function formatPatch(patch: FileSet): string;
export function formatPatch(patch: FileSet | undefined): string | null;
export function formatPatch(patch: FileSet | undefined) {
return patch ? formatPatchWorker("", patch) : null;
}
/* eslint-enable no-null/no-null */
function formatPatchWorker(dirname: string, container: FileSet): string {
let text = "";
for (const name of Object.keys(container)) {
const entry = normalizeFileSetEntry(container[name]);
const file = dirname ? vpath.combine(dirname, name) : name;
// eslint-disable-next-line no-null/no-null
if (entry === null || entry === undefined || entry instanceof Unlink || entry instanceof Rmdir) {
text += `//// [${file}] unlink\r\n`;
}
else if (entry instanceof Rmdir) {
text += `//// [${vpath.addTrailingSeparator(file)}] rmdir\r\n`;
}
else if (entry instanceof Directory) {
text += formatPatchWorker(file, entry.files);
}
else if (entry instanceof SameFileContentFile) {
text += `//// [${file}] file written with same contents\r\n`;
}
else if (entry instanceof File) {
const content = typeof entry.data === "string" ? entry.data : entry.data.toString("utf8");
text += `//// [${file}]\r\n${content}\r\n\r\n`;
}
else if (entry instanceof Link) {
text += `//// [${file}] link(${entry.path})\r\n`;
}
else if (entry instanceof Symlink) {
text += `//// [${file}] symlink(${entry.symlink})\r\n`;
}
else if (entry instanceof Mount) {
text += `//// [${file}] mount(${entry.source})\r\n`;
}
}
return text;
}
export function iteratePatch(patch: FileSet | undefined): IterableIterator<[string, string]> | null {
// eslint-disable-next-line no-null/no-null
return patch ? Harness.Compiler.iterateOutputs(iteratePatchWorker("", patch)) : null;
}
function* iteratePatchWorker(dirname: string, container: FileSet): IterableIterator<documents.TextDocument> {
for (const name of Object.keys(container)) {
const entry = normalizeFileSetEntry(container[name]);
const file = dirname ? vpath.combine(dirname, name) : name;
if (entry instanceof Directory) {
yield* ts.arrayFrom(iteratePatchWorker(file, entry.files));
}
else if (entry instanceof File) {
const content = typeof entry.data === "string" ? entry.data : entry.data.toString("utf8");
yield new documents.TextDocument(file, content);
}
}
}
}
