tsc-ts 0.0.3 → 0.0.5

package/dist/api/compiler/transformers/declarations-pseudo.js

@@ -0,0 +1,797 @@
+// Pseudo-types: the types of declarations as far as syntax decides them, following tsgo's
+// pseudochecker and the isolatedDeclarations rules. Annotations, literals, `as const` values
+// and function expressions with annotated returns have pseudo-types; everything else is
+// "inferred" and needs the checker.
+import { ArrayLiteralExpression, ArrowFunction, FunctionExpression, MethodDeclaration, GetAccessorDeclaration, NodeVisitor, ObjectLiteralExpression, ParameterDeclaration, PrefixUnaryExpression, PropertyAssignment, PropertyDeclaration, ReturnStatement, SetAccessorDeclaration, TypeReferenceNode, VariableDeclaration, UnionTypeNode, IntersectionTypeNode, getAsteriskToken, getBody, getExpression, getName, getParameters, getPostfixToken, getSymbol, getType, getTypeParameters, } from '../ast.js';
+import { isFunctionLike, nodeIsMissing } from '../ast-utilities.js';
+import { getCombinedNodeFlags, hasSyntacticModifier, isIdentifierNamed } from '../binder-utilities.js';
+import { getAllAccessorDeclarations } from './declarations-diagnostics.js';
+export class PseudoType {
+    kind;
+    constructor(kind) {
+        this.kind = kind;
+    }
+}
+export class DirectType extends PseudoType {
+    typeNode;
+    constructor(typeNode) {
+        super(0 /* PseudoTypeKind.Direct */);
+        this.typeNode = typeNode;
+    }
+}
+export class InferredType extends PseudoType {
+    expression;
+    /** Nodes to report isolatedDeclarations errors on, such as spreads; the expression if empty. */
+    errorNodes;
+    isSignatureReturn;
+    constructor(expression, isSignatureReturn, errorNodes) {
+        super(1 /* PseudoTypeKind.Inferred */);
+        this.expression = expression;
+        this.isSignatureReturn = isSignatureReturn;
+        this.errorNodes = errorNodes;
+    }
+}
+export class NoResultType extends PseudoType {
+    declaration;
+    constructor(declaration) {
+        super(2 /* PseudoTypeKind.NoResult */);
+        this.declaration = declaration;
+    }
+}
+export class MaybeConstType extends PseudoType {
+    node;
+    constType;
+    regularType;
+    constructor(node, constType, regularType) {
+        super(3 /* PseudoTypeKind.MaybeConstLocation */);
+        this.node = node;
+        this.constType = constType;
+        this.regularType = regularType;
+    }
+}
+export class UnionType extends PseudoType {
+    types;
+    constructor(types) {
+        super(4 /* PseudoTypeKind.Union */);
+        this.types = types;
+    }
+}
+export class PseudoParameter {
+    rest;
+    name;
+    optional;
+    type;
+    constructor(rest, name, optional, type) {
+        this.rest = rest;
+        this.name = name;
+        this.optional = optional;
+        this.type = type;
+    }
+}
+export class SignatureType extends PseudoType {
+    signature;
+    parameters;
+    typeParameters;
+    returnType;
+    constructor(signature, parameters, typeParameters, returnType) {
+        super(14 /* PseudoTypeKind.SingleCallSignature */);
+        this.signature = signature;
+        this.parameters = parameters;
+        this.typeParameters = typeParameters;
+        this.returnType = returnType;
+    }
+}
+export class TupleType extends PseudoType {
+    elements;
+    constructor(elements) {
+        super(15 /* PseudoTypeKind.Tuple */);
+        this.elements = elements;
+    }
+}
+/** A member of an object literal type. */
+export class PseudoMember {
+    kind;
+    name;
+    optional;
+    readonly;
+    /** The method or accessor declaration; undefined for properties. */
+    signature;
+    typeParameters;
+    parameters;
+    /** The property or get accessor type, or the method's return type. */
+    type;
+    constructor(kind, name, optional, readonly, signature, typeParameters, parameters, type) {
+        this.kind = kind;
+        this.name = name;
+        this.optional = optional;
+        this.readonly = readonly;
+        this.signature = signature;
+        this.typeParameters = typeParameters;
+        this.parameters = parameters;
+        this.type = type;
+    }
+}
+export class ObjectLiteralType extends PseudoType {
+    members;
+    constructor(members) {
+        super(16 /* PseudoTypeKind.ObjectLiteral */);
+        this.members = members;
+    }
+}
+/** A string, numeric or bigint literal type. */
+export class LiteralType extends PseudoType {
+    node;
+    constructor(kind, node) {
+        super(kind);
+        this.node = node;
+    }
+}
+export const undefinedType = new PseudoType(5 /* PseudoTypeKind.Undefined */);
+export const nullType = new PseudoType(6 /* PseudoTypeKind.Null */);
+export const anyType = new PseudoType(7 /* PseudoTypeKind.Any */);
+export const stringType = new PseudoType(8 /* PseudoTypeKind.String */);
+export const numberType = new PseudoType(9 /* PseudoTypeKind.Number */);
+export const bigintType = new PseudoType(10 /* PseudoTypeKind.BigInt */);
+export const booleanType = new PseudoType(11 /* PseudoTypeKind.Boolean */);
+export const falseType = new PseudoType(12 /* PseudoTypeKind.False */);
+export const trueType = new PseudoType(13 /* PseudoTypeKind.True */);
+function inferred(expression, isSignatureReturn) {
+    return new InferredType(expression, isSignatureReturn, []);
+}
+/** Whether a pseudo-type is inferred without nodes to report errors on. */
+function isBareInferred(type) {
+    return type instanceof InferredType && type.errorNodes.length === 0;
+}
+export class PseudoChecker {
+    strictNullChecks;
+    /** Global symbols merged across files, by each file's symbol. */
+    mergedSymbols;
+    /** Resolves `undefined`, which a declaration can shadow. */
+    names;
+    constructor(strictNullChecks, mergedSymbols, names) {
+        this.strictNullChecks = strictNullChecks;
+        this.mergedSymbols = mergedSymbols;
+        this.names = names;
+    }
+    /** How many `| undefined` additions only the checker can decide; reset by callers. */
+    uncertain = 0;
+    /** Adds `| undefined` unless the type may already include it; counts the cases that need types to tell. */
+    addUndefined(type) {
+        if (couldAlreadyReferToUndefined(type) && !definitelyHasUndefined(type))
+            this.uncertain++;
+        return addUndefinedIfDefinitelyRequired(type);
+    }
+    getMergedSymbol(symbol) {
+        return this.mergedSymbols.get(symbol) ?? symbol;
+    }
+    getReturnTypeOfSignature(signature) {
+        if (signature.kind === 178 /* SyntaxKind.GetAccessor */)
+            return this.getTypeOfAccessor(signature);
+        return this.createReturnFromSignature(signature);
+    }
+    getTypeOfAccessor(accessor) {
+        const accessors = getAllAccessorDeclarations(accessor);
+        const annotation = this.getAccessorAnnotation(accessor, accessors.firstAccessor, accessors.secondAccessor);
+        if (annotation !== undefined && annotation.kind !== 183 /* SyntaxKind.TypePredicate */)
+            return new DirectType(annotation);
+        const getter = accessors.getAccessor;
+        if (getter !== undefined) {
+            const result = this.createReturnFromSignature(getter);
+            if (result instanceof InferredType && result.errorNodes.length === 0) {
+                // The error is reported on the accessors.
+                const errorNodes = [getter];
+                if (accessors.setAccessor !== undefined)
+                    errorNodes.push(accessors.setAccessor);
+                return new InferredType(result.expression, result.isSignatureReturn, errorNodes);
+            }
+            return result;
+        }
+        return new NoResultType(accessor);
+    }
+    getAccessorAnnotation(node, first, second) {
+        let annotation = accessorAnnotation(node);
+        if (annotation === undefined && node !== first)
+            annotation = accessorAnnotation(first);
+        if (annotation === undefined && second !== undefined && node !== second)
+            annotation = accessorAnnotation(second);
+        return annotation;
+    }
+    getTypeOfExpression(node) {
+        return this.typeFromExpression(node);
+    }
+    getTypeOfDeclaration(node) {
+        switch (node.kind) {
+            case 170 /* SyntaxKind.Parameter */:
+                if (node instanceof ParameterDeclaration) {
+                    const narrowed = node;
+                    return this.typeFromParameter(narrowed);
+                }
+                break;
+            case 261 /* SyntaxKind.VariableDeclaration */:
+                if (node instanceof VariableDeclaration) {
+                    const narrowed = node;
+                    return this.typeFromVariable(narrowed);
+                }
+                break;
+            case 172 /* SyntaxKind.PropertySignature */:
+            case 173 /* SyntaxKind.PropertyDeclaration */:
+            case 340 /* SyntaxKind.JSDocPropertyTag */:
+                return this.typeFromProperty(node);
+            case 278 /* SyntaxKind.ExportAssignment */:
+                return this.typeFromExpression(getExpression(node));
+            case 212 /* SyntaxKind.PropertyAccessExpression */:
+            case 213 /* SyntaxKind.ElementAccessExpression */:
+            case 227 /* SyntaxKind.BinaryExpression */: {
+                const type = getType(node);
+                return type !== undefined ? new DirectType(type) : new NoResultType(node);
+            }
+            case 303 /* SyntaxKind.PropertyAssignment */:
+            case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+                return this.typeFromPropertyAssignment(node);
+        }
+        return new NoResultType(node);
+    }
+    typeFromPropertyAssignment(node) {
+        const annotation = getType(node);
+        if (annotation !== undefined)
+            return new DirectType(annotation);
+        if (node instanceof PropertyAssignment) {
+            const result = this.typeFromExpression(node.initializer);
+            if (!isBareInferred(result))
+                return result;
+        }
+        return new NoResultType(node);
+    }
+    typeFromProperty(node) {
+        const annotation = getType(node);
+        if (annotation !== undefined)
+            return new DirectType(annotation);
+        // A property declared more than once has the type of its first declaration; only the checker
+        // knows which, so the type is still written from this one but counted as uncertain.
+        const symbol = getSymbol(node);
+        if (symbol !== undefined && symbol.declarations.length > 1)
+            this.uncertain++;
+        if (node instanceof PropertyDeclaration) {
+            const initializer = node.initializer;
+            if (initializer !== undefined && !isContextuallyTyped(node)) {
+                // Readonly template literals may become literal types, so they aren't inferred.
+                if (hasSyntacticModifier(node, 8 /* ModifierFlags.Readonly */) && initializer.kind === 229 /* SyntaxKind.TemplateExpression */)
+                    return new NoResultType(node);
+                const result = this.typeFromExpression(initializer);
+                if (!isBareInferred(result)) {
+                    const postfix = node.postfixToken;
+                    // `x? = value` has `| undefined` in its type.
+                    if (result.kind !== 0 /* PseudoTypeKind.Direct */ &&
+                        postfix !== undefined &&
+                        postfix.kind === 57 /* SyntaxKind.QuestionToken */)
+                        return this.addUndefined(result);
+                    return result;
+                }
+            }
+        }
+        return new NoResultType(node);
+    }
+    typeFromVariable(declaration) {
+        if (declaration.type !== undefined)
+            return new DirectType(declaration.type);
+        const initializer = declaration.initializer;
+        // As tsgo, the file's own declarations; merged ones are left to the checker's type comparison.
+        const symbol = declaration.symbol;
+        if (initializer !== undefined && (symbol === undefined || countVariableDeclarations(symbol.declarations) === 1)) {
+            if (!isContextuallyTyped(declaration)) {
+                // Const template literals may become literal types, so they aren't inferred.
+                if ((getCombinedNodeFlags(declaration) & 2 /* NodeFlags.Const */) !== 0 &&
+                    initializer.kind === 229 /* SyntaxKind.TemplateExpression */)
+                    return new NoResultType(declaration);
+                const result = this.typeFromExpression(initializer);
+                if (!isBareInferred(result))
+                    return result;
+            }
+        }
+        return new NoResultType(declaration);
+    }
+    /** The return type of a signature; `NoResult` or `Inferred` when unknown. */
+    createReturnFromSignature(fn) {
+        if (isFunctionLike(fn)) {
+            const type = getType(fn);
+            if (type !== undefined)
+                return new DirectType(type);
+        }
+        if (isValueSignatureDeclaration(fn))
+            return this.typeFromSingleReturnExpression(fn);
+        return new NoResultType(fn);
+    }
+    typeFromSingleReturnExpression(fn) {
+        let candidate = undefined;
+        const body = getBody(fn);
+        if (body !== undefined && !nodeIsMissing(body)) {
+            // An async function or generator returns a promise or generator of its returned values.
+            if (hasSyntacticModifier(fn, 1024 /* ModifierFlags.Async */) || getAsteriskToken(fn) !== undefined)
+                return inferred(fn, true);
+            if (body.kind === 242 /* SyntaxKind.Block */) {
+                const returns = collectReturnStatements(body);
+                // Only a single return directly in the body.
+                if (returns.length === 1 && returns[0].parent === body)
+                    candidate = returns[0].expression;
+            }
+            else
+                candidate = body;
+        }
+        if (candidate !== undefined) {
+            if (!isContextuallyTyped(candidate))
+                return this.typeFromExpression(candidate);
+            let type = undefined;
+            if (candidate.kind === 217 /* SyntaxKind.TypeAssertionExpression */ || candidate.kind === 235 /* SyntaxKind.AsExpression */)
+                type = getType(candidate);
+            if (type !== undefined && !isConstTypeReference(type))
+                return new DirectType(type);
+        }
+        return inferred(fn, true);
+    }
+    /** `checkExpression` for pseudo-types. */
+    typeFromExpression(node) {
+        switch (node.kind) {
+            case 233 /* SyntaxKind.OmittedExpression */:
+                return undefinedType;
+            case 218 /* SyntaxKind.ParenthesizedExpression */:
+                return this.typeFromExpression(getExpression(node));
+            case 79 /* SyntaxKind.Identifier */:
+                // A declaration named `undefined` shadows it.
+                if (isIdentifierNamed(node, 'undefined'))
+                    return this.names.resolve(node, 'undefined', 111551 /* SymbolFlags.Value */, undefined, false, false) === undefined
+                        ? undefinedType
+                        : inferred(node, false);
+                break;
+            case 105 /* SyntaxKind.NullKeyword */:
+                return nullType;
+            case 220 /* SyntaxKind.ArrowFunction */:
+            case 219 /* SyntaxKind.FunctionExpression */:
+                return this.typeFromFunctionLikeExpression(node);
+            case 217 /* SyntaxKind.TypeAssertionExpression */:
+            case 235 /* SyntaxKind.AsExpression */: {
+                const type = getType(node);
+                if (isConstTypeReference(type))
+                    return this.typeFromExpression(getExpression(node));
+                return new DirectType(type);
+            }
+            case 225 /* SyntaxKind.PrefixUnaryExpression */:
+                if (node instanceof PrefixUnaryExpression) {
+                    const unary = node;
+                    if (isSignedNumericLiteral(unary))
+                        return typeFromSignedLiteral(unary);
+                }
+                break;
+            case 210 /* SyntaxKind.ArrayLiteralExpression */:
+                if (node instanceof ArrayLiteralExpression) {
+                    const narrowed = node;
+                    return this.typeFromArrayLiteral(narrowed);
+                }
+                break;
+            case 211 /* SyntaxKind.ObjectLiteralExpression */:
+                if (node instanceof ObjectLiteralExpression) {
+                    const narrowed = node;
+                    return this.typeFromObjectLiteral(narrowed);
+                }
+                break;
+            case 232 /* SyntaxKind.ClassExpression */:
+                return new InferredType(node, false, [node]);
+            case 229 /* SyntaxKind.TemplateExpression */:
+                // Templates with substitutions aren't literal types, but `as const` would make them one.
+                if (isInConstContext(node))
+                    return inferred(node, false);
+                return new MaybeConstType(node, inferred(node, false), stringType);
+            case 8 /* SyntaxKind.NumericLiteral */:
+                return new MaybeConstType(node, new LiteralType(18 /* PseudoTypeKind.NumericLiteral */, node), numberType);
+            case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+            case 10 /* SyntaxKind.StringLiteral */:
+                return new MaybeConstType(node, new LiteralType(17 /* PseudoTypeKind.StringLiteral */, node), stringType);
+            case 9 /* SyntaxKind.BigIntLiteral */:
+                return new MaybeConstType(node, new LiteralType(19 /* PseudoTypeKind.BigIntLiteral */, node), bigintType);
+            case 111 /* SyntaxKind.TrueKeyword */:
+                return new MaybeConstType(node, trueType, booleanType);
+            case 96 /* SyntaxKind.FalseKeyword */:
+                return new MaybeConstType(node, falseType, booleanType);
+        }
+        return inferred(node, false);
+    }
+    typeFromObjectLiteral(node) {
+        const errorNodes = objectLiteralErrorNodes(node);
+        if (errorNodes.length > 0)
+            return new InferredType(node, false, errorNodes);
+        const members = [];
+        for (const property of node.properties.nodes) {
+            switch (property.kind) {
+                case 175 /* SyntaxKind.MethodDeclaration */: {
+                    const postfix = getPostfixToken(property);
+                    const optional = postfix !== undefined && postfix.kind === 57 /* SyntaxKind.QuestionToken */;
+                    const fullSignature = getFullSignature(property);
+                    if (fullSignature !== undefined) {
+                        members.push(new PseudoMember(1 /* PseudoMemberKind.Property */, getName(property), optional, false, undefined, [], [], new DirectType(fullSignature)));
+                        break;
+                    }
+                    members.push(new PseudoMember(0 /* PseudoMemberKind.Method */, getName(property), optional, false, property, nodesOf(getTypeParameters(property)), this.cloneParameters(getParameters(property).nodes), this.createReturnFromSignature(property)));
+                    break;
+                }
+                case 303 /* SyntaxKind.PropertyAssignment */: {
+                    const assignment = property;
+                    const postfix = assignment.postfixToken;
+                    members.push(new PseudoMember(1 /* PseudoMemberKind.Property */, assignment.name, postfix !== undefined && postfix.kind === 57 /* SyntaxKind.QuestionToken */, false, undefined, [], [], this.typeFromExpression(assignment.initializer)));
+                    break;
+                }
+                case 179 /* SyntaxKind.SetAccessor */:
+                case 178 /* SyntaxKind.GetAccessor */: {
+                    const member = this.getAccessorMember(property);
+                    if (member !== undefined)
+                        members.push(member);
+                    break;
+                }
+            }
+        }
+        return new ObjectLiteralType(members);
+    }
+    getAccessorMember(accessor) {
+        const accessors = getAllAccessorDeclarations(accessor);
+        const name = getName(accessor);
+        const getter = accessors.getAccessor;
+        const setter = accessors.setAccessor;
+        // With both accessors annotated, their types may differ, so both are kept.
+        if (getter instanceof GetAccessorDeclaration &&
+            getter.type !== undefined &&
+            setter instanceof SetAccessorDeclaration &&
+            setter.parameters.nodes.length > 0 &&
+            getType(setter.parameters.nodes[0]) !== undefined) {
+            if (accessor.kind === 178 /* SyntaxKind.GetAccessor */)
+                return new PseudoMember(3 /* PseudoMemberKind.GetAccessor */, name, false, false, accessor, [], [], this.getTypeOfAccessor(accessor));
+            const parameters = this.cloneParameters(accessor.parameters.nodes);
+            return new PseudoMember(2 /* PseudoMemberKind.SetAccessor */, name, false, false, accessor, [], parameters, anyType);
+        }
+        // Otherwise the first accessor is a property, `readonly` for a lone getter.
+        if (accessor === accessors.firstAccessor)
+            return new PseudoMember(1 /* PseudoMemberKind.Property */, name, false, accessor.kind === 178 /* SyntaxKind.GetAccessor */ && accessors.secondAccessor === undefined, undefined, [], [], this.getTypeOfAccessor(accessor));
+        return undefined;
+    }
+    typeFromArrayLiteral(node) {
+        if (!isInConstContext(node))
+            return new InferredType(node, false, [node]);
+        for (const element of node.elements.nodes)
+            if (element.kind === 231 /* SyntaxKind.SpreadElement */)
+                return new InferredType(node, false, [element]);
+        // An `as const` array with a contextual type may or may not be readonly.
+        if (isContextuallyTyped(node))
+            return inferred(node, false);
+        const elements = [];
+        for (const element of node.elements.nodes)
+            elements.push(this.typeFromExpression(element));
+        return new TupleType(elements);
+    }
+    typeFromFunctionLikeExpression(node) {
+        const fullSignature = getFullSignature(node);
+        if (fullSignature !== undefined)
+            return new DirectType(fullSignature);
+        return new SignatureType(node, this.cloneParameters(getParameters(node).nodes), nodesOf(getTypeParameters(node)), this.createReturnFromSignature(node));
+    }
+    typeFromParameter(node) {
+        const parent = node.parent;
+        if (parent.kind === 179 /* SyntaxKind.SetAccessor */)
+            return this.getTypeOfAccessor(parent);
+        if (node.initializer === undefined)
+            return node.type !== undefined ? new DirectType(node.type) : new NoResultType(node);
+        const parameters = getParameters(parent).nodes;
+        return this.typeFromParameterAt(node, parameters.indexOf(node), lastRequiredParameterIndex(parameters));
+    }
+    typeFromParameterAt(node, index, lastRequired) {
+        const parent = node.parent;
+        if (parent.kind === 179 /* SyntaxKind.SetAccessor */)
+            return this.getTypeOfAccessor(parent);
+        const hasRequiredAfter = index < lastRequired - 1;
+        if (node.type !== undefined) {
+            const result = new DirectType(node.type);
+            // An initialized parameter before a required one has `| undefined` in its type.
+            if (this.strictNullChecks && node.initializer !== undefined && hasRequiredAfter)
+                return this.addUndefined(result);
+            return result;
+        }
+        if (node.initializer !== undefined && node.name.kind === 79 /* SyntaxKind.Identifier */ && !isContextuallyTyped(node)) {
+            let result = this.typeFromExpression(node.initializer);
+            // The error is reported on the parameter.
+            if (isBareInferred(result))
+                result = new InferredType(result.expression, false, [node]);
+            if (!this.strictNullChecks || !hasRequiredAfter)
+                return result;
+            return this.addUndefined(result);
+        }
+        // Types aren't inferred from binding patterns.
+        return new NoResultType(node);
+    }
+    cloneParameters(nodes) {
+        const result = [];
+        const lastRequired = lastRequiredParameterIndex(nodes);
+        for (let i = 0; i < nodes.length; i++) {
+            const parameter = nodes[i];
+            let optional = parameter.questionToken !== undefined;
+            // An initialized parameter is optional when no required one follows.
+            if (!optional && parameter.initializer !== undefined)
+                optional = i >= lastRequired - 1;
+            result.push(new PseudoParameter(parameter.dotDotDotToken !== undefined, parameter.name, optional, this.typeFromParameterAt(parameter, i, lastRequired)));
+        }
+        return result;
+    }
+}
+function nodesOf(list) {
+    return list === undefined ? [] : list.nodes;
+}
+function accessorAnnotation(node) {
+    if (node instanceof GetAccessorDeclaration)
+        return node.type;
+    if (node instanceof SetAccessorDeclaration) {
+        const parameters = node.parameters.nodes;
+        return parameters.length > 0 ? getType(parameters[0]) : undefined;
+    }
+    return undefined;
+}
+function countVariableDeclarations(declarations) {
+    if (declarations.length === 1)
+        return 1;
+    let count = 0;
+    for (const declaration of declarations)
+        if (declaration.kind === 261 /* SyntaxKind.VariableDeclaration */)
+            count++;
+    return count;
+}
+function isValueSignatureDeclaration(node) {
+    switch (node.kind) {
+        case 219 /* SyntaxKind.FunctionExpression */:
+        case 220 /* SyntaxKind.ArrowFunction */:
+        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 178 /* SyntaxKind.GetAccessor */:
+        case 179 /* SyntaxKind.SetAccessor */:
+        case 263 /* SyntaxKind.FunctionDeclaration */:
+        case 177 /* SyntaxKind.Constructor */:
+            return true;
+    }
+    return false;
+}
+/** The return statements of a function body, outside nested functions. */
+export function collectReturnStatements(body) {
+    const collector = new ReturnCollector();
+    collector.visitNode(body);
+    return collector.statements;
+}
+class ReturnCollector extends NodeVisitor {
+    statements = [];
+    visitNode(node) {
+        switch (node.kind) {
+            case 254 /* SyntaxKind.ReturnStatement */:
+                if (node instanceof ReturnStatement)
+                    this.statements.push(node);
+                return false;
+            case 270 /* SyntaxKind.CaseBlock */:
+            case 242 /* SyntaxKind.Block */:
+            case 246 /* SyntaxKind.IfStatement */:
+            case 247 /* SyntaxKind.DoStatement */:
+            case 248 /* SyntaxKind.WhileStatement */:
+            case 249 /* SyntaxKind.ForStatement */:
+            case 250 /* SyntaxKind.ForInStatement */:
+            case 251 /* SyntaxKind.ForOfStatement */:
+            case 255 /* SyntaxKind.WithStatement */:
+            case 256 /* SyntaxKind.SwitchStatement */:
+            case 297 /* SyntaxKind.CaseClause */:
+            case 298 /* SyntaxKind.DefaultClause */:
+            case 257 /* SyntaxKind.LabeledStatement */:
+            case 259 /* SyntaxKind.TryStatement */:
+            case 300 /* SyntaxKind.CatchClause */:
+                return node.forEachChild(this);
+        }
+        return false;
+    }
+}
+function isSignedNumericLiteral(node) {
+    const operand = node.operand.kind;
+    if (node.operator === 40 /* SyntaxKind.MinusToken */)
+        return operand === 8 /* SyntaxKind.NumericLiteral */ || operand === 9 /* SyntaxKind.BigIntLiteral */;
+    return node.operator === 39 /* SyntaxKind.PlusToken */ && operand === 8 /* SyntaxKind.NumericLiteral */;
+}
+function typeFromSignedLiteral(node) {
+    const literal = node.operator === 39 /* SyntaxKind.PlusToken */ ? node.operand : node;
+    if (node.operand.kind === 9 /* SyntaxKind.BigIntLiteral */)
+        return new MaybeConstType(node, new LiteralType(19 /* PseudoTypeKind.BigIntLiteral */, literal), bigintType);
+    return new MaybeConstType(node, new LiteralType(18 /* PseudoTypeKind.NumericLiteral */, literal), numberType);
+}
+export function isConstTypeReference(node) {
+    return (node instanceof TypeReferenceNode &&
+        (node.typeArguments === undefined || node.typeArguments.nodes.length === 0) &&
+        isIdentifierNamed(node.typeName, 'const'));
+}
+function isConstAssertionNode(node) {
+    return ((node.kind === 235 /* SyntaxKind.AsExpression */ || node.kind === 217 /* SyntaxKind.TypeAssertionExpression */) &&
+        isConstTypeReference(getType(node)));
+}
+/** Whether a nested expression is inside an `as const`, as far as syntax decides. */
+export function isInConstContext(node) {
+    let current = node.parent;
+    while (current !== undefined) {
+        switch (current.kind) {
+            case 235 /* SyntaxKind.AsExpression */:
+            case 217 /* SyntaxKind.TypeAssertionExpression */:
+                return isConstAssertionNode(current);
+            case 210 /* SyntaxKind.ArrayLiteralExpression */:
+            case 211 /* SyntaxKind.ObjectLiteralExpression */:
+            case 218 /* SyntaxKind.ParenthesizedExpression */:
+            case 231 /* SyntaxKind.SpreadElement */:
+            case 303 /* SyntaxKind.PropertyAssignment */:
+            case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+            case 240 /* SyntaxKind.TemplateSpan */:
+            case 225 /* SyntaxKind.PrefixUnaryExpression */:
+                current = current.parent;
+                continue;
+        }
+        return false;
+    }
+    return false;
+}
+/** Whether calls, `satisfies` or annotations around a node can change its type. */
+function isContextuallyTyped(node) {
+    for (let current = node.parent; current !== undefined; current = current.parent) {
+        switch (current.kind) {
+            case 214 /* SyntaxKind.CallExpression */:
+            case 239 /* SyntaxKind.SatisfiesExpression */:
+            case 285 /* SyntaxKind.JsxElement */:
+            case 295 /* SyntaxKind.JsxExpression */:
+                return true;
+            case 261 /* SyntaxKind.VariableDeclaration */:
+            case 170 /* SyntaxKind.Parameter */:
+            case 173 /* SyntaxKind.PropertyDeclaration */:
+            case 172 /* SyntaxKind.PropertySignature */:
+            case 235 /* SyntaxKind.AsExpression */:
+            case 217 /* SyntaxKind.TypeAssertionExpression */:
+                if (getType(current) !== undefined && !isConstAssertionNode(current))
+                    return true;
+                break;
+        }
+    }
+    return false;
+}
+function objectLiteralErrorNodes(node) {
+    const errorNodes = [];
+    for (const property of node.properties.nodes) {
+        if ((property.flags & 32768 /* NodeFlags.ThisNodeHasError */) !== 0) {
+            errorNodes.push(property);
+            continue;
+        }
+        if (property.kind === 304 /* SyntaxKind.ShorthandPropertyAssignment */ || property.kind === 305 /* SyntaxKind.SpreadAssignment */) {
+            errorNodes.push(property);
+            continue;
+        }
+        const name = getName(property);
+        if ((name.flags & 32768 /* NodeFlags.ThisNodeHasError */) !== 0)
+            errorNodes.push(name);
+        else if (name.kind === 80 /* SyntaxKind.PrivateIdentifier */)
+            errorNodes.push(property);
+        else if (name.kind === 168 /* SyntaxKind.ComputedPropertyName */ && !isPrimitiveLiteral(getExpression(name)))
+            errorNodes.push(name);
+    }
+    return errorNodes;
+}
+function isPrimitiveLiteral(node) {
+    switch (node.kind) {
+        case 111 /* SyntaxKind.TrueKeyword */:
+        case 96 /* SyntaxKind.FalseKeyword */:
+        case 8 /* SyntaxKind.NumericLiteral */:
+        case 10 /* SyntaxKind.StringLiteral */:
+        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+            return true;
+        case 225 /* SyntaxKind.PrefixUnaryExpression */: {
+            const unary = node;
+            return ((unary.operator === 40 /* SyntaxKind.MinusToken */ || unary.operator === 39 /* SyntaxKind.PlusToken */) &&
+                unary.operand.kind === 8 /* SyntaxKind.NumericLiteral */);
+        }
+    }
+    return false;
+}
+/** The index just past the last parameter without `?`, initializer or `...`. */
+export function lastRequiredParameterIndex(parameters) {
+    for (let i = parameters.length - 1; i >= 0; i--) {
+        const parameter = parameters[i];
+        if (parameter.dotDotDotToken === undefined &&
+            parameter.initializer === undefined &&
+            parameter.questionToken === undefined)
+            return i + 1;
+    }
+    return 0;
+}
+function typeNodeCouldReferToUndefined(node) {
+    let current = node;
+    while (current.kind === 197 /* SyntaxKind.ParenthesizedType */)
+        current = getType(current);
+    switch (current.kind) {
+        // These need symbols or types to know.
+        case 184 /* SyntaxKind.TypeReference */:
+        case 200 /* SyntaxKind.IndexedAccessType */:
+        case 187 /* SyntaxKind.TypeQuery */:
+        case 191 /* SyntaxKind.OptionalType */:
+        case 192 /* SyntaxKind.RestType */:
+        case 206 /* SyntaxKind.ImportType */:
+        case 195 /* SyntaxKind.ConditionalType */:
+        case 199 /* SyntaxKind.TypeOperator */:
+        case 183 /* SyntaxKind.TypePredicate */:
+        case 157 /* SyntaxKind.UndefinedKeyword */:
+            return true;
+        case 193 /* SyntaxKind.UnionType */:
+        case 194 /* SyntaxKind.IntersectionType */:
+            // Intersections are treated like unions, as tsgo does.
+            for (const type of typesOf(current))
+                if (typeNodeCouldReferToUndefined(type))
+                    return true;
+            return false;
+    }
+    return false;
+}
+/** Whether a pseudo-type may already include `undefined`. */
+export function couldAlreadyReferToUndefined(type) {
+    if (type instanceof NoResultType || type instanceof InferredType || isUndefinedType(type))
+        return true;
+    if (type instanceof MaybeConstType)
+        return couldAlreadyReferToUndefined(type.regularType);
+    if (type instanceof DirectType)
+        return typeNodeCouldReferToUndefined(type.typeNode);
+    if (type instanceof UnionType) {
+        for (const member of type.types)
+            if (couldAlreadyReferToUndefined(member))
+                return true;
+        return false;
+    }
+    return false;
+}
+function isUndefinedType(type) {
+    return type.kind === 5 /* PseudoTypeKind.Undefined */ || (type instanceof MaybeConstType && isUndefinedType(type.constType));
+}
+function definitelyHasUndefined(type) {
+    if (isUndefinedType(type))
+        return true;
+    if (type instanceof UnionType) {
+        for (const member of type.types)
+            if (definitelyHasUndefined(member))
+                return true;
+        return false;
+    }
+    if (type instanceof DirectType)
+        return typeNodeHasUndefined(type.typeNode);
+    return false;
+}
+function typeNodeHasUndefined(node) {
+    if (node.kind === 157 /* SyntaxKind.UndefinedKeyword */ ||
+        node.kind === 132 /* SyntaxKind.AnyKeyword */ ||
+        node.kind === 159 /* SyntaxKind.UnknownKeyword */)
+        return true;
+    if (node.kind === 197 /* SyntaxKind.ParenthesizedType */)
+        return typeNodeHasUndefined(getType(node));
+    if (node instanceof UnionTypeNode) {
+        for (const member of node.types.nodes)
+            if (typeNodeHasUndefined(member))
+                return true;
+    }
+    return false;
+}
+function addUndefinedIfDefinitelyRequired(type) {
+    if (couldAlreadyReferToUndefined(type))
+        return type;
+    return new UnionType([type, undefinedType]);
+}
+/** The members of a union or intersection type node. */
+export function typesOf(node) {
+    if (node instanceof UnionTypeNode)
+        return node.types.nodes;
+    if (node instanceof IntersectionTypeNode)
+        return node.types.nodes;
+    return [];
+}
+/** The JSDoc `@type` signature of a function expression, arrow function or method. */
+function getFullSignature(node) {
+    if (node instanceof ArrowFunction)
+        return node.fullSignature;
+    if (node instanceof FunctionExpression)
+        return node.fullSignature;
+    if (node instanceof MethodDeclaration)
+        return node.fullSignature;
+    return undefined;
+}