tsc-ts 0.0.3 → 0.0.5

package/dist/api/compiler/checker-declaration-order.d.ts

@@ -0,0 +1,12 @@
+import { type Node } from './ast.js';
+import { type Checker } from './checker.js';
+import { type Symbol } from './symbol.js';
+/** Reports a block-scoped variable, class or enum resolved at `errorLocation` before its declaration. */
+export declare function checkResolvedBlockScopedVariable(c: Checker, resolved: Symbol, errorLocation: Node): void;
+/** Reports a class property read in an initializer before it's initialized. */
+export declare function checkPropertyNotUsedBeforeDeclaration(c: Checker, prop: Symbol, node: Node, right: Node): void;
+export declare function isInPropertyInitializerOrClassStaticBlock(node: Node, ignoreArrowFunctions: boolean): boolean;
+export declare function getEmitStandardClassFields(c: Checker): boolean;
+/** Whether a use of a block-scoped declaration is legal: after it, or deferred until it's initialized. */
+export declare function isBlockScopedNameDeclaredBeforeUse(c: Checker, declaration: Node, usage: Node): boolean;
+export declare function getEnclosingBlockScopeContainer(node: Node): Node | undefined;

package/dist/api/compiler/checker-declaration-order.js

@@ -0,0 +1,356 @@
+// Declaration order: uses of block-scoped variables, classes, enums and class properties before
+// their declarations or initialization.
+import { getExpression, getInitializer, getPostfixToken, getText, getName, getMembers, } from './ast.js';
+import { declarationNameToString, getContainingClass, getImmediatelyInvokedFunctionExpression, getNameOfDeclaration, getSourceFileOfNode, isAccessExpression, isBlockOrCatchScoped, isClassLike, isParameterPropertyDeclaration, isPartOfTypeQuery, isStatic, } from './binder-utilities.js';
+import { isFunctionLike } from './ast-utilities.js';
+import { createDiagnosticForNode } from './checker.js';
+import { ScriptTarget } from './options.js';
+import { getSymbolOfDeclaration } from './checker-symbols.js';
+import { getTypeOfSymbol } from './checker-symbol-types.js';
+import { isPropertyInitializedInStaticBlocks } from './checker-classes.js';
+import { getExportSymbolOfValueSymbolIfExported } from './checker-symbols.js';
+import { getBaseTypes, getDeclaredTypeOfSymbol } from './checker-declared-types.js';
+import { getPropertyOfType } from './checker-members.js';
+import { getFunctionFlags } from './checker-utilities.js';
+/** Reports a block-scoped variable, class or enum resolved at `errorLocation` before its declaration. */
+export function checkResolvedBlockScopedVariable(c, resolved, errorLocation) {
+    const result = getExportSymbolOfValueSymbolIfExported(c, resolved);
+    if ((result.flags & (2 /* SymbolFlags.BlockScopedVariable */ | 32 /* SymbolFlags.Class */ | 384 /* SymbolFlags.Enum */)) === 0)
+        return;
+    // Constructor functions aren't block scoped.
+    if ((result.flags & (16 /* SymbolFlags.Function */ | 1 /* SymbolFlags.FunctionScopedVariable */ | 67108864 /* SymbolFlags.Assignment */)) !== 0 &&
+        (result.flags & 32 /* SymbolFlags.Class */) !== 0)
+        return;
+    let declaration;
+    for (const d of result.declarations) {
+        if (isBlockOrCatchScoped(d) || isClassLike(d) || d.kind === 267 /* SyntaxKind.EnumDeclaration */) {
+            declaration = d;
+            break;
+        }
+    }
+    if (declaration === undefined ||
+        (declaration.flags & 8388608 /* NodeFlags.Ambient */) !== 0 ||
+        isBlockScopedNameDeclaredBeforeUse(c, declaration, errorLocation))
+        return;
+    const declarationName = declarationNameToString(getSourceFileOfNode(declaration), getNameOfDeclaration(declaration));
+    let diagnostic = undefined;
+    if ((result.flags & 2 /* SymbolFlags.BlockScopedVariable */) !== 0)
+        diagnostic = c.error(errorLocation, 616 /* Diagnostics.Block_scoped_variable_0_used_before_its_declaration */, declarationName);
+    else if ((result.flags & 32 /* SymbolFlags.Class */) !== 0)
+        diagnostic = c.error(errorLocation, 617 /* Diagnostics.Class_0_used_before_its_declaration */, declarationName);
+    else if ((result.flags & 256 /* SymbolFlags.RegularEnum */) !== 0 || c.isolatedModules)
+        diagnostic = c.error(errorLocation, 618 /* Diagnostics.Enum_0_used_before_its_declaration */, declarationName);
+    if (diagnostic !== undefined)
+        diagnostic.addRelatedInfo(createDiagnosticForNode(declaration, 860 /* Diagnostics.X_0_is_declared_here */, [declarationName]));
+}
+/** Reports a class property read in an initializer before it's initialized. */
+export function checkPropertyNotUsedBeforeDeclaration(c, prop, node, right) {
+    const valueDeclaration = prop.valueDeclaration;
+    if (valueDeclaration === undefined || getSourceFileOfNode(node).isDeclarationFile)
+        return;
+    const declarationName = getText(right);
+    let diagnostic = undefined;
+    if (isInPropertyInitializerOrClassStaticBlock(node, false) &&
+        !isOptionalPropertyDeclaration(valueDeclaration) &&
+        !(isAccessExpression(node) && isAccessExpression(getExpression(node))) &&
+        !isBlockScopedNameDeclaredBeforeUse(c, valueDeclaration, right) &&
+        !(valueDeclaration.kind === 175 /* SyntaxKind.MethodDeclaration */ && isStatic(valueDeclaration)) &&
+        (getUseDefineForClassFields(c) || !isPropertyDeclaredInAncestorClass(c, prop)))
+        diagnostic = c.error(right, 861 /* Diagnostics.Property_0_is_used_before_its_initialization */, declarationName);
+    else if (valueDeclaration.kind === 264 /* SyntaxKind.ClassDeclaration */ &&
+        node.parent.kind !== 184 /* SyntaxKind.TypeReference */ &&
+        (valueDeclaration.flags & 8388608 /* NodeFlags.Ambient */) === 0 &&
+        !isBlockScopedNameDeclaredBeforeUse(c, valueDeclaration, right))
+        diagnostic = c.error(right, 617 /* Diagnostics.Class_0_used_before_its_declaration */, declarationName);
+    if (diagnostic !== undefined)
+        diagnostic.addRelatedInfo(createDiagnosticForNode(valueDeclaration, 860 /* Diagnostics.X_0_is_declared_here */, [declarationName]));
+}
+export function isInPropertyInitializerOrClassStaticBlock(node, ignoreArrowFunctions) {
+    for (let current = node; current !== undefined; current = current.parent) {
+        switch (current.kind) {
+            case 173 /* SyntaxKind.PropertyDeclaration */:
+            case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
+                return true;
+            case 187 /* SyntaxKind.TypeQuery */:
+            case 288 /* SyntaxKind.JsxClosingElement */:
+                return false;
+            case 220 /* SyntaxKind.ArrowFunction */:
+                if (!ignoreArrowFunctions)
+                    return false;
+                break;
+            case 242 /* SyntaxKind.Block */: {
+                const parent = current.parent;
+                if (isFunctionLike(parent) && parent.kind !== 220 /* SyntaxKind.ArrowFunction */)
+                    return false;
+            }
+        }
+    }
+    return false;
+}
+function isOptionalPropertyDeclaration(node) {
+    if (node.kind !== 173 /* SyntaxKind.PropertyDeclaration */)
+        return false;
+    const postfix = getPostfixToken(node);
+    return postfix !== undefined && postfix.kind === 57 /* SyntaxKind.QuestionToken */;
+}
+function isPropertyDeclaredInAncestorClass(c, prop) {
+    const parent = prop.parent;
+    if (parent === undefined || (parent.flags & 32 /* SymbolFlags.Class */) === 0)
+        return false;
+    const baseTypes = getBaseTypes(c, getDeclaredTypeOfSymbol(c, parent));
+    if (baseTypes.length === 0)
+        return false;
+    const superProperty = getPropertyOfType(c, baseTypes[0], prop.name);
+    return superProperty !== undefined && superProperty.valueDeclaration !== undefined;
+}
+function getUseDefineForClassFields(c) {
+    return c.compilerOptions.useDefineForClassFields ?? c.languageVersion >= ScriptTarget.ES2022;
+}
+export function getEmitStandardClassFields(c) {
+    return c.compilerOptions.useDefineForClassFields !== false && c.languageVersion >= ScriptTarget.ES2022;
+}
+/** Whether a use of a block-scoped declaration is legal: after it, or deferred until it's initialized. */
+export function isBlockScopedNameDeclaredBeforeUse(c, declaration, usage) {
+    if (getSourceFileOfNode(declaration) !== getSourceFileOfNode(usage))
+        return true;
+    const declContainer = getEnclosingBlockScopeContainer(declaration);
+    // Uses in type contexts are deferred.
+    if ((usage.flags & 4194304 /* NodeFlags.JSDoc */) !== 0 || isPartOfTypeQuery(usage) || isInAmbientOrTypeNode(usage))
+        return true;
+    if (declaration.pos <= usage.pos &&
+        !(declaration.kind === 173 /* SyntaxKind.PropertyDeclaration */ &&
+            isThisProperty(usage.parent) &&
+            getInitializer(declaration) === undefined &&
+            declaration.postfixToken?.kind !== 53 /* SyntaxKind.ExclamationToken */)) {
+        if (declaration.kind === 209 /* SyntaxKind.BindingElement */) {
+            // Binding elements may use earlier siblings only (`var [a = b, b = b] = ...` is an error).
+            const errorBindingElement = findAncestorOfKind(usage, 209 /* SyntaxKind.BindingElement */);
+            if (errorBindingElement !== undefined)
+                return (findAncestorOfKind(errorBindingElement, 209 /* SyntaxKind.BindingElement */) !==
+                    findAncestorOfKind(declaration, 209 /* SyntaxKind.BindingElement */) || declaration.pos < errorBindingElement.pos);
+            // `var [a] = a` uses the variable before its declaration.
+            return isBlockScopedNameDeclaredBeforeUse(c, findAncestorOfKind(declaration, 261 /* SyntaxKind.VariableDeclaration */), usage);
+        }
+        if (declaration.kind === 261 /* SyntaxKind.VariableDeclaration */)
+            // `var a = a` uses the variable in its own initializer.
+            return !isImmediatelyUsedInInitializerOfBlockScopedVariable(declaration, usage, declContainer);
+        if (isClassLike(declaration))
+            return !isUsedInClassComputedNameOrDecorator(c, declaration, usage);
+        if (declaration.kind === 173 /* SyntaxKind.PropertyDeclaration */)
+            // A self-referencing property initializer, as in `x = this.x`.
+            return !isPropertyImmediatelyReferencedWithinDeclaration(declaration, usage, false);
+        if (isParameterPropertyDeclaration(declaration, declaration.parent))
+            // `foo = this.bar` with standard class fields, when bar is a parameter property.
+            return !(getEmitStandardClassFields(c) &&
+                getContainingClass(declaration) === getContainingClass(usage) &&
+                isUsedInFunctionOrInstanceProperty(c, usage, declaration, declContainer));
+        return true;
+    }
+    // Uses after the declaration are legal when deferred: in export specifiers and `export =`,
+    // functions, and instance property initializers referencing other members.
+    const parent = usage.parent;
+    if (parent.kind === 282 /* SyntaxKind.ExportSpecifier */ || isExportEquals(parent) || isExportEquals(usage))
+        return true;
+    if (isUsedInFunctionOrInstanceProperty(c, usage, declaration, declContainer)) {
+        if (getEmitStandardClassFields(c) &&
+            getContainingClass(declaration) !== undefined &&
+            (declaration.kind === 173 /* SyntaxKind.PropertyDeclaration */ ||
+                isParameterPropertyDeclaration(declaration, declaration.parent)))
+            return !isPropertyImmediatelyReferencedWithinDeclaration(declaration, usage, true);
+        return true;
+    }
+    return false;
+}
+function isExportEquals(node) {
+    return node.kind === 278 /* SyntaxKind.ExportAssignment */ && node.isExportEquals;
+}
+/**
+ * Whether a use of a class within its own declaration happens before the class exists: in a
+ * computed member name, or in a decorator outside a deferred function.
+ */
+function isUsedInClassComputedNameOrDecorator(c, declaration, usage) {
+    const legacyDecorators = c.compilerOptions.experimentalDecorators === true;
+    let container = usage;
+    while (container !== undefined && container !== declaration) {
+        if (container.kind === 168 /* SyntaxKind.ComputedPropertyName */ && container.parent.parent === declaration)
+            break;
+        if (!legacyDecorators && container.kind === 171 /* SyntaxKind.Decorator */) {
+            const decorated = container.parent;
+            if (decorated === declaration ||
+                ((decorated.kind === 175 /* SyntaxKind.MethodDeclaration */ ||
+                    decorated.kind === 178 /* SyntaxKind.GetAccessor */ ||
+                    decorated.kind === 179 /* SyntaxKind.SetAccessor */ ||
+                    decorated.kind === 173 /* SyntaxKind.PropertyDeclaration */) &&
+                    decorated.parent === declaration) ||
+                (decorated.kind === 170 /* SyntaxKind.Parameter */ && decorated.parent.parent === declaration))
+                break;
+        }
+        container = container.parent;
+    }
+    if (container === undefined || container === declaration)
+        return false;
+    if (!legacyDecorators && container.kind === 171 /* SyntaxKind.Decorator */) {
+        let n = usage;
+        while (n !== undefined && n !== container) {
+            if (isFunctionLike(n) && getImmediatelyInvokedFunctionExpression(n) === undefined)
+                break;
+            n = n.parent;
+        }
+        return !(n !== undefined && n !== container);
+    }
+    return true;
+}
+function isThisProperty(node) {
+    return isAccessExpression(node) && getExpression(node).kind === 109 /* SyntaxKind.ThisKeyword */;
+}
+function findAncestorOfKind(node, kind) {
+    for (let current = node; current !== undefined; current = current.parent)
+        if (current.kind === kind)
+            return current;
+    return undefined;
+}
+function isInAmbientOrTypeNode(node) {
+    if ((node.flags & 8388608 /* NodeFlags.Ambient */) !== 0)
+        return true;
+    for (let current = node; current !== undefined; current = current.parent)
+        if (current.kind === 265 /* SyntaxKind.InterfaceDeclaration */ ||
+            current.kind === 266 /* SyntaxKind.TypeAliasDeclaration */ ||
+            current.kind === 188 /* SyntaxKind.TypeLiteral */)
+            return true;
+    return false;
+}
+export function getEnclosingBlockScopeContainer(node) {
+    for (let current = node.parent; current !== undefined; current = current.parent) {
+        switch (current.kind) {
+            case 307 /* SyntaxKind.SourceFile */:
+            case 270 /* SyntaxKind.CaseBlock */:
+            case 300 /* SyntaxKind.CatchClause */:
+            case 268 /* SyntaxKind.ModuleDeclaration */:
+            case 249 /* SyntaxKind.ForStatement */:
+            case 250 /* SyntaxKind.ForInStatement */:
+            case 251 /* SyntaxKind.ForOfStatement */:
+            case 177 /* SyntaxKind.Constructor */:
+            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.SetAccessor */:
+            case 263 /* SyntaxKind.FunctionDeclaration */:
+            case 219 /* SyntaxKind.FunctionExpression */:
+            case 220 /* SyntaxKind.ArrowFunction */:
+            case 173 /* SyntaxKind.PropertyDeclaration */:
+            case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
+                return current;
+            case 242 /* SyntaxKind.Block */: {
+                // Function bodies aren't block scope containers of their own.
+                const parent = current.parent;
+                if (!isFunctionLike(parent) && parent.kind !== 176 /* SyntaxKind.ClassStaticBlockDeclaration */)
+                    return current;
+            }
+        }
+    }
+    return undefined;
+}
+function isUsedInFunctionOrInstanceProperty(c, usage, declaration, declContainer) {
+    for (let current = usage; current !== undefined; current = current.parent) {
+        if (current === declContainer)
+            return false;
+        if (isFunctionLike(current)) {
+            if (getImmediatelyInvokedFunctionExpression(current) === undefined)
+                return true;
+            continue;
+        }
+        if (current.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */) {
+            if (declaration.pos < usage.pos)
+                return true;
+            continue;
+        }
+        const parent = current.parent;
+        if (parent !== undefined && parent.kind === 173 /* SyntaxKind.PropertyDeclaration */ && getInitializer(parent) === current) {
+            if (isStatic(parent)) {
+                if (declaration.kind === 175 /* SyntaxKind.MethodDeclaration */)
+                    return true;
+                // A static property assigned in a static block before the initializer.
+                if (declaration.kind === 173 /* SyntaxKind.PropertyDeclaration */ &&
+                    getContainingClass(usage) === getContainingClass(declaration)) {
+                    const propName = getName(declaration);
+                    if (propName.kind === 79 /* SyntaxKind.Identifier */ || propName.kind === 80 /* SyntaxKind.PrivateIdentifier */) {
+                        const symbol = getSymbolOfDeclaration(c, declaration);
+                        const staticBlocks = [];
+                        for (const m of getMembers(declaration.parent).nodes)
+                            if (m.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */)
+                                staticBlocks.push(m);
+                        if (symbol !== undefined &&
+                            isPropertyInitializedInStaticBlocks(c, propName, getTypeOfSymbol(c, symbol), staticBlocks, declaration.parent.pos, current.pos))
+                            return true;
+                    }
+                }
+            }
+            else {
+                const isDeclarationInstanceProperty = declaration.kind === 173 /* SyntaxKind.PropertyDeclaration */ && !isStatic(declaration);
+                if (!isDeclarationInstanceProperty || getContainingClass(usage) !== getContainingClass(declaration))
+                    return true;
+            }
+        }
+        if (parent !== undefined && parent.kind === 171 /* SyntaxKind.Decorator */ && getExpression(parent) === current) {
+            const decorated = parent.parent;
+            if (decorated.kind === 170 /* SyntaxKind.Parameter */)
+                return isUsedInFunctionOrInstanceProperty(c, decorated.parent.parent, declaration, declContainer);
+            if (decorated.kind === 175 /* SyntaxKind.MethodDeclaration */)
+                return isUsedInFunctionOrInstanceProperty(c, decorated.parent, declaration, declContainer);
+        }
+    }
+    return false;
+}
+function isImmediatelyUsedInInitializerOfBlockScopedVariable(declaration, usage, declContainer) {
+    const grandparent = declaration.parent.parent;
+    switch (grandparent.kind) {
+        case 244 /* SyntaxKind.VariableStatement */:
+        case 249 /* SyntaxKind.ForStatement */:
+        case 251 /* SyntaxKind.ForOfStatement */:
+            // The use is within the declaration: its initializer or a binding element.
+            if (isSameScopeDescendentOf(usage, declaration, declContainer))
+                return true;
+    }
+    // In `for (... in/of expr)`, the use is within the expression.
+    return ((grandparent.kind === 250 /* SyntaxKind.ForInStatement */ || grandparent.kind === 251 /* SyntaxKind.ForOfStatement */) &&
+        isSameScopeDescendentOf(usage, getExpression(grandparent), declContainer));
+}
+/** Whether `initial` is within `parent` without crossing `stopAt` or a function that isn't an IIFE. */
+function isSameScopeDescendentOf(initial, parent, stopAt) {
+    if (parent === undefined)
+        return false;
+    for (let n = initial; n !== undefined; n = n.parent) {
+        if (n === parent)
+            return true;
+        if (n === stopAt ||
+            (isFunctionLike(n) &&
+                (getImmediatelyInvokedFunctionExpression(n) === undefined ||
+                    (getFunctionFlags(n) & 3 /* FunctionFlags.AsyncGenerator */) !== 0)))
+            return false;
+    }
+    return false;
+}
+/** Whether a property initializer references the property immediately rather than in a deferred function. */
+function isPropertyImmediatelyReferencedWithinDeclaration(declaration, usage, stopAtAnyPropertyDeclaration) {
+    if (usage.end > declaration.end)
+        return false;
+    for (let node = usage; node !== undefined && node !== declaration; node = node.parent) {
+        switch (node.kind) {
+            case 220 /* SyntaxKind.ArrowFunction */:
+                return false;
+            case 173 /* SyntaxKind.PropertyDeclaration */:
+                // Even when stopping at any property declaration, it must be in the same class.
+                return (stopAtAnyPropertyDeclaration &&
+                    ((declaration.kind === 173 /* SyntaxKind.PropertyDeclaration */ && node.parent === declaration.parent) ||
+                        (isParameterPropertyDeclaration(declaration, declaration.parent) &&
+                            node.parent === declaration.parent.parent)));
+            case 242 /* SyntaxKind.Block */:
+                switch (node.parent.kind) {
+                    case 175 /* SyntaxKind.MethodDeclaration */:
+                    case 178 /* SyntaxKind.GetAccessor */:
+                    case 179 /* SyntaxKind.SetAccessor */:
+                        return false;
+                }
+        }
+    }
+    return true;
+}

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

@@ -0,0 +1,33 @@
+import { type Node, type NodeList, ModifierFlags } from './ast.js';
+import { type Checker } from './checker.js';
+import { type Type } from './checker-types.js';
+export declare function checkVariableStatement(c: Checker, node: Node): void;
+export declare function checkVariableDeclarationList(c: Checker, node: Node): void;
+/** Checks a variable, parameter, property or binding element declaration. */
+export declare function checkVariableLikeDeclaration(c: Checker, node: Node): void;
+export declare function checkFunctionDeclaration(c: Checker, node: Node): void;
+export declare function checkTypeParameter(c: Checker, node: Node): void;
+/** Variance annotations are only allowed on type aliases of object, function, constructor and mapped types. */
+export declare function checkTypeParameterDeferred(c: Checker, node: Node): void;
+/** Checks a type parameter list: each parameter, default ordering and duplicate names. */
+export declare function checkTypeParameters(c: Checker, list: NodeList | undefined): void;
+export declare function checkTypeAliasDeclaration(c: Checker, node: Node): void;
+/**
+ * Checks the type arguments of a type reference, an import type or a heritage type reference against the
+ * constraints of the type parameters of what it references, as tsgo's checkTypeReferenceOrImport does;
+ * not when `type`, the type of the reference, is the error type.
+ */
+export declare function checkTypeArgumentConstraintsOfReference(c: Checker, node: Node, type: Type): void;
+export declare function checkEnumMember(c: Checker, node: Node): void;
+export declare function checkEnumDeclaration(c: Checker, node: Node): void;
+/** Whether erasableSyntaxOnly applies at `node`: it is set, and `node` is in a TypeScript file. */
+export declare function shouldCheckErasableSyntax(c: Checker, node: Node): boolean;
+export declare function checkModuleDeclaration(c: Checker, node: Node): void;
+export declare function isInstantiatedModule(node: Node, preserveConstEnums: boolean): boolean;
+/** Reports `export =` mixed with other exports, and names exported by more than one declaration. */
+export declare function checkExternalModuleExports(c: Checker, node: Node): void;
+/** Reports merged declarations that mix exported and local (or default-exported) declarations. */
+export declare function checkExportsOnMergedDeclarations(c: Checker, node: Node): void;
+export declare function getEffectiveDeclarationFlags(node: Node, flagsToCheck: ModifierFlags): ModifierFlags;
+/** Reports renamings in parameters of bodiless signatures whose new names are unused. */
+export declare function checkUnusedRenamedBindingElements(c: Checker): void;