tsc-ts 0.0.4 → 0.0.5

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

@@ -0,0 +1,226 @@
+// Statements.
+import { getExpression, getStatements, getName, } from './ast.js';
+import { createDiagnosticForNode } from './checker.js';
+import { getReturnTypeFromAnnotation, getReturnTypeOfSignature, getSignatureFromDeclaration, } from './checker-signatures.js';
+import { checkExpression, checkExpressionCached, checkNonNullExpression, checkTypeAssignableToAndOptionallyElaborate, } from './checker-expressions.js';
+import { checkIteratedTypeOrElementType } from './checker-iteration.js';
+import { checkDestructuringAssignment } from './checker-destructuring.js';
+import { checkReferenceExpression, checkTestingKnownTruthyType, checkTruthinessExpression, isTypeEqualityComparableTo, } from './checker-operators.js';
+import { checkTypeComparableTo, isTypeAssignableTo } from './relations.js';
+import { isReachableFlowNode } from './checker-narrowing.js';
+import { getIndexType, isTypeAssignableToKindEx as isTypeAssignableToKind } from './checker-type-operators.js';
+import { getExtractStringType } from './checker-symbol-types.js';
+import { checkSourceElement } from './checker-source-file.js';
+import { checkVariableDeclarationList, checkVariableLikeDeclaration } from './checker-declarations.js';
+import { checkReturnExpression, isUnwrappedReturnTypeUndefinedVoidOrAny } from './checker-functions.js';
+import { unwrapReturnType } from './checker-iteration.js';
+import { getFunctionFlags, isBindingPattern } from './checker-utilities.js';
+import { getContainingFunctionOrClassStaticBlock } from './checker-grammar.js';
+import { ScriptTarget } from './options.js';
+import { checkExternalEmitHelpers } from './checker-emit-helpers.js';
+import { typeToString } from './type-printer.js';
+import { getNonNullableType, hasTypeFacts } from './checker-flow.js';
+export function checkBlock(c, node) {
+    for (const s of getStatements(node).nodes)
+        checkSourceElement(c, s);
+}
+export function checkExpressionStatement(c, node) {
+    checkExpression(c, getExpression(node));
+}
+export function checkIfStatement(c, node) {
+    const s = node;
+    const t = checkTruthinessExpression(c, s.expression, 0 /* CheckMode.Normal */);
+    checkTestingKnownTruthyType(c, s.expression, t, s.thenStatement);
+    checkSourceElement(c, s.thenStatement);
+    if (s.thenStatement.kind === 243 /* SyntaxKind.EmptyStatement */)
+        c.error(s.thenStatement, 249 /* Diagnostics.The_body_of_an_if_statement_cannot_be_the_empty_statement */);
+    checkSourceElement(c, s.elseStatement);
+}
+export function checkDoStatement(c, node) {
+    const s = node;
+    checkSourceElement(c, s.statement);
+    checkTruthinessExpression(c, s.expression, 0 /* CheckMode.Normal */);
+}
+export function checkWhileStatement(c, node) {
+    const s = node;
+    checkTruthinessExpression(c, s.expression, 0 /* CheckMode.Normal */);
+    checkSourceElement(c, s.statement);
+}
+export function checkForStatement(c, node) {
+    const s = node;
+    const initializer = s.initializer;
+    if (initializer !== undefined) {
+        if (initializer.kind === 262 /* SyntaxKind.VariableDeclarationList */)
+            checkVariableDeclarationList(c, initializer);
+        else
+            checkExpression(c, initializer);
+    }
+    if (s.condition !== undefined)
+        checkTruthinessExpression(c, s.condition, 0 /* CheckMode.Normal */);
+    if (s.incrementor !== undefined)
+        checkExpression(c, s.incrementor);
+    checkSourceElement(c, s.statement);
+}
+export function checkForInStatement(c, node) {
+    const s = node;
+    const expressionType = checkExpression(c, s.expression);
+    const rightType = hasTypeFacts(c, expressionType, 50331648 /* TypeFacts.IsUndefinedOrNull */)
+        ? getNonNullableType(c, expressionType)
+        : expressionType;
+    if (s.initializer.kind === 262 /* SyntaxKind.VariableDeclarationList */) {
+        const declarations = s.initializer.declarations.nodes;
+        if (declarations.length !== 0 && isBindingPattern(getName(declarations[0])))
+            c.error(getName(declarations[0]), 651 /* Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern */);
+        for (const d of declarations)
+            checkVariableLikeDeclaration(c, d);
+    }
+    else {
+        // The variable must be a reference that the keys of the object, as strings, are assignable to.
+        const varExpr = s.initializer;
+        const leftType = checkExpression(c, varExpr);
+        if (varExpr.kind === 210 /* SyntaxKind.ArrayLiteralExpression */ || varExpr.kind === 211 /* SyntaxKind.ObjectLiteralExpression */)
+            c.error(varExpr, 651 /* Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern */);
+        else if (!isTypeAssignableTo(c, getIndexTypeOrString(c, rightType), leftType))
+            c.error(varExpr, 576 /* Diagnostics.The_left_hand_side_of_a_for_in_statement_must_be_of_type_string_or_any */);
+        else
+            checkReferenceExpression(c, varExpr, 577 /* Diagnostics.The_left_hand_side_of_a_for_in_statement_must_be_a_variable_or_a_property_access */, 912 /* Diagnostics.The_left_hand_side_of_a_for_in_statement_may_not_be_an_optional_property_access */);
+    }
+    if ((rightType.flags & 262144 /* TypeFlags.Never */) !== 0 ||
+        !isTypeAssignableToKind(c, rightType, 131072 /* TypeFlags.NonPrimitive */ | 117964800 /* TypeFlags.InstantiableNonPrimitive */, false))
+        c.error(s.expression, 578 /* Diagnostics.The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter_but_here_has_type_0 */, typeToString(c, rightType));
+    checkSourceElement(c, s.statement);
+}
+function getIndexTypeOrString(c, t) {
+    const indexType = getExtractStringType(c, getIndexType(c, t));
+    return (indexType.flags & 262144 /* TypeFlags.Never */) !== 0 ? c.stringType : indexType;
+}
+export function checkForOfStatement(c, node) {
+    const s = node;
+    // for await..of in an async function before ES2018 uses __asyncValues.
+    if (s.awaitModifier !== undefined) {
+        const container = getContainingFunctionOrClassStaticBlock(node);
+        if ((container === undefined || container.kind !== 176 /* SyntaxKind.ClassStaticBlockDeclaration */) &&
+            (getFunctionFlags(container) & (4 /* FunctionFlags.Invalid */ | 2 /* FunctionFlags.Async */)) === 2 /* FunctionFlags.Async */ &&
+            c.languageVersion < ScriptTarget.ES2018)
+            checkExternalEmitHelpers(c, node, 256 /* ExternalEmitHelpers.ForAwaitOfIncludes */);
+    }
+    // A declaration checks the right side through its type; an expression is checked as a
+    // destructuring assignment or a reference the iterated type must be assignable to.
+    if (s.initializer.kind === 262 /* SyntaxKind.VariableDeclarationList */) {
+        for (const d of s.initializer.declarations.nodes)
+            checkVariableLikeDeclaration(c, d);
+    }
+    else {
+        const varExpr = s.initializer;
+        const iteratedType = checkRightHandSideOfForOf(c, s);
+        if (varExpr.kind === 210 /* SyntaxKind.ArrayLiteralExpression */ || varExpr.kind === 211 /* SyntaxKind.ObjectLiteralExpression */)
+            checkDestructuringAssignment(c, varExpr, iteratedType, 0 /* CheckMode.Normal */, false);
+        else {
+            const leftType = checkExpression(c, varExpr);
+            checkReferenceExpression(c, varExpr, 647 /* Diagnostics.The_left_hand_side_of_a_for_of_statement_must_be_a_variable_or_a_property_access */, 913 /* Diagnostics.The_left_hand_side_of_a_for_of_statement_may_not_be_an_optional_property_access */);
+            checkTypeAssignableToAndOptionallyElaborate(c, iteratedType, leftType, varExpr, s.expression);
+        }
+    }
+    checkSourceElement(c, s.statement);
+}
+/** The element type a `for...of` produces. */
+export function checkRightHandSideOfForOf(c, statement) {
+    const s = statement;
+    const use = s.awaitModifier !== undefined ? 15 /* IterationUse.ForAwaitOf */ : 13 /* IterationUse.ForOf */;
+    return checkIteratedTypeOrElementType(c, use, checkNonNullExpression(c, s.expression), c.undefinedType, s.expression);
+}
+export function checkReturnStatement(c, node) {
+    const s = node;
+    const container = getContainingFunction(node);
+    // Returns outside functions and in static blocks are grammar errors.
+    if (container === undefined)
+        return;
+    const signature = getSignatureFromDeclaration(c, container);
+    const returnType = getReturnTypeOfSignature(c, signature);
+    const functionFlags = getFunctionFlags(container);
+    const exprNode = s.expression;
+    if (c.strictNullChecks || exprNode !== undefined || (returnType.flags & 262144 /* TypeFlags.Never */) !== 0) {
+        const exprType = exprNode !== undefined ? checkExpressionCached(c, exprNode) : c.undefinedType;
+        if (container.kind === 179 /* SyntaxKind.SetAccessor */) {
+            if (exprNode !== undefined)
+                c.error(node, 579 /* Diagnostics.Setters_cannot_return_a_value */);
+        }
+        else if (container.kind === 177 /* SyntaxKind.Constructor */) {
+            if (exprNode !== undefined &&
+                !checkTypeAssignableToAndOptionallyElaborate(c, exprType, returnType, node, exprNode))
+                c.error(node, 580 /* Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class */);
+        }
+        else if (getReturnTypeFromAnnotation(c, container) !== undefined) {
+            const unwrappedReturnType = unwrapReturnType(c, returnType, functionFlags);
+            checkReturnExpression(c, container, unwrappedReturnType, node, exprNode, exprType, false);
+        }
+    }
+    else if (container.kind !== 177 /* SyntaxKind.Constructor */ &&
+        c.compilerOptions.noImplicitReturns === true &&
+        !isUnwrappedReturnTypeUndefinedVoidOrAny(c, container, returnType))
+        // The function has a return type, but this return statement has no expression.
+        c.error(node, 1701 /* Diagnostics.Not_all_code_paths_return_a_value */);
+}
+function getContainingFunction(node) {
+    let current = node.parent;
+    while (current !== undefined) {
+        switch (current.kind) {
+            case 263 /* SyntaxKind.FunctionDeclaration */:
+            case 219 /* SyntaxKind.FunctionExpression */:
+            case 220 /* SyntaxKind.ArrowFunction */:
+            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.SetAccessor */:
+            case 177 /* SyntaxKind.Constructor */:
+                return current;
+            case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
+            case 307 /* SyntaxKind.SourceFile */:
+                return undefined;
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
+export function checkSwitchStatement(c, node) {
+    const s = node;
+    const expressionType = checkExpression(c, s.expression);
+    for (const clause of s.caseBlock.clauses.nodes) {
+        const caseClause = clause;
+        if (caseClause.expression !== undefined) {
+            const caseType = checkExpression(c, caseClause.expression);
+            // Without equality comparability, the reversed comparison reports the error.
+            if (!isTypeEqualityComparableTo(c, expressionType, caseType))
+                checkTypeComparableTo(c, caseType, expressionType, caseClause.expression, undefined);
+        }
+        for (const statement of caseClause.statements.nodes)
+            checkSourceElement(c, statement);
+        if (c.compilerOptions.noFallthroughCasesInSwitch === true &&
+            caseClause.fallthroughFlowNode !== undefined &&
+            isReachableFlowNode(c, caseClause.fallthroughFlowNode))
+            c.error(clause, 1700 /* Diagnostics.Fallthrough_case_in_switch */);
+    }
+}
+export function checkLabeledStatement(c, node) {
+    const { label, statement } = node;
+    // The binder marks the labels that no break or continue statement references.
+    if ((label.flags & 134217728 /* NodeFlags.Unreachable */) !== 0 && c.compilerOptions.allowUnusedLabels !== true)
+        c.addErrorOrSuggestion(c.compilerOptions.allowUnusedLabels === false, createDiagnosticForNode(label, 1699 /* Diagnostics.Unused_label */, []));
+    checkSourceElement(c, statement);
+}
+export function checkThrowStatement(c, node) {
+    const expr = getExpression(node);
+    if (expr !== undefined)
+        checkExpression(c, expr);
+}
+export function checkTryStatement(c, node) {
+    const s = node;
+    checkBlock(c, s.tryBlock);
+    const catchClause = s.catchClause;
+    if (catchClause !== undefined) {
+        if (catchClause.variableDeclaration !== undefined)
+            checkVariableLikeDeclaration(c, catchClause.variableDeclaration);
+        checkBlock(c, catchClause.block);
+    }
+    if (s.finallyBlock !== undefined)
+        checkBlock(c, s.finallyBlock);
+}

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

@@ -0,0 +1,13 @@
+import { type Node } from './ast.js';
+import { type DiagnosticMessage } from './diagnostics.js';
+import type { Checker } from './checker.js';
+import { type Type } from './checker-types.js';
+/** The type of `super` in `super(...)`, `super.x` or `super[x]`, reporting where it can't be used. */
+export declare function checkSuperExpression(c: Checker, node: Node): Type;
+/** The member or function `super` at `node` belongs to. */
+export declare function getSuperContainer(node: Node, stopOnFunctions: boolean): Node | undefined;
+/** Reports `node` in a derived class constructor when it may run before `super(...)`. */
+export declare function checkThisBeforeSuper(c: Checker, node: Node, container: Node, message: DiagnosticMessage): void;
+export declare function classDeclarationExtendsNull(c: Checker, classDeclaration: Node): boolean;
+/** Reports `this` in a static property initializer of a class with legacy decorators. */
+export declare function checkThisInStaticClassFieldInitializerInDecoratedClass(c: Checker, thisExpression: Node, container: Node): void;

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

@@ -0,0 +1,241 @@
+// `super` expressions and `this` before `super(...)` in derived class constructors.
+import { ScriptTarget } from './options.js';
+import { markSuperPropertyInStaticInitializer } from './checker-generated-code.js';
+import { getExpression, getFlowNode, getInitializer, getModifiers } from './ast.js';
+import { isClassElement, isClassLike, isStatic } from './binder-utilities.js';
+import { getBranchLabelAntecedents } from './checker-narrowing.js';
+import { getBaseConstructorTypeOfClass, getBaseTypes, getDeclaredTypeOfSymbol, getExtendsHeritageClauseElement, } from './checker-declared-types.js';
+import { getTypeWithThisArgument } from './checker-members.js';
+import { getSymbolOfDeclaration } from './checker-symbols.js';
+/** The type of `super` in `super(...)`, `super.x` or `super[x]`, reporting where it can't be used. */
+export function checkSuperExpression(c, node) {
+    const parent = node.parent;
+    const isCallExpression = parent.kind === 214 /* SyntaxKind.CallExpression */ && getExpression(parent) === node;
+    const immediateContainer = getSuperContainer(node, true);
+    let container = immediateContainer;
+    // `super` property accesses in arrow functions belong to the enclosing container.
+    if (!isCallExpression)
+        while (container !== undefined && container.kind === 220 /* SyntaxKind.ArrowFunction */)
+            container = getSuperContainer(container, true);
+    if (container === undefined || !isLegalUsageOfSuperExpression(container, isCallExpression)) {
+        if (isInComputedPropertyNameBefore(node, container))
+            c.error(node, 632 /* Diagnostics.X_super_cannot_be_referenced_in_a_computed_property_name */);
+        else if (isCallExpression)
+            c.error(node, 514 /* Diagnostics.Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors */);
+        else if (container === undefined ||
+            container.parent === undefined ||
+            !(isClassLike(container.parent) || container.parent.kind === 211 /* SyntaxKind.ObjectLiteralExpression */))
+            c.error(node, 794 /* Diagnostics.X_super_can_only_be_referenced_in_members_of_derived_classes_or_object_literal_expressions */);
+        else
+            c.error(node, 515 /* Diagnostics.X_super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class */);
+        return c.errorType;
+    }
+    if (!isCallExpression && immediateContainer.kind === 177 /* SyntaxKind.Constructor */)
+        checkThisBeforeSuper(c, node, container, 1814 /* Diagnostics.X_super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class */);
+    // `super` in an object literal is `any`.
+    if (container.parent.kind === 211 /* SyntaxKind.ObjectLiteralExpression */)
+        return c.anyType;
+    const classLikeDeclaration = container.parent;
+    if (getExtendsHeritageClauseElement(classLikeDeclaration) === undefined) {
+        c.error(node, 512 /* Diagnostics.X_super_can_only_be_referenced_in_a_derived_class */);
+        return c.errorType;
+    }
+    if (classDeclarationExtendsNull(c, classLikeDeclaration))
+        return isCallExpression ? c.errorType : c.nullWideningType;
+    const symbol = getSymbolOfDeclaration(c, classLikeDeclaration);
+    if (symbol === undefined)
+        return c.errorType;
+    const classType = getDeclaredTypeOfSymbol(c, symbol);
+    const baseTypes = getBaseTypes(c, classType);
+    if (baseTypes.length === 0)
+        return c.errorType;
+    if (container.kind === 177 /* SyntaxKind.Constructor */ && isInConstructorArgumentInitializer(node, container)) {
+        c.error(node, 513 /* Diagnostics.X_super_cannot_be_referenced_in_constructor_arguments */);
+        return c.errorType;
+    }
+    if (isStatic(container) || isCallExpression) {
+        if (!isCallExpression &&
+            c.languageVersion <= ScriptTarget.ES2021 &&
+            (container.kind === 173 /* SyntaxKind.PropertyDeclaration */ || container.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */))
+            markSuperPropertyInStaticInitializer(c, node);
+        return getBaseConstructorTypeOfClass(c, classType);
+    }
+    return getTypeWithThisArgument(c, baseTypes[0], classType.thisType, false);
+}
+function isLegalUsageOfSuperExpression(container, isCallExpression) {
+    // Super calls are only permitted in constructors of derived classes.
+    if (isCallExpression)
+        return container.kind === 177 /* SyntaxKind.Constructor */;
+    // Super property accesses are permitted in members directly within a class or object literal.
+    const parent = container.parent;
+    if (parent === undefined || !(isClassLike(parent) || parent.kind === 211 /* SyntaxKind.ObjectLiteralExpression */))
+        return false;
+    switch (container.kind) {
+        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 174 /* SyntaxKind.MethodSignature */:
+        case 178 /* SyntaxKind.GetAccessor */:
+        case 179 /* SyntaxKind.SetAccessor */:
+        case 173 /* SyntaxKind.PropertyDeclaration */:
+            return true;
+        case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
+            return isStatic(container);
+        case 172 /* SyntaxKind.PropertySignature */:
+        case 177 /* SyntaxKind.Constructor */:
+            return !isStatic(container);
+    }
+    return false;
+}
+/** Whether `node` is in a computed property name below `container`. */
+function isInComputedPropertyNameBefore(node, container) {
+    for (let current = node.parent; current !== undefined && current !== container; current = current.parent)
+        if (current.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+            return true;
+    return false;
+}
+function isInConstructorArgumentInitializer(node, constructorDeclaration) {
+    for (let current = node; current !== undefined; current = current.parent) {
+        if (isFunctionLikeDeclarationKind(current.kind))
+            return false;
+        if (current.kind === 170 /* SyntaxKind.Parameter */ && current.parent === constructorDeclaration)
+            return true;
+    }
+    return false;
+}
+function isFunctionLikeDeclarationKind(kind) {
+    switch (kind) {
+        case 263 /* SyntaxKind.FunctionDeclaration */:
+        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 177 /* SyntaxKind.Constructor */:
+        case 178 /* SyntaxKind.GetAccessor */:
+        case 179 /* SyntaxKind.SetAccessor */:
+        case 219 /* SyntaxKind.FunctionExpression */:
+        case 220 /* SyntaxKind.ArrowFunction */:
+            return true;
+    }
+    return false;
+}
+/** The member or function `super` at `node` belongs to. */
+export function getSuperContainer(node, stopOnFunctions) {
+    for (let current = node.parent; current !== undefined; current = current.parent) {
+        switch (current.kind) {
+            case 168 /* SyntaxKind.ComputedPropertyName */:
+                current = current.parent;
+                break;
+            case 263 /* SyntaxKind.FunctionDeclaration */:
+            case 219 /* SyntaxKind.FunctionExpression */:
+            case 220 /* SyntaxKind.ArrowFunction */:
+                if (stopOnFunctions)
+                    return current;
+                break;
+            case 173 /* SyntaxKind.PropertyDeclaration */:
+            case 172 /* SyntaxKind.PropertySignature */:
+            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 174 /* SyntaxKind.MethodSignature */:
+            case 177 /* SyntaxKind.Constructor */:
+            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.SetAccessor */:
+            case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
+                return current;
+            case 171 /* SyntaxKind.Decorator */: {
+                // Decorators are applied outside the body of their class or method.
+                const decorated = current.parent;
+                if (decorated.kind === 170 /* SyntaxKind.Parameter */ && isClassElement(decorated.parent))
+                    current = decorated.parent;
+                else if (isClassElement(decorated))
+                    current = decorated;
+                break;
+            }
+        }
+    }
+    return undefined;
+}
+/** Reports `node` in a derived class constructor when it may run before `super(...)`. */
+export function checkThisBeforeSuper(c, node, container, message) {
+    const containingClassDeclaration = container.parent;
+    // Classes without `extends`, or extending `null`, don't call `super`.
+    if (getExtendsHeritageClauseElement(containingClassDeclaration) === undefined)
+        return;
+    if (classDeclarationExtendsNull(c, containingClassDeclaration))
+        return;
+    const flow = getFlowNode(node);
+    if (flow !== undefined && !isPostSuperFlowNode(c, flow, false))
+        c.error(node, message);
+}
+export function classDeclarationExtendsNull(c, classDeclaration) {
+    const symbol = getSymbolOfDeclaration(c, classDeclaration);
+    if (symbol === undefined)
+        return false;
+    const classType = getDeclaredTypeOfSymbol(c, symbol);
+    if ((classType.objectFlags & 3 /* ObjectFlags.ClassOrInterface */) === 0 || (classType.flags & 1048576 /* TypeFlags.Object */) === 0)
+        return false;
+    return getBaseConstructorTypeOfClass(c, classType) === c.nullWideningType;
+}
+/** Whether every path to `start` passes a `super(...)` call. */
+function isPostSuperFlowNode(c, start, noCacheCheckIn) {
+    let flow = start;
+    let noCacheCheck = noCacheCheckIn;
+    for (;;) {
+        const flags = flow.flags;
+        if ((flags & 4096 /* FlowFlags.Shared */) !== 0) {
+            if (!noCacheCheck) {
+                const cached = c.flowNodePostSuper.get(flow);
+                if (cached !== undefined)
+                    return cached;
+                const postSuper = isPostSuperFlowNode(c, flow, true);
+                c.flowNodePostSuper.set(flow, postSuper);
+                return postSuper;
+            }
+            noCacheCheck = false;
+        }
+        if ((flags & (16 /* FlowFlags.Assignment */ | 96 /* FlowFlags.Condition */ | 256 /* FlowFlags.ArrayMutation */ | 128 /* FlowFlags.SwitchClause */)) !== 0)
+            flow = flow.antecedent;
+        else if ((flags & 512 /* FlowFlags.Call */) !== 0) {
+            if (getExpression(flow.node).kind === 107 /* SyntaxKind.SuperKeyword */)
+                return true;
+            flow = flow.antecedent;
+        }
+        else if ((flags & 4 /* FlowFlags.BranchLabel */) !== 0) {
+            for (const antecedent of getBranchLabelAntecedents(c, flow))
+                if (!isPostSuperFlowNode(c, antecedent, false))
+                    return false;
+            return true;
+        }
+        else if ((flags & 8 /* FlowFlags.LoopLabel */) !== 0) {
+            // A loop is post-super when the path into its top is.
+            flow = flow.antecedents[0];
+        }
+        else if ((flags & 1024 /* FlowFlags.ReduceLabel */) !== 0) {
+            c.flowReduceLabels.push(flow);
+            const result = isPostSuperFlowNode(c, flow.antecedent, false);
+            c.flowReduceLabels.pop();
+            return result;
+        }
+        // Unreachable nodes count as post-super to silence errors.
+        else
+            return (flags & 1 /* FlowFlags.Unreachable */) !== 0;
+    }
+}
+/** Reports `this` in a static property initializer of a class with legacy decorators. */
+export function checkThisInStaticClassFieldInitializerInDecoratedClass(c, thisExpression, container) {
+    if (container.kind !== 173 /* SyntaxKind.PropertyDeclaration */ || !isStatic(container) || !c.legacyDecorators)
+        return;
+    const initializer = getInitializer(container);
+    if (initializer !== undefined &&
+        initializer.pos <= thisExpression.pos &&
+        thisExpression.pos <= initializer.end &&
+        hasDecoratorModifier(container.parent))
+        c.error(thisExpression, 947 /* Diagnostics.Cannot_use_this_in_a_static_property_initializer_of_a_decorated_class */);
+}
+function hasDecoratorModifier(node) {
+    const modifiers = getModifiersOf(node);
+    if (modifiers === undefined)
+        return false;
+    for (const modifier of modifiers)
+        if (modifier.kind === 171 /* SyntaxKind.Decorator */)
+            return true;
+    return false;
+}
+function getModifiersOf(node) {
+    const list = getModifiers(node);
+    return list !== undefined ? list.nodes : undefined;
+}

package/dist/api/compiler/checker-symbol-types.d.ts

@@ -0,0 +1,67 @@
+import { CheckMode } from './checker-types.js';
+import { type Node, type SourceFile } from './ast.js';
+import { hasStaticModifier } from './binder-utilities.js';
+import { type Symbol } from './symbol.js';
+import { type Checker } from './checker.js';
+import { type Type, TypeFlags, type UnionType } from './checker-types.js';
+import { filterType } from './checker-type-factory.js';
+import { getDeclarationOfAliasSymbol } from './checker-symbols.js';
+export declare function getTypeOfSymbol(c: Checker, symbol: Symbol): Type;
+export declare function getTypeOfParameter(c: Checker, symbol: Symbol): Type;
+export declare function getNonMissingTypeOfSymbol(c: Checker, symbol: Symbol): Type;
+export declare function getWriteTypeOfSymbol(c: Checker, symbol: Symbol): Type;
+export declare function getWidenedTypeForVariableLikeDeclaration(c: Checker, declaration: Node, reportErrors: boolean): Type;
+/** Whether a parameter, property or method is declared with `?`. */
+export declare function isOptionalDeclaration(node: Node): boolean;
+/** The declared or inferred type of a variable-like declaration; undefined when nothing can be inferred. */
+export declare function getTypeForVariableLikeDeclaration(c: Checker, declaration: Node, includeOptionality: boolean, checkMode?: CheckMode): Type | undefined;
+export declare function widenTypeInferredFromInitializer(c: Checker, declaration: Node, t: Type): Type;
+export declare function getWidenedLiteralTypeForInitializer(c: Checker, declaration: Node, t: Type): Type;
+export declare function widenTypeForVariableLikeDeclaration(c: Checker, t: Type | undefined, declaration: Node, reportErrors: boolean): Type;
+export declare function declarationBelongsToPrivateAmbientMember(declaration: Node): boolean;
+export declare function isPrivateWithinAmbient(node: Node): boolean;
+/** What a widened type is the type of, for the implicit any messages. */
+export declare const enum WideningKind {
+    Normal = 0,
+    FunctionReturn = 1,
+    GeneratorNext = 2,
+    GeneratorYield = 3
+}
+/**
+ * Implicit-any widening of null/undefined, which strictNullChecks avoids. A function's inferred
+ * types report it only without a contextual signature, or when the contextual type is generic.
+ */
+export declare function reportErrorsFromWidening(c: Checker, declaration: Node, t: Type, wideningKind: WideningKind): void;
+export declare function reportImplicitAny(c: Checker, declaration: Node, t: Type, wideningKind?: WideningKind): void;
+export declare function getWidenedType(c: Checker, t: Type): Type;
+/**
+ * By name, the first property of the unions of `file`'s object literals that leave the name missing.
+ * Without a checker, as on a parse thread, array literals are taken to have the global Array type, and
+ * the result is undefined where an enum the scan can't resolve decides which literals subtype reduction
+ * leaves out (`enumKeyOfMemberAccess`); the checker then scans the file itself.
+ */
+export declare function scanSiblingProperties(file: SourceFile, c: Checker | undefined): Map<string, Node> | undefined;
+/** The first property of each name among the files of one of tsgo's checkers, scanned in order. */
+export declare class SlotSiblingProperties {
+    readonly members: Map<string, Node>;
+    /** The index of the file of each name's property. */
+    readonly fileIndexes: Map<string, number>;
+    /** The index of the next file of the checker to scan. */
+    next: number;
+    constructor(first: number);
+}
+export declare function addOptionality(c: Checker, t: Type, isProperty: boolean, isOptional: boolean): Type;
+export declare function getOptionalType(c: Checker, t: Type, isProperty: boolean): Type;
+export declare function addOptionalTypeMarker(c: Checker, t: Type): Type;
+export declare function removeOptionalTypeMarker(c: Checker, t: Type): Type;
+export declare function removeMissingType(c: Checker, t: Type, isOptional: boolean): Type;
+export declare function removeMissingOrUndefinedType(c: Checker, t: Type): Type;
+export declare function getNullableType(c: Checker, t: Type, flags: TypeFlags): Type;
+export declare function isReadonlySymbol(c: Checker, symbol: Symbol): boolean;
+export declare function getAnnotatedAccessorTypeNode(accessor: Node | undefined): Node | undefined;
+export declare function getWriteTypeOfAccessors(c: Checker, symbol: Symbol): Type;
+export declare function getBaseTypeVariableOfClass(c: Checker, symbol: Symbol): Type | undefined;
+export { getDeclarationOfAliasSymbol, filterType, hasStaticModifier };
+export type { UnionType };
+/** `Extract<t, string>`, or string without the global `Extract`. */
+export declare function getExtractStringType(c: Checker, t: Type): Type;