tsc-ts 0.0.3 → 0.0.5

package/dist/api/compiler/file-system.d.ts

@@ -0,0 +1,51 @@
+/** The files and directories directly inside a directory, sorted by name. */
+export declare class DirectoryEntries {
+    readonly files: readonly string[];
+    readonly directories: readonly string[];
+    /** Entries reached through a symlink; `undefined` if the file system doesn't track symlinks. */
+    readonly symlinks: ReadonlySet<string> | undefined;
+    constructor(files: readonly string[], directories: readonly string[], 
+    /** Entries reached through a symlink; `undefined` if the file system doesn't track symlinks. */
+    symlinks: ReadonlySet<string> | undefined);
+}
+export declare const emptyDirectoryEntries: DirectoryEntries;
+/** File system access. Paths are absolute and use `/`. */
+export declare abstract class FileSystem {
+    readonly useCaseSensitiveFileNames: boolean;
+    constructor(useCaseSensitiveFileNames: boolean);
+    abstract fileExists(path: string): boolean;
+    abstract directoryExists(path: string): boolean;
+    /** Returns `undefined` if the file can't be read. */
+    abstract readFile(path: string): string | undefined;
+    /** Entries of a readable directory; empty if it can't be read. */
+    abstract getAccessibleEntries(path: string): DirectoryEntries;
+    /** The path with symlinks resolved, or `path` itself if it does not exist. */
+    abstract realpath(path: string): string;
+    /**
+     * Called before the file system is shared with other threads, which makes it immutable
+     * (parallel-check.ts): a file system that caches keeps caching on each thread from then on.
+     */
+    prepareForSharing(): void;
+}
+/**
+ * Caches every query of another file system; for a single compilation, where files don't change.
+ * Once shared with other threads (`prepareForSharing`), what was cached until then is read by every
+ * thread, and each thread caches new answers in tables of its own.
+ */
+export declare class CachedFileSystem extends FileSystem {
+    private readonly inner;
+    private readonly caches;
+    private shared;
+    constructor(inner: FileSystem);
+    prepareForSharing(): void;
+    /** Where new answers go: this file system's caches, or once it is shared, this thread's. */
+    private ownCaches;
+    fileExists(path: string): boolean;
+    directoryExists(path: string): boolean;
+    readFile(path: string): string | undefined;
+    getAccessibleEntries(path: string): DirectoryEntries;
+    realpath(path: string): string;
+    /** Whether `fileExists` was called for `path`. */
+    lookedUpFile(path: string): boolean;
+    private key;
+}

package/dist/api/compiler/file-system.js

@@ -0,0 +1,132 @@
+/**
+ * The file system the compiler reads, and a caching layer over it.
+ */
+import { getCanonicalFileName } from './path.js';
+/** The files and directories directly inside a directory, sorted by name. */
+export class DirectoryEntries {
+    files;
+    directories;
+    symlinks;
+    constructor(files, directories, 
+    /** Entries reached through a symlink; `undefined` if the file system doesn't track symlinks. */
+    symlinks) {
+        this.files = files;
+        this.directories = directories;
+        this.symlinks = symlinks;
+    }
+}
+export const emptyDirectoryEntries = new DirectoryEntries([], [], undefined);
+/** File system access. Paths are absolute and use `/`. */
+export class FileSystem {
+    useCaseSensitiveFileNames;
+    constructor(useCaseSensitiveFileNames) {
+        this.useCaseSensitiveFileNames = useCaseSensitiveFileNames;
+    }
+    /**
+     * Called before the file system is shared with other threads, which makes it immutable
+     * (parallel-check.ts): a file system that caches keeps caching on each thread from then on.
+     */
+    prepareForSharing() { }
+}
+/** The answers a CachedFileSystem keeps. */
+class FileSystemCaches {
+    files = new Map();
+    directories = new Map();
+    entries = new Map();
+    realpaths = new Map();
+}
+// What each file system shared with other threads (and so immutable) did not know yet when it was
+// shared, as this thread learned it.
+const threadCaches = new Map();
+/**
+ * Caches every query of another file system; for a single compilation, where files don't change.
+ * Once shared with other threads (`prepareForSharing`), what was cached until then is read by every
+ * thread, and each thread caches new answers in tables of its own.
+ */
+export class CachedFileSystem extends FileSystem {
+    inner;
+    caches = new FileSystemCaches();
+    shared = false;
+    constructor(inner) {
+        super(inner.useCaseSensitiveFileNames);
+        this.inner = inner;
+    }
+    prepareForSharing() {
+        // A file system already shared (with an earlier program of a build) is immutable.
+        if (!this.shared)
+            this.shared = true;
+    }
+    /** Where new answers go: this file system's caches, or once it is shared, this thread's. */
+    ownCaches() {
+        if (!this.shared)
+            return this.caches;
+        let caches = threadCaches.get(this);
+        if (caches === undefined) {
+            caches = new FileSystemCaches();
+            threadCaches.set(this, caches);
+        }
+        return caches;
+    }
+    fileExists(path) {
+        const key = this.key(path);
+        let exists = this.caches.files.get(key);
+        if (exists !== undefined)
+            return exists;
+        const own = this.ownCaches();
+        exists = own.files.get(key);
+        if (exists === undefined) {
+            exists = this.inner.fileExists(path);
+            own.files.set(key, exists);
+        }
+        return exists;
+    }
+    directoryExists(path) {
+        const key = this.key(path);
+        let exists = this.caches.directories.get(key);
+        if (exists !== undefined)
+            return exists;
+        const own = this.ownCaches();
+        exists = own.directories.get(key);
+        if (exists === undefined) {
+            exists = this.inner.directoryExists(path);
+            own.directories.set(key, exists);
+        }
+        return exists;
+    }
+    readFile(path) {
+        return this.inner.readFile(path);
+    }
+    getAccessibleEntries(path) {
+        const key = this.key(path);
+        let entries = this.caches.entries.get(key);
+        if (entries !== undefined)
+            return entries;
+        const own = this.ownCaches();
+        entries = own.entries.get(key);
+        if (entries === undefined) {
+            entries = this.inner.getAccessibleEntries(path);
+            own.entries.set(key, entries);
+        }
+        return entries;
+    }
+    realpath(path) {
+        const key = this.key(path);
+        let real = this.caches.realpaths.get(key);
+        if (real !== undefined)
+            return real;
+        const own = this.ownCaches();
+        real = own.realpaths.get(key);
+        if (real === undefined) {
+            real = this.inner.realpath(path);
+            own.realpaths.set(key, real);
+        }
+        return real;
+    }
+    /** Whether `fileExists` was called for `path`. */
+    lookedUpFile(path) {
+        return this.caches.files.has(this.key(path));
+    }
+    key(path) {
+        return getCanonicalFileName(path, this.useCaseSensitiveFileNames);
+    }
+}

package/dist/api/compiler/flow.d.ts

@@ -0,0 +1,60 @@
+import type { ProgramLifetime } from '@scriptc/types';
+import type { Node } from './ast.js';
+export declare const enum FlowFlags {
+    None = 0,
+    Unreachable = 1,
+    /** Start of a function, source file or other control flow container. */
+    Start = 2,
+    /** A junction of paths, e.g. after an `if`. */
+    BranchLabel = 4,
+    /** The top of a loop. */
+    LoopLabel = 8,
+    Assignment = 16,
+    /** `node` is known to be true here. */
+    TrueCondition = 32,
+    /** `node` is known to be false here. */
+    FalseCondition = 64,
+    /** The start of a range of `case` clauses. */
+    SwitchClause = 128,
+    /** A possible array mutation such as `x.push(…)` or `x[i] = …`. */
+    ArrayMutation = 256,
+    /** A call that may be an assertion. */
+    Call = 512,
+    /** Temporarily narrows a label's antecedents; see `FlowReduceLabel`. */
+    ReduceLabel = 1024,
+    /** Referenced as an antecedent once. */
+    Referenced = 2048,
+    /** Referenced as an antecedent more than once. */
+    Shared = 4096,
+    Label = 12,
+    Condition = 96
+}
+export declare class FlowNode implements ProgramLifetime {
+    flags: FlowFlags;
+    /** The assignment, condition, call or function this node is about. */
+    node: Node | undefined;
+    /** What runs before this node, for all but labels. */
+    antecedent: FlowNode | undefined;
+    /** For labels: the joined paths, in order of addition. */
+    antecedents: FlowNode[] | undefined;
+    constructor(flags: FlowFlags, node: Node | undefined, antecedent: FlowNode | undefined);
+}
+/**
+ * Entry to clauses `clauseStart` to `clauseEnd` (exclusive) of `switchStatement`, which is
+ * also `node`. An empty range means no clause matched.
+ */
+export declare class FlowSwitchClause extends FlowNode {
+    readonly switchStatement: Node;
+    readonly clauseStart: number;
+    readonly clauseEnd: number;
+    constructor(antecedent: FlowNode, switchStatement: Node, clauseStart: number, clauseEnd: number);
+    isEmpty(): boolean;
+}
+/**
+ * While analysis passes this node, `target` (the label before a `finally` block) has only
+ * `antecedents`, e.g. the paths that completed the `try` block normally.
+ */
+export declare class FlowReduceLabel extends FlowNode {
+    readonly target: FlowNode;
+    constructor(target: FlowNode, antecedents: FlowNode[], antecedent: FlowNode);
+}

package/dist/api/compiler/flow.js

@@ -0,0 +1,45 @@
+export class FlowNode {
+    flags;
+    /** The assignment, condition, call or function this node is about. */
+    node;
+    /** What runs before this node, for all but labels. */
+    antecedent;
+    /** For labels: the joined paths, in order of addition. */
+    antecedents;
+    constructor(flags, node, antecedent) {
+        this.flags = flags;
+        this.node = node;
+        this.antecedent = antecedent;
+        this.antecedents = undefined;
+    }
+}
+/**
+ * Entry to clauses `clauseStart` to `clauseEnd` (exclusive) of `switchStatement`, which is
+ * also `node`. An empty range means no clause matched.
+ */
+export class FlowSwitchClause extends FlowNode {
+    switchStatement;
+    clauseStart;
+    clauseEnd;
+    constructor(antecedent, switchStatement, clauseStart, clauseEnd) {
+        super(128 /* FlowFlags.SwitchClause */, switchStatement, antecedent);
+        this.switchStatement = switchStatement;
+        this.clauseStart = clauseStart;
+        this.clauseEnd = clauseEnd;
+    }
+    isEmpty() {
+        return this.clauseStart === this.clauseEnd;
+    }
+}
+/**
+ * While analysis passes this node, `target` (the label before a `finally` block) has only
+ * `antecedents`, e.g. the paths that completed the `try` block normally.
+ */
+export class FlowReduceLabel extends FlowNode {
+    target;
+    constructor(target, antecedents, antecedent) {
+        super(1024 /* FlowFlags.ReduceLabel */, undefined, antecedent);
+        this.target = target;
+        this.antecedents = antecedents;
+    }
+}

package/dist/api/compiler/instantiation.d.ts

@@ -0,0 +1,74 @@
+import { type Node } from './ast.js';
+import { type Symbol } from './symbol.js';
+import type { Checker, VarianceReporting } from './checker.js';
+import { IndexInfo, type ObjectType, Signature, type Type, TypeAlias, TypeMapper, TypeParameter } from './checker-types.js';
+/** Applies `m1`, then instantiates its result with `m2`, or applies `m2` when `m1` doesn't map. */
+export declare class CompositeTypeMapper extends TypeMapper {
+    readonly c: Checker;
+    readonly m1: TypeMapper;
+    readonly m2: TypeMapper;
+    constructor(c: Checker, m1: TypeMapper, m2: TypeMapper);
+    map(type: Type): Type;
+}
+/** Records unreliable or unmeasurable variance when it sees a marker type. */
+export declare class ReportingMapper extends TypeMapper {
+    readonly c: Checker;
+    readonly flag: VarianceReporting;
+    constructor(c: Checker, flag: VarianceReporting);
+    map(type: Type): Type;
+}
+/** Maps type parameters to copies without constraints. */
+export declare class RestrictiveMapper extends TypeMapper {
+    readonly c: Checker;
+    constructor(c: Checker);
+    map(type: Type): Type;
+}
+/** Maps type parameters to the wildcard type. */
+export declare class PermissiveMapper extends TypeMapper {
+    readonly c: Checker;
+    constructor(c: Checker);
+    map(type: Type): Type;
+}
+/** Maps type parameters to the unique literal `never`, for reducibility checks. */
+export declare class UniqueLiteralMapper extends TypeMapper {
+    readonly c: Checker;
+    constructor(c: Checker);
+    map(type: Type): Type;
+}
+export declare function combineTypeMappers(c: Checker, m1: TypeMapper | undefined, m2: TypeMapper): TypeMapper;
+export declare function instantiateType(c: Checker, type: Type, mapper: TypeMapper | undefined): Type;
+export declare function instantiateTypeWithAlias(c: Checker, type: Type, mapper: TypeMapper | undefined, alias: TypeAlias | undefined): Type;
+/** Whether `type` could reference a type parameter we infer for. Cached on the type. */
+export declare function couldContainTypeVariables(c: Checker, type: Type): boolean;
+/** Whether `node` has a reference to `tp` (or one that may be to it, such as a type query). */
+export declare function containsTypeParameterReference(c: Checker, tp: Type, node: Node): boolean;
+export declare function isNodeDescendantOf(node: Node, ancestor: Node): boolean;
+/**
+ * Whether `tp` may be referenced in `node`: true without exactly one declaration, across
+ * statement blocks, or for references and type queries we can't rule out.
+ */
+export declare function isTypeParameterPossiblyReferenced(c: Checker, tp: Type, node: Node): boolean;
+export declare function instantiateAnonymousType(c: Checker, type: ObjectType, mapper: TypeMapper, alias: TypeAlias | undefined): ObjectType;
+export declare function cloneTypeParameter(c: Checker, tp: Type): TypeParameter;
+export declare function instantiateTypeAlias(c: Checker, alias: TypeAlias | undefined, mapper: TypeMapper): TypeAlias | undefined;
+/** Instantiates each type; returns `types` itself when nothing changed. */
+export declare function instantiateTypes(c: Checker, types: Type[], mapper: TypeMapper | undefined): Type[];
+export declare function instantiateSymbols(c: Checker, symbols: Symbol[], mapper: TypeMapper): Symbol[];
+export declare function instantiateSignatures(c: Checker, signatures: Signature[], mapper: TypeMapper): Signature[];
+export declare function instantiateIndexInfos(c: Checker, infos: IndexInfo[], mapper: TypeMapper): IndexInfo[];
+export declare function instantiateIndexInfo(c: Checker, info: IndexInfo, mapper: TypeMapper): IndexInfo;
+export declare function instantiateSignature(c: Checker, sig: Signature, mapper: TypeMapper): Signature;
+export declare function instantiateSignatureEx(c: Checker, sig: Signature, mapper: TypeMapper, eraseTypeParameters: boolean): Signature;
+export declare function instantiateSymbol(c: Checker, symbol: Symbol, mapper: TypeMapper): Symbol;
+/**
+ * Whether `instantiateSymbol` returns `symbol` itself. This depends on whether the type of `symbol`
+ * is resolved yet, so lazily instantiated members record it when tsgo would instantiate them.
+ */
+export declare function keepsSymbolUnderInstantiation(c: Checker, symbol: Symbol, mapper: TypeMapper): boolean;
+/** The instantiated copy of `symbol` that `instantiateSymbol` creates when it doesn't keep it. */
+export declare function newInstantiatedSymbol(c: Checker, symbol: Symbol, mapper: TypeMapper): Symbol;
+/** Conservatively, whether a parameter or member's type can't reference `this`. */
+export declare function isThisless(symbol: Symbol): boolean;
+export declare function getRestrictiveInstantiation(c: Checker, type: Type): Type;
+export declare function isRestrictiveInstance(c: Checker, type: Type): boolean;
+export { Signature };