tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/checker-generated-code.d.ts

@@ -0,0 +1,25 @@
+import { type Node } from './ast.js';
+import type { Checker } from './checker.js';
+import { type Diagnostic, type DiagnosticMessage } from './diagnostics.js';
+/** A collision check that waits until the file is checked, when the flags it reads are complete. */
+export declare class DeferredCollisionCheck {
+    readonly node: Node;
+    /** `Reflect` rather than `WeakMap` and `WeakSet`. */
+    readonly reflect: boolean;
+    constructor(node: Node, 
+    /** `Reflect` rather than `WeakMap` and `WeakSet`. */
+    reflect: boolean);
+}
+/** An error that is not reported under noEmit, since it is about the emitted code. */
+export declare function errorSkippedOnNoEmit(c: Checker, node: Node, message: DiagnosticMessage, ...args: string[]): Diagnostic;
+/** Checks the name of a declaration against the names the emitted code reserves. */
+export declare function checkCollisionsForDeclarationName(c: Checker, node: Node, name: Node | undefined): void;
+/**
+ * A private name downleveled (before ESNext, or without useDefineForClassFields) is emitted with `WeakMap` or
+ * `WeakSet`: marks the block scopes around its class.
+ */
+export declare function markPrivateIdentifierScope(c: Checker, node: Node): void;
+/** `super.x` in a static initializer before ES2022 is emitted with `Reflect`: marks the block scopes around it. */
+export declare function markSuperPropertyInStaticInitializer(c: Checker, node: Node): void;
+/** Reports the `WeakMap`, `WeakSet` and `Reflect` collisions found while checking the file. */
+export declare function produceDeferredCollisionChecks(c: Checker): void;

package/dist/api/compiler/checker-generated-code.js

@@ -0,0 +1,168 @@
+// Declarations whose names collide with names the emitted code uses: `require` and `exports` in CommonJS
+// output, `Object`, `Promise` (async functions before ES2017), `WeakMap` and `WeakSet` (downleveled private
+// names) and `Reflect` (downleveled `super` in static initializers). These errors are skipped under noEmit.
+import { getBody, getMembers, getName, getText } from './ast.js';
+import { declarationNameToString, getRootDeclaration, getSourceFileOfNode, isClassLike, isExternalOrCommonJSModule, getModuleInstanceState, } from './binder-utilities.js';
+import { getDeclarationContainer, isTypeOnlyImportOrExportDeclaration } from './checker-modules.js';
+import { getEnclosingBlockScopeContainer } from './checker-declaration-order.js';
+import { ModuleKind, ScriptTarget, getEmitModuleKind, getUseDefineForClassFields } from './options.js';
+import { moduleKindName } from './program-utilities.js';
+/** A collision check that waits until the file is checked, when the flags it reads are complete. */
+export class DeferredCollisionCheck {
+    node;
+    reflect;
+    constructor(node, 
+    /** `Reflect` rather than `WeakMap` and `WeakSet`. */
+    reflect) {
+        this.node = node;
+        this.reflect = reflect;
+    }
+}
+/** An error that is not reported under noEmit, since it is about the emitted code. */
+export function errorSkippedOnNoEmit(c, node, message, ...args) {
+    const diagnostic = c.error(node, message, ...args);
+    diagnostic.skippedOnNoEmit = true;
+    return diagnostic;
+}
+/** Checks the name of a declaration against the names the emitted code reserves. */
+export function checkCollisionsForDeclarationName(c, node, name) {
+    if (name === undefined)
+        return;
+    checkCollisionWithRequireExportsInGeneratedCode(c, node, name);
+    checkCollisionWithGlobalObjectInGeneratedCode(c, node, name);
+    checkCollisionWithGlobalPromiseInGeneratedCode(c, node, name);
+    if (c.languageVersion <= ScriptTarget.ES2021 &&
+        (needCollisionCheckForIdentifier(node, name, 'WeakMap') || needCollisionCheckForIdentifier(node, name, 'WeakSet')))
+        c.deferredCollisionChecks.push(new DeferredCollisionCheck(node, false));
+    if (c.languageVersion <= ScriptTarget.ES2021 && needCollisionCheckForIdentifier(node, name, 'Reflect'))
+        c.deferredCollisionChecks.push(new DeferredCollisionCheck(node, true));
+    if (isClassLike(node) && (node.flags & 8388608 /* NodeFlags.Ambient */) === 0 && getText(name) === 'Object') {
+        if (c.host.getEmitModuleFormatOfFile(getSourceFileOfNode(name)) < ModuleKind.ES2015)
+            c.error(name, 857 /* Diagnostics.Class_name_cannot_be_Object_when_targeting_ES5_and_above_with_module_0 */, moduleKindName(getEmitModuleKind(c.compilerOptions)));
+    }
+}
+function checkCollisionWithRequireExportsInGeneratedCode(c, node, name) {
+    if (!needCollisionCheckForIdentifier(node, name, 'require') &&
+        !needCollisionCheckForIdentifier(node, name, 'exports'))
+        return;
+    // ES modules don't use `require` or `exports`.
+    if (c.host.getEmitModuleFormatOfFile(getSourceFileOfNode(node)) >= ModuleKind.ES2015)
+        return;
+    if (node.kind === 268 /* SyntaxKind.ModuleDeclaration */ && getModuleInstanceState(node) !== 2 /* ModuleInstanceState.Instantiated */)
+        return;
+    const parent = getDeclarationContainer(node);
+    if (parent.kind === 307 /* SyntaxKind.SourceFile */ && isExternalOrCommonJSModule(parent))
+        reportReservedTopLevelName(c, name, 609 /* Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module */);
+}
+function checkCollisionWithGlobalObjectInGeneratedCode(c, node, name) {
+    if (isClassLike(node) || !needCollisionCheckForIdentifier(node, name, 'Object'))
+        return;
+    if (node.kind === 268 /* SyntaxKind.ModuleDeclaration */ && getModuleInstanceState(node) !== 2 /* ModuleInstanceState.Instantiated */)
+        return;
+    const parent = getDeclarationContainer(node);
+    if (parent.kind === 307 /* SyntaxKind.SourceFile */ &&
+        isExternalOrCommonJSModule(parent) &&
+        c.host.getEmitModuleFormatOfFile(parent) === ModuleKind.CommonJS)
+        reportReservedTopLevelName(c, name, 609 /* Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module */);
+}
+function checkCollisionWithGlobalPromiseInGeneratedCode(c, node, name) {
+    if (c.languageVersion >= ScriptTarget.ES2017 || !needCollisionCheckForIdentifier(node, name, 'Promise'))
+        return;
+    if (node.kind === 268 /* SyntaxKind.ModuleDeclaration */ && getModuleInstanceState(node) !== 2 /* ModuleInstanceState.Instantiated */)
+        return;
+    const parent = getDeclarationContainer(node);
+    if (parent.kind === 307 /* SyntaxKind.SourceFile */ &&
+        isExternalOrCommonJSModule(parent) &&
+        (parent.flags & 262144 /* NodeFlags.HasAsyncFunctions */) !== 0)
+        reportReservedTopLevelName(c, name, 687 /* Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_containing_async_functions */);
+}
+function reportReservedTopLevelName(c, name, message) {
+    const text = declarationNameToString(getSourceFileOfNode(name), name);
+    errorSkippedOnNoEmit(c, name, message, text, text);
+}
+/** Whether the declaration `node` binds `name` where the emitted code could see it. */
+function needCollisionCheckForIdentifier(node, identifier, name) {
+    if (identifier.kind !== 79 /* SyntaxKind.Identifier */ || getText(identifier) !== name)
+        return false;
+    switch (node.kind) {
+        case 173 /* SyntaxKind.PropertyDeclaration */:
+        case 172 /* SyntaxKind.PropertySignature */:
+        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 174 /* SyntaxKind.MethodSignature */:
+        case 178 /* SyntaxKind.GetAccessor */:
+        case 179 /* SyntaxKind.SetAccessor */:
+        case 303 /* SyntaxKind.PropertyAssignment */:
+            return false;
+    }
+    if ((node.flags & 8388608 /* NodeFlags.Ambient */) !== 0)
+        return false;
+    if ((node.kind === 274 /* SyntaxKind.ImportClause */ ||
+        node.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */ ||
+        node.kind === 277 /* SyntaxKind.ImportSpecifier */) &&
+        isTypeOnlyImportOrExportDeclaration(node))
+        return false;
+    const root = getRootDeclaration(node);
+    return !(root.kind === 170 /* SyntaxKind.Parameter */ && getBody(root.parent) === undefined);
+}
+/**
+ * A private name downleveled (before ESNext, or without useDefineForClassFields) is emitted with `WeakMap` or
+ * `WeakSet`: marks the block scopes around its class.
+ */
+export function markPrivateIdentifierScope(c, node) {
+    const name = getName(node);
+    if (name === undefined || name.kind !== 80 /* SyntaxKind.PrivateIdentifier */)
+        return;
+    if (c.languageVersion >= ScriptTarget.ESNext && getUseDefineForClassFields(c.compilerOptions))
+        return;
+    for (let scope = getEnclosingBlockScopeContainer(node); scope !== undefined; scope = getEnclosingBlockScopeContainer(scope))
+        c.nodeLinks(scope).flags |= 1048576 /* NodeCheckFlags.ContainsClassWithPrivateIdentifiers */;
+}
+/** `super.x` in a static initializer before ES2022 is emitted with `Reflect`: marks the block scopes around it. */
+export function markSuperPropertyInStaticInitializer(c, node) {
+    for (let scope = getEnclosingBlockScopeContainer(node.parent); scope !== undefined; scope = getEnclosingBlockScopeContainer(scope))
+        if (scope.kind !== 307 /* SyntaxKind.SourceFile */ || isExternalOrCommonJSModule(scope))
+            c.nodeLinks(scope).flags |= 2097152 /* NodeCheckFlags.ContainsSuperPropertyInStaticInitializer */;
+}
+/** Reports the `WeakMap`, `WeakSet` and `Reflect` collisions found while checking the file. */
+export function produceDeferredCollisionChecks(c) {
+    const checks = c.deferredCollisionChecks;
+    if (checks.length === 0)
+        return;
+    c.deferredCollisionChecks = [];
+    for (const check of checks) {
+        if (check.reflect)
+            checkReflectCollision(c, check.node);
+        else
+            checkWeakMapSetCollision(c, check.node);
+    }
+}
+function checkWeakMapSetCollision(c, node) {
+    const scope = getEnclosingBlockScopeContainer(node);
+    if (scope === undefined || (c.nodeLinks(scope).flags & 1048576 /* NodeCheckFlags.ContainsClassWithPrivateIdentifiers */) === 0)
+        return;
+    const name = getName(node);
+    if (name !== undefined && name.kind === 79 /* SyntaxKind.Identifier */)
+        errorSkippedOnNoEmit(c, node, 1844 /* Diagnostics.Compiler_reserves_name_0_when_emitting_private_identifier_downlevel */, getText(name));
+}
+function checkReflectCollision(c, node) {
+    let hasCollision = false;
+    if (node.kind === 232 /* SyntaxKind.ClassExpression */) {
+        for (const member of getMembers(node).nodes)
+            if ((c.nodeLinks(member).flags & 2097152 /* NodeCheckFlags.ContainsSuperPropertyInStaticInitializer */) !== 0) {
+                hasCollision = true;
+                break;
+            }
+    }
+    else if (node.kind === 219 /* SyntaxKind.FunctionExpression */)
+        hasCollision = (c.nodeLinks(node).flags & 2097152 /* NodeCheckFlags.ContainsSuperPropertyInStaticInitializer */) !== 0;
+    else {
+        const scope = getEnclosingBlockScopeContainer(node);
+        hasCollision =
+            scope !== undefined && (c.nodeLinks(scope).flags & 2097152 /* NodeCheckFlags.ContainsSuperPropertyInStaticInitializer */) !== 0;
+    }
+    if (!hasCollision)
+        return;
+    const name = getName(node);
+    if (name !== undefined && name.kind === 79 /* SyntaxKind.Identifier */)
+        errorSkippedOnNoEmit(c, node, 949 /* Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_when_emitting_super_references_in_static_initializers */, declarationNameToString(getSourceFileOfNode(name), name), 'Reflect');
+}

package/dist/api/compiler/checker-globals.d.ts

@@ -0,0 +1,14 @@
+import type { Checker } from './checker.js';
+import type { Type } from './checker-types.js';
+export declare function getGlobalESSymbolType(c: Checker): Type;
+export declare function getGlobalBigIntType(c: Checker): Type;
+export declare function getGlobalTemplateStringsArrayType(c: Checker): Type;
+export declare function getGlobalTypedPropertyDescriptorType(c: Checker): Type;
+export declare function getGlobalClassDecoratorContextType(c: Checker): Type;
+export declare function getGlobalClassMethodDecoratorContextType(c: Checker): Type;
+export declare function getGlobalClassGetterDecoratorContextType(c: Checker): Type;
+export declare function getGlobalClassSetterDecoratorContextType(c: Checker): Type;
+export declare function getGlobalClassAccessorDecoratorContextType(c: Checker): Type;
+export declare function getGlobalClassAccessorDecoratorTargetType(c: Checker): Type;
+export declare function getGlobalClassAccessorDecoratorResultType(c: Checker): Type;
+export declare function getGlobalClassFieldDecoratorContextType(c: Checker): Type;

package/dist/api/compiler/checker-globals.js

@@ -0,0 +1,37 @@
+import { getCachedGlobalType } from './checker-symbols.js';
+export function getGlobalESSymbolType(c) {
+    return getCachedGlobalType(c, 'Symbol', 0, false);
+}
+export function getGlobalBigIntType(c) {
+    return getCachedGlobalType(c, 'BigInt', 0, false);
+}
+export function getGlobalTemplateStringsArrayType(c) {
+    return getCachedGlobalType(c, 'TemplateStringsArray', 0, true);
+}
+export function getGlobalTypedPropertyDescriptorType(c) {
+    return getCachedGlobalType(c, 'TypedPropertyDescriptor', 1, true);
+}
+export function getGlobalClassDecoratorContextType(c) {
+    return getCachedGlobalType(c, 'ClassDecoratorContext', 1, true);
+}
+export function getGlobalClassMethodDecoratorContextType(c) {
+    return getCachedGlobalType(c, 'ClassMethodDecoratorContext', 2, true);
+}
+export function getGlobalClassGetterDecoratorContextType(c) {
+    return getCachedGlobalType(c, 'ClassGetterDecoratorContext', 2, true);
+}
+export function getGlobalClassSetterDecoratorContextType(c) {
+    return getCachedGlobalType(c, 'ClassSetterDecoratorContext', 2, true);
+}
+export function getGlobalClassAccessorDecoratorContextType(c) {
+    return getCachedGlobalType(c, 'ClassAccessorDecoratorContext', 2, true);
+}
+export function getGlobalClassAccessorDecoratorTargetType(c) {
+    return getCachedGlobalType(c, 'ClassAccessorDecoratorTarget', 2, true);
+}
+export function getGlobalClassAccessorDecoratorResultType(c) {
+    return getCachedGlobalType(c, 'ClassAccessorDecoratorResult', 2, true);
+}
+export function getGlobalClassFieldDecoratorContextType(c) {
+    return getCachedGlobalType(c, 'ClassFieldDecoratorContext', 2, true);
+}

package/dist/api/compiler/checker-grammar.d.ts

@@ -0,0 +1,35 @@
+import { type Node, type NodeList, NodeVisitor, type ObjectLiteralExpression, type SourceFile } from './ast.js';
+import { type Checker } from './checker.js';
+import { ModuleKind } from './options.js';
+import { SourceFileMetadata } from './program-utilities.js';
+import { Scanner } from './scanner.js';
+/** Runs the grammar checks of every node of `file`. */
+export declare function checkGrammarSourceFile(c: Checker, file: SourceFile): void;
+/** Checks the grammar of an object literal each time it is checked, as tsgo does. */
+export declare function checkGrammarObjectLiteralOfExpression(c: Checker, node: ObjectLiteralExpression, inDestructuring: boolean): void;
+/** Reports a trailing comma after the rest element of a destructuring assignment. */
+export declare function checkGrammarRestTrailingComma(c: Checker, node: Node, list: NodeList): void;
+/** Checks the grammar of a function expression or arrow function each time it is checked. */
+export declare function checkGrammarFunctionExpression(c: Checker, node: Node): void;
+/** Checks the grammar of an `await` expression each time it is checked. */
+export declare function checkGrammarAwaitExpression(c: Checker, node: Node): void;
+/** Checks the grammar of a `yield` expression each time it is checked. */
+export declare function checkGrammarYieldOfExpression(c: Checker, node: Node): void;
+/** Per-file state of the grammar walk. */
+export declare class GrammarChecker extends NodeVisitor {
+    readonly c: Checker;
+    readonly file: SourceFile;
+    /** Grammar errors are only reported in files without parse errors. */
+    readonly hasParseErrors: boolean;
+    readonly moduleKind: ModuleKind;
+    readonly metadata: SourceFileMetadata;
+    readonly legacyDecorators: boolean;
+    /** Blocks and statements that already reported a statement in an ambient context. */
+    readonly reportedAmbientStatements: Set<number>;
+    private scanner;
+    constructor(c: Checker, file: SourceFile);
+    visitNode(node: Node): boolean;
+    /** A scanner over the file's text, for rescanning tokens. */
+    getScanner(): Scanner;
+}
+export declare function getContainingFunctionOrClassStaticBlock(node: Node): Node | undefined;