tsc-ts 0.0.4 → 0.0.6

package/dist/api/compiler/checker-source-file.d.ts

@@ -0,0 +1,27 @@
+import { type Node, NodeVisitor, type SourceFile } from './ast.js';
+import type { Checker } from './checker.js';
+/**
+ * Checks `file` once; diagnostics accumulate in the checker. `checkUnused` also reports unused
+ * identifiers, which need the whole file checked first.
+ */
+export declare function checkSourceFile(c: Checker, file: SourceFile, checkUnused?: boolean): void;
+/** Checks a statement, declaration, class member or type node. */
+export declare function checkSourceElement(c: Checker, node: Node | undefined): void;
+/** Resolves the `@link` names of a node's JSDoc, which marks what they name referenced. */
+export declare function checkJSDocLinksOfNode(c: Checker, node: Node): void;
+/** Resolves every type reference in a type annotation, reporting unresolved names and constraint errors. */
+export declare function checkTypeNodeIfPresent(c: Checker, node: Node | undefined): void;
+/** Visits the children of a type node; owned by the checker to avoid per-node allocation. */
+export declare class TypeNodeVisitor extends NodeVisitor {
+    readonly c: Checker;
+    constructor(c: Checker);
+    visitNode(node: Node): boolean;
+}
+/**
+ * Queues a function expression, arrow, accessor, class expression or other deferred node to check with
+ * its file, like tsgo: nodes wait in the links of their own source file and are checked when that file
+ * is checked, and nodes of files this checker has already checked are not queued again. Checking one
+ * file often defers nodes of others (inferring a function's return type checks its body), and those
+ * belong to whichever checker checks the other file.
+ */
+export declare function checkNodeDeferred(c: Checker, node: Node): void;

package/dist/api/compiler/checker-source-file.js

@@ -0,0 +1,619 @@
+// File-level checking: `checkSourceFile`, the statement/declaration dispatch and deferred checks.
+//
+// Extension points, by syntactic area:
+// - statements: checker-statements.ts (`checkBlock`, `checkIfStatement`, ...)
+// - declarations: checker-declarations.ts (variables, functions, aliases, enums, namespaces)
+// - imports and exports: checker-modules.ts
+// - classes and interfaces: checker-classes.ts
+// - expressions: checker-expressions.ts (`checkExpression`), calls in checker-calls.ts
+// - JSX: checker-jsx.ts
+// - grammar: checker-grammar.ts (checks the parser leaves to the checker)
+// - type nodes: `checkTypeNode` below
+import { checkPendingExternalEmitHelpers } from './checker-emit-helpers.js';
+import { produceDeferredCollisionChecks } from './checker-generated-code.js';
+import { resolveUntypedCall } from './checker-calls.js';
+import { NodeVisitor, getComment, getElements, getExpression, getName, getParameters, getText, getNodeId, getStatements, getType, getTypeParameters, getHeritageClauses, getFlowNode, } from './ast.js';
+import { getSourceFileOfNode, isEnumConst, isExternalOrCommonJSModule, isPotentiallyExecutableNode, } from './binder-utilities.js';
+import { getSignatureFromDeclaration, getTypePredicateOfSignature } from './checker-signatures.js';
+import { getConstraintTypeFromMappedType, getNameTypeFromMappedType } from './checker-type-operators.js';
+import { checkTypeAssignableTo, checkTypeRelatedTo } from './relations.js';
+import { Diagnostic, chainDiagnostic } from './diagnostics.js';
+import { skipTrivia } from './scanner.js';
+import { nodeIsMissing } from './ast-utilities.js';
+import { getAttachedJSDoc } from './parser.js';
+import { shouldPreserveConstEnums } from './options.js';
+import { isReachableFlowNode } from './checker-narrowing.js';
+import { getTupleElementFlags, getTypeFromIndexedAccessTypeNode, getTypeFromTypeNode } from './checker-type-nodes.js';
+import { isArrayLikeType } from './checker-members.js';
+import { checkBlock, checkDoStatement, checkExpressionStatement, checkForInStatement, checkForOfStatement, checkForStatement, checkIfStatement, checkLabeledStatement, checkReturnStatement, checkSwitchStatement, checkThrowStatement, checkTryStatement, checkWhileStatement, } from './checker-statements.js';
+import { checkEnumDeclaration, checkEnumMember, checkExternalModuleExports, checkFunctionDeclaration, checkModuleDeclaration, checkTypeAliasDeclaration, checkTypeArgumentConstraintsOfReference, checkTypeParameter, checkTypeParameterDeferred, checkTypeParameters, checkVariableStatement, checkVariableLikeDeclaration, checkUnusedRenamedBindingElements, isInstantiatedModule, } from './checker-declarations.js';
+import { checkExportAssignment, checkExportDeclaration, checkImportDeclaration, checkImportEqualsDeclaration, resolveJSDocMemberName, } from './checker-modules.js';
+import { checkAccessorDeclaration, checkClassDeclaration, checkClassLikeDeferred, checkInterfaceDeclaration, } from './checker-classes.js';
+import { checkJsxElementDeferred } from './checker-jsx.js';
+import { checkAssertionDeferred, checkComputedPropertyName, checkExpression, checkIndexedAccessIndexType, } from './checker-expressions.js';
+import { checkFunctionLikeBody } from './checker-functions.js';
+import { produceDeferredIterationErrors } from './checker-iteration.js';
+import { checkFunctionOrMethodSymbols } from './checker-overloads.js';
+import { checkInferTypeParameterDeclarations, checkTypeLiteralMembers } from './checker-heritage.js';
+import { checkGrammarSourceFile } from './checker-grammar.js';
+import { getTypeOfSymbol, reportImplicitAny } from './checker-symbol-types.js';
+import { getSymbolOfDeclaration } from './checker-symbols.js';
+import { checkUnusedIdentifiers } from './checker-unused.js';
+import { checkDeprecatedTypeReference } from './checker-deprecation.js';
+/**
+ * Checks `file` once; diagnostics accumulate in the checker. `checkUnused` also reports unused
+ * identifiers, which need the whole file checked first.
+ */
+export function checkSourceFile(c, file, checkUnused = false) {
+    const links = c.nodeLinks(file);
+    if ((links.flags & 1 /* NodeCheckFlags.TypeChecked */) === 0) {
+        links.flags |= 1 /* NodeCheckFlags.TypeChecked */;
+        checkSourceFileWorker(c, file);
+    }
+    if (checkUnused && (links.flags & 2 /* NodeCheckFlags.UnusedChecked */) === 0) {
+        links.flags |= 2 /* NodeCheckFlags.UnusedChecked */;
+        checkUnusedIdentifiers(c, file);
+    }
+}
+function checkSourceFileWorker(c, file) {
+    c.fileBeingChecked = file;
+    c.saveDeferredDiagnostics = true;
+    for (const statement of getStatements(file).nodes)
+        checkSourceElement(c, statement);
+    checkDeferredNodes(c, file);
+    if (isExternalOrCommonJSModule(file))
+        checkExternalModuleExports(c, file);
+    if (!file.isDeclarationFile)
+        checkUnusedRenamedBindingElements(c);
+    else
+        c.renamedBindingElementsInTypes.length = 0;
+    // Grammar checks run last so the types they need are created in tsgo's order.
+    checkGrammarSourceFile(c, file);
+    // Expressions first checked by grammar checks may defer more nodes.
+    checkDeferredNodes(c, file);
+    checkPendingExternalEmitHelpers(c, file);
+    c.fileBeingChecked = undefined;
+    c.saveDeferredDiagnostics = false;
+    produceDeferredIterationErrors(c);
+    produceDeferredCollisionChecks(c);
+    // The file's deferred nodes are all checked; later ones are not queued (checkNodeDeferred).
+    const links = c.nodeLinks(file);
+    links.typeChecked = true;
+    links.deferredNodes = undefined;
+}
+/** Checks a statement, declaration, class member or type node. */
+export function checkSourceElement(c, node) {
+    if (node === undefined)
+        return;
+    const saveCurrentNode = c.currentNode;
+    const saveWithinUnreachableCode = c.withinUnreachableCode;
+    c.currentNode = node;
+    c.instantiationCount = 0;
+    checkSourceElementWorker(c, node);
+    c.currentNode = saveCurrentNode;
+    c.withinUnreachableCode = saveWithinUnreachableCode;
+}
+/** Reports a statement that can't be reached, with the unreachable statements after it. */
+function checkSourceElementUnreachable(c, node) {
+    if (!isPotentiallyExecutableNode(node))
+        return false;
+    if (c.reportedUnreachableNodes.has(node))
+        return true;
+    if (!isSourceElementUnreachable(c, node))
+        return false;
+    c.reportedUnreachableNodes.add(node);
+    const file = getSourceFileOfNode(node);
+    let endNode = node;
+    const parent = node.parent;
+    const statements = getStatements(parent)?.nodes;
+    if (statements !== undefined) {
+        const offset = statements.indexOf(node);
+        if (offset >= 0)
+            for (let i = offset + 1; i < statements.length; i++) {
+                const next = statements[i];
+                if (!isPotentiallyExecutableNode(next) || !isSourceElementUnreachable(c, next))
+                    break;
+                endNode = next;
+                c.reportedUnreachableNodes.add(next);
+            }
+    }
+    // A missing statement starts where it ends, before the trivia of the next token.
+    const start = nodeIsMissing(node) ? node.pos : skipTrivia(file.text, node.pos);
+    const diagnostic = new Diagnostic(file.diagnosticFile(), start, endNode.end, 1698 /* Diagnostics.Unreachable_code_detected */, []);
+    c.addErrorOrSuggestion(c.compilerOptions.allowUnreachableCode === false, diagnostic);
+    return true;
+}
+function isSourceElementUnreachable(c, node) {
+    if ((node.flags & 134217728 /* NodeFlags.Unreachable */) !== 0) {
+        // The binder knows the code is unreachable; const enums only count when preserved.
+        if (node.kind === 267 /* SyntaxKind.EnumDeclaration */)
+            return !isEnumConst(node) || shouldPreserveConstEnums(c.compilerOptions);
+        if (node.kind === 268 /* SyntaxKind.ModuleDeclaration */)
+            return isInstantiatedModule(node, shouldPreserveConstEnums(c.compilerOptions));
+        return true;
+    }
+    // Otherwise control flow decides, through assertion calls for example.
+    const flowNode = getFlowNode(node);
+    return flowNode !== undefined && !isReachableFlowNode(c, flowNode);
+}
+/** Resolves the `@link` names of a node's JSDoc, which marks what they name referenced. */
+export function checkJSDocLinksOfNode(c, node) {
+    const jsDoc = getAttachedJSDoc(node);
+    if (jsDoc !== undefined)
+        for (const d of jsDoc)
+            checkJSDocLinks(c, d);
+}
+function checkSourceElementWorker(c, node) {
+    checkJSDocLinksOfNode(c, node);
+    if (!c.withinUnreachableCode &&
+        c.compilerOptions.allowUnreachableCode !== true &&
+        checkSourceElementUnreachable(c, node))
+        c.withinUnreachableCode = true;
+    switch (node.kind) {
+        // Statements
+        case 242 /* SyntaxKind.Block */:
+        case 269 /* SyntaxKind.ModuleBlock */:
+            checkBlock(c, node);
+            return;
+        case 243 /* SyntaxKind.EmptyStatement */:
+        case 260 /* SyntaxKind.DebuggerStatement */:
+        case 253 /* SyntaxKind.BreakStatement */:
+        case 252 /* SyntaxKind.ContinueStatement */:
+            return;
+        case 244 /* SyntaxKind.VariableStatement */:
+            checkVariableStatement(c, node);
+            return;
+        case 245 /* SyntaxKind.ExpressionStatement */:
+            checkExpressionStatement(c, node);
+            return;
+        case 246 /* SyntaxKind.IfStatement */:
+            checkIfStatement(c, node);
+            return;
+        case 247 /* SyntaxKind.DoStatement */:
+            checkDoStatement(c, node);
+            return;
+        case 248 /* SyntaxKind.WhileStatement */:
+            checkWhileStatement(c, node);
+            return;
+        case 249 /* SyntaxKind.ForStatement */:
+            checkForStatement(c, node);
+            return;
+        case 250 /* SyntaxKind.ForInStatement */:
+            checkForInStatement(c, node);
+            return;
+        case 251 /* SyntaxKind.ForOfStatement */:
+            checkForOfStatement(c, node);
+            return;
+        case 254 /* SyntaxKind.ReturnStatement */:
+            checkReturnStatement(c, node);
+            return;
+        case 256 /* SyntaxKind.SwitchStatement */:
+            checkSwitchStatement(c, node);
+            return;
+        case 257 /* SyntaxKind.LabeledStatement */:
+            checkLabeledStatement(c, node);
+            return;
+        case 258 /* SyntaxKind.ThrowStatement */:
+            checkThrowStatement(c, node);
+            return;
+        case 259 /* SyntaxKind.TryStatement */:
+            checkTryStatement(c, node);
+            return;
+        case 255 /* SyntaxKind.WithStatement */:
+            // The body isn't checked: every name in it has type `any`.
+            checkExpression(c, getExpression(node));
+            return;
+        // Declarations
+        case 263 /* SyntaxKind.FunctionDeclaration */:
+            checkFunctionDeclaration(c, node);
+            return;
+        case 264 /* SyntaxKind.ClassDeclaration */:
+            checkClassDeclaration(c, node);
+            return;
+        case 265 /* SyntaxKind.InterfaceDeclaration */:
+            checkInterfaceDeclaration(c, node);
+            return;
+        case 266 /* SyntaxKind.TypeAliasDeclaration */:
+        case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+            checkTypeAliasDeclaration(c, node);
+            return;
+        case 267 /* SyntaxKind.EnumDeclaration */:
+            checkEnumDeclaration(c, node);
+            return;
+        case 306 /* SyntaxKind.EnumMember */:
+            checkEnumMember(c, node);
+            return;
+        case 268 /* SyntaxKind.ModuleDeclaration */:
+            checkModuleDeclaration(c, node);
+            return;
+        case 273 /* SyntaxKind.ImportDeclaration */:
+        case 346 /* SyntaxKind.JSImportDeclaration */:
+            checkImportDeclaration(c, node);
+            return;
+        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+            checkImportEqualsDeclaration(c, node);
+            return;
+        case 279 /* SyntaxKind.ExportDeclaration */:
+            checkExportDeclaration(c, node);
+            return;
+        case 278 /* SyntaxKind.ExportAssignment */:
+            checkExportAssignment(c, node);
+            return;
+        case 271 /* SyntaxKind.NamespaceExportDeclaration */:
+        case 283 /* SyntaxKind.MissingDeclaration */:
+            return;
+        case 169 /* SyntaxKind.TypeParameter */:
+            checkTypeParameter(c, node);
+            return;
+    }
+    checkTypeNode(c, node);
+}
+// ---- JSDoc
+/** Resolves the names of `{@link}` tags in a JSDoc comment and its tags, which references them. */
+function checkJSDocLinks(c, jsDoc) {
+    checkJSDocCommentLinks(c, getComment(jsDoc));
+    const tags = jsDoc.kind === 315 /* SyntaxKind.JSDoc */ ? jsDoc.tags : undefined;
+    if (tags !== undefined)
+        for (const tag of tags.nodes)
+            checkJSDocCommentLinks(c, getComment(tag));
+}
+function checkJSDocCommentLinks(c, comments) {
+    if (comments === undefined)
+        return;
+    for (const comment of comments.nodes)
+        if (comment.kind === 319 /* SyntaxKind.JSDocLink */ ||
+            comment.kind === 320 /* SyntaxKind.JSDocLinkCode */ ||
+            comment.kind === 321 /* SyntaxKind.JSDocLinkPlain */)
+            resolveJSDocMemberName(c, getName(comment));
+}
+// ---- Type nodes
+/** Resolves every type reference in a type annotation, reporting unresolved names and constraint errors. */
+export function checkTypeNodeIfPresent(c, node) {
+    if (node !== undefined)
+        checkTypeNode(c, node);
+}
+/** Implicit `any` return types of signatures without annotations. */
+function checkSignatureMember(c, node) {
+    if (getType(node) !== undefined || !c.noImplicitAny)
+        return;
+    if (node.kind === 174 /* SyntaxKind.MethodSignature */)
+        reportImplicitAny(c, node, c.anyType);
+    else if (node.kind === 180 /* SyntaxKind.CallSignature */)
+        c.error(node, 1692 /* Diagnostics.Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type */);
+    else
+        c.error(node, 1685 /* Diagnostics.Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type */);
+}
+function checkTypeNode(c, node) {
+    const saveCurrentNode = c.currentNode;
+    c.currentNode = node;
+    c.instantiationCount = 0;
+    checkTypeNodeWorker(c, node);
+    c.currentNode = saveCurrentNode;
+}
+function isTypeReferenceHeritageElement(node) {
+    const clause = node.parent;
+    if (clause === undefined || clause.kind !== 299 /* SyntaxKind.HeritageClause */)
+        return false;
+    const token = clause.token;
+    if ((token === 118 /* SyntaxKind.ImplementsKeyword */) === (clause.parent.kind === 265 /* SyntaxKind.InterfaceDeclaration */))
+        return false;
+    // Only the first clause of each kind counts.
+    for (const other of getHeritageClauses(clause.parent).nodes)
+        if (other.token === token)
+            return other === clause;
+    return false;
+}
+function checkTypeNodeWorker(c, node) {
+    switch (node.kind) {
+        case 183 /* SyntaxKind.TypePredicate */:
+            checkTypePredicate(c, node);
+            return;
+        case 174 /* SyntaxKind.MethodSignature */:
+        case 180 /* SyntaxKind.CallSignature */:
+        case 181 /* SyntaxKind.ConstructSignature */: {
+            checkTypeParameters(c, getTypeParameters(node));
+            checkSignatureMember(c, node);
+            const name = getName(node);
+            if (name !== undefined && name.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+                checkComputedPropertyName(c, name);
+            break;
+        }
+        case 185 /* SyntaxKind.FunctionType */:
+        case 186 /* SyntaxKind.ConstructorType */:
+            checkTypeParameters(c, getTypeParameters(node));
+            break;
+        case 184 /* SyntaxKind.TypeReference */:
+        case 206 /* SyntaxKind.ImportType */: {
+            const type = getTypeFromTypeNode(c, node);
+            checkTypeArgumentConstraintsOfReference(c, node, type);
+            checkDeprecatedTypeReference(c, node, type);
+            break;
+        }
+        case 200 /* SyntaxKind.IndexedAccessType */:
+            // The indexed access type itself, not the substitution type of a conditional type's true branch.
+            checkIndexedAccessIndexType(c, getTypeFromIndexedAccessTypeNode(c, node), node);
+            break;
+        case 190 /* SyntaxKind.TupleType */:
+            checkTupleRestElements(c, node);
+            getTypeFromTypeNode(c, node);
+        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+            // Implemented types and interface base types are type references; class base types are
+            // checked with the base constructor's type parameters.
+            if (isTypeReferenceHeritageElement(node))
+                checkTypeArgumentConstraintsOfReference(c, node, getTypeFromTypeNode(c, node));
+            break;
+        case 187 /* SyntaxKind.TypeQuery */:
+        case 199 /* SyntaxKind.TypeOperator */:
+        case 202 /* SyntaxKind.LiteralType */:
+        case 198 /* SyntaxKind.ThisType */:
+            getTypeFromTypeNode(c, node);
+            break;
+    }
+    // Type arguments of an import type are only resolved with its type.
+    if (node.kind === 206 /* SyntaxKind.ImportType */) {
+        checkTypeNode(c, node.argument);
+        return;
+    }
+    // Type arguments of a type query are checked with its type.
+    if (node.kind === 187 /* SyntaxKind.TypeQuery */)
+        return;
+    if (node.kind === 201 /* SyntaxKind.MappedType */) {
+        checkMappedType(c, node);
+        return;
+    }
+    if (node.kind === 204 /* SyntaxKind.TemplateLiteralType */) {
+        checkTemplateLiteralType(c, node);
+        return;
+    }
+    node.forEachChild(c.typeNodeVisitor);
+    // Unions and intersections are resolved after their constituents.
+    if (node.kind === 193 /* SyntaxKind.UnionType */ || node.kind === 194 /* SyntaxKind.IntersectionType */)
+        getTypeFromTypeNode(c, node);
+    if (node.kind === 174 /* SyntaxKind.MethodSignature */)
+        checkFunctionOrMethodSymbols(c, node);
+    else if (node.kind === 188 /* SyntaxKind.TypeLiteral */)
+        checkTypeLiteralMembers(c, node);
+}
+/** Checks that each span of a template literal type can be written in a template, then its type. */
+function checkTemplateLiteralType(c, node) {
+    for (const span of node.templateSpans.nodes) {
+        const spanType = span.type;
+        checkTypeNode(c, spanType);
+        checkTypeAssignableTo(c, getTypeFromTypeNode(c, spanType), c.templateConstraintType, spanType, undefined);
+    }
+    getTypeFromTypeNode(c, node);
+}
+/** Checks a mapped type's parts before its type, which resolves the constraint eagerly. */
+function checkMappedType(c, node) {
+    checkTypeParameter(c, node.typeParameter);
+    checkTypeNodeIfPresent(c, node.nameType);
+    checkTypeNodeIfPresent(c, node.type);
+    if (node.type === undefined)
+        reportImplicitAny(c, node, c.anyType);
+    const t = getTypeFromTypeNode(c, node);
+    const nameType = getNameTypeFromMappedType(c, t);
+    if (nameType !== undefined)
+        checkTypeAssignableTo(c, nameType, c.stringNumberSymbolType, node.nameType, undefined);
+    else
+        checkTypeAssignableTo(c, getConstraintTypeFromMappedType(c, t), c.stringNumberSymbolType, node.typeParameter.constraint, undefined);
+}
+function checkTypePredicate(c, node) {
+    const parent = getTypePredicateParent(node);
+    if (parent === undefined) {
+        c.error(node, 178 /* Diagnostics.A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods */);
+        return;
+    }
+    const signature = getSignatureFromDeclaration(c, parent);
+    const typePredicate = getTypePredicateOfSignature(c, signature);
+    if (typePredicate === undefined)
+        return;
+    checkTypeNodeIfPresent(c, node.type);
+    if (typePredicate.kind === 0 /* TypePredicateKind.This */ || typePredicate.kind === 2 /* TypePredicateKind.AssertsThis */)
+        return;
+    const parameterName = node.parameterName;
+    if (typePredicate.parameterIndex >= 0) {
+        if (signature.hasRestParameter() && typePredicate.parameterIndex === signature.parameters.length - 1)
+            c.error(parameterName, 179 /* Diagnostics.A_type_predicate_cannot_reference_a_rest_parameter */);
+        else if (typePredicate.type !== undefined) {
+            const diagnostics = [];
+            if (!checkTypeRelatedTo(c, typePredicate.type, getTypeOfSymbol(c, signature.parameters[typePredicate.parameterIndex]), c.assignableRelation, node.type, undefined, diagnostics))
+                c.addDiagnostic(chainDiagnostic(diagnostics[0], 811 /* Diagnostics.A_type_predicate_s_type_must_be_assignable_to_its_parameter_s_type */));
+        }
+        return;
+    }
+    for (const param of getParameters(parent).nodes) {
+        const name = getName(param);
+        if ((name.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 208 /* SyntaxKind.ArrayBindingPattern */) &&
+            checkIfTypePredicateVariableIsDeclaredInBindingPattern(c, name, parameterName, typePredicate.parameterName))
+            return;
+    }
+    c.error(parameterName, 175 /* Diagnostics.Cannot_find_parameter_0 */, typePredicate.parameterName);
+}
+/** The signature whose return type is the type predicate, if it is in a valid position. */
+function getTypePredicateParent(node) {
+    const parent = node.parent;
+    switch (parent.kind) {
+        case 220 /* SyntaxKind.ArrowFunction */:
+        case 180 /* SyntaxKind.CallSignature */:
+        case 263 /* SyntaxKind.FunctionDeclaration */:
+        case 219 /* SyntaxKind.FunctionExpression */:
+        case 185 /* SyntaxKind.FunctionType */:
+        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 174 /* SyntaxKind.MethodSignature */:
+            if (getType(parent) === node)
+                return parent;
+    }
+    return undefined;
+}
+function checkIfTypePredicateVariableIsDeclaredInBindingPattern(c, pattern, predicateVariableNode, predicateVariableName) {
+    for (const element of getElements(pattern).nodes) {
+        const name = getName(element);
+        if (name === undefined)
+            continue;
+        if (name.kind === 79 /* SyntaxKind.Identifier */ && getText(name) === predicateVariableName) {
+            c.error(predicateVariableNode, 180 /* Diagnostics.A_type_predicate_cannot_reference_element_0_in_a_binding_pattern */, predicateVariableName);
+            return true;
+        }
+        if ((name.kind === 208 /* SyntaxKind.ArrayBindingPattern */ || name.kind === 207 /* SyntaxKind.ObjectBindingPattern */) &&
+            checkIfTypePredicateVariableIsDeclaredInBindingPattern(c, name, predicateVariableNode, predicateVariableName))
+            return true;
+    }
+    return false;
+}
+/** Checks an accessor of a type literal or interface. */
+function checkTypeMemberAccessor(c, node) {
+    const name = getName(node);
+    if (name !== undefined && name.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+        checkComputedPropertyName(c, name);
+    const symbol = getSymbolOfDeclaration(c, node);
+    if (symbol !== undefined)
+        getTypeOfSymbol(c, symbol);
+    checkFunctionLikeBody(c, node);
+    checkAccessorDeclaration(c, node);
+}
+/** Variadic tuple elements must be array-like. */
+function checkTupleRestElements(c, node) {
+    for (const e of node.elements.nodes) {
+        if ((getTupleElementFlags(c, e) & 8 /* ElementFlags.Variadic */) === 0)
+            continue;
+        if (!isArrayLikeType(c, getTypeFromTypeNode(c, getType(e)))) {
+            c.error(e, 725 /* Diagnostics.A_rest_element_type_must_be_an_array_type */);
+            return;
+        }
+    }
+}
+/** Visits the children of a type node; owned by the checker to avoid per-node allocation. */
+export class TypeNodeVisitor extends NodeVisitor {
+    c;
+    constructor(c) {
+        super();
+        this.c = c;
+    }
+    visitNode(node) {
+        // Type members and their parameters are source elements in tsgo, whose JSDoc links count as uses.
+        checkJSDocLinksOfNode(this.c, node);
+        switch (node.kind) {
+            case 79 /* SyntaxKind.Identifier */:
+            case 167 /* SyntaxKind.QualifiedName */:
+            case 10 /* SyntaxKind.StringLiteral */:
+            case 8 /* SyntaxKind.NumericLiteral */:
+                return false;
+            case 170 /* SyntaxKind.Parameter */:
+                checkVariableLikeDeclaration(this.c, node);
+                return false;
+            case 174 /* SyntaxKind.MethodSignature */:
+            case 180 /* SyntaxKind.CallSignature */:
+            case 181 /* SyntaxKind.ConstructSignature */:
+                checkTypeNode(this.c, node);
+                return false;
+            case 172 /* SyntaxKind.PropertySignature */:
+                checkVariableLikeDeclaration(this.c, node);
+                return false;
+            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.SetAccessor */:
+                checkTypeMemberAccessor(this.c, node);
+                return false;
+            case 182 /* SyntaxKind.IndexSignature */:
+                node.forEachChild(this);
+                return false;
+            case 169 /* SyntaxKind.TypeParameter */:
+                // Lists of signatures are checked as a whole; `infer` and mapped type parameters alone.
+                if (node.parent.kind === 196 /* SyntaxKind.InferType */ || node.parent.kind === 201 /* SyntaxKind.MappedType */)
+                    checkTypeParameter(this.c, node);
+                if (node.parent.kind === 196 /* SyntaxKind.InferType */) {
+                    const symbol = getSymbolOfDeclaration(this.c, node);
+                    if (symbol !== undefined)
+                        checkInferTypeParameterDeclarations(this.c, symbol);
+                }
+                return false;
+        }
+        if (node.kind >= 183 /* SyntaxKind.FirstTypeNode */ && node.kind <= 206 /* SyntaxKind.LastTypeNode */)
+            checkTypeNode(this.c, node);
+        else if (node.kind === 234 /* SyntaxKind.ExpressionWithTypeArguments */)
+            checkTypeNode(this.c, node);
+        return false;
+    }
+}
+// ---- Deferred checks
+/**
+ * Queues a function expression, arrow, accessor, class expression or other deferred node to check with
+ * its file, like tsgo: nodes wait in the links of their own source file and are checked when that file
+ * is checked, and nodes of files this checker has already checked are not queued again. Checking one
+ * file often defers nodes of others (inferring a function's return type checks its body), and those
+ * belong to whichever checker checks the other file.
+ */
+export function checkNodeDeferred(c, node) {
+    const links = c.nodeLinks(getSourceFileOfNode(node));
+    if (links.typeChecked)
+        return;
+    const id = getNodeId(node);
+    if (c.deferredNodeIds.has(id))
+        return;
+    c.deferredNodeIds.add(id);
+    let nodes = links.deferredNodes;
+    if (nodes === undefined) {
+        nodes = [];
+        links.deferredNodes = nodes;
+    }
+    nodes.push(node);
+}
+function checkDeferredNodes(c, file) {
+    const nodes = c.nodeLinks(file).deferredNodes;
+    if (nodes === undefined)
+        return;
+    // Deferred checks may defer more nodes.
+    for (let i = 0; i < nodes.length; i++)
+        checkDeferredNode(c, nodes[i]);
+    nodes.length = 0;
+}
+/** Resolves the type of an object literal accessor, which reports accessors implicitly typed `any`. */
+function checkObjectLiteralAccessorType(c, node) {
+    if (node.parent.kind !== 211 /* SyntaxKind.ObjectLiteralExpression */)
+        return;
+    const symbol = getSymbolOfDeclaration(c, node);
+    if (symbol !== undefined)
+        getTypeOfSymbol(c, symbol);
+}
+function checkDeferredNode(c, node) {
+    const saveCurrentNode = c.currentNode;
+    c.currentNode = node;
+    c.instantiationCount = 0;
+    switch (node.kind) {
+        case 214 /* SyntaxKind.CallExpression */:
+        case 215 /* SyntaxKind.NewExpression */:
+        case 216 /* SyntaxKind.TaggedTemplateExpression */:
+            // Deferred when overload resolution fails, so that the arguments are checked once.
+            resolveUntypedCall(c, node);
+            break;
+        case 219 /* SyntaxKind.FunctionExpression */:
+        case 220 /* SyntaxKind.ArrowFunction */:
+        case 175 /* SyntaxKind.MethodDeclaration */:
+            checkFunctionLikeBody(c, node);
+            break;
+        case 178 /* SyntaxKind.GetAccessor */:
+        case 179 /* SyntaxKind.SetAccessor */:
+            checkObjectLiteralAccessorType(c, node);
+            checkFunctionLikeBody(c, node);
+            if (node.parent.kind === 211 /* SyntaxKind.ObjectLiteralExpression */)
+                checkAccessorDeclaration(c, node);
+            break;
+        case 232 /* SyntaxKind.ClassExpression */:
+            checkClassLikeDeferred(c, node);
+            break;
+        case 235 /* SyntaxKind.AsExpression */:
+        case 217 /* SyntaxKind.TypeAssertionExpression */:
+            checkAssertionDeferred(c, node);
+            break;
+        case 169 /* SyntaxKind.TypeParameter */:
+            checkTypeParameterDeferred(c, node);
+            break;
+        case 285 /* SyntaxKind.JsxElement */:
+        case 286 /* SyntaxKind.JsxSelfClosingElement */:
+            checkJsxElementDeferred(c, node);
+            break;
+        case 223 /* SyntaxKind.VoidExpression */:
+            checkExpression(c, getExpression(node));
+            break;
+    }
+    c.currentNode = saveCurrentNode;
+}

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

@@ -0,0 +1,18 @@
+import { type Node } from './ast.js';
+import { type Checker } from './checker.js';
+import { type Type } from './checker-types.js';
+export declare function checkBlock(c: Checker, node: Node): void;
+export declare function checkExpressionStatement(c: Checker, node: Node): void;
+export declare function checkIfStatement(c: Checker, node: Node): void;
+export declare function checkDoStatement(c: Checker, node: Node): void;
+export declare function checkWhileStatement(c: Checker, node: Node): void;
+export declare function checkForStatement(c: Checker, node: Node): void;
+export declare function checkForInStatement(c: Checker, node: Node): void;
+export declare function checkForOfStatement(c: Checker, node: Node): void;
+/** The element type a `for...of` produces. */
+export declare function checkRightHandSideOfForOf(c: Checker, statement: Node): Type;
+export declare function checkReturnStatement(c: Checker, node: Node): void;
+export declare function checkSwitchStatement(c: Checker, node: Node): void;
+export declare function checkLabeledStatement(c: Checker, node: Node): void;
+export declare function checkThrowStatement(c: Checker, node: Node): void;
+export declare function checkTryStatement(c: Checker, node: Node): void;