tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/node-builder-pseudo.js

@@ -0,0 +1,744 @@
+// Writing pseudo-types (types as far as syntax decides them) as type nodes, checked against the
+// checker's types: declaration emit reuses what the source wrote where it denotes the same type,
+// and reports what isolatedDeclarations can't write without inference.
+import { FunctionTypeNode, GetAccessorDeclaration, Identifier, KeywordTypeNode, LiteralTypeNode, MethodSignatureDeclaration, ParameterDeclaration, PropertyAccessExpression, PropertySignatureDeclaration, QualifiedName, SetAccessorDeclaration, StringLiteral, TupleTypeNode, TypeLiteralNode, TypeOperatorNode, TypePredicateNode, UnionTypeNode, getBody, getName, getPostfixToken, getQuestionToken, getSymbol, getText, isDeclarationNode, } from './ast.js';
+import { isFunctionLike } from './ast-utilities.js';
+import { getSourceFileOfNode, isEntityNameExpression } from './binder-utilities.js';
+import { getContextualType, instantiateContextualType } from './checker-contextual.js';
+import { checkExpressionCached, isConstContext, isLiteralOfContextualType } from './checker-expressions.js';
+import { getTypeWithFacts } from './checker-flow.js';
+import { getPropertiesOfType, getPropertyOfType } from './checker-members.js';
+import { getReturnTypeOfSignature, getSignatureFromDeclaration, getSingleCallSignature, getTypePredicateOfSignature, } from './checker-signatures.js';
+import { getTypeOfParameter, getTypeOfSymbol, getWidenedType, getWriteTypeOfSymbol, removeMissingType, } from './checker-symbol-types.js';
+import { getRegularTypeOfLiteralType, getTypeArguments, getUnionType, isErrorType, isTupleType, } from './checker-type-factory.js';
+import { getTypeFromTypeNode } from './checker-type-nodes.js';
+import { NameResolver } from './name-resolver.js';
+import { getSymbolOfDeclaration } from './checker-symbols.js';
+import { canReuseExistingJSTypeNode, classifyPropertyName, getExpandedParameters, isOptionalParameter, requiresAddingImplicitUndefined, } from './node-builder.js';
+import { tryReuseExistingNode } from './node-builder-reuse.js';
+import { compareTypesIdentical } from './relations.js';
+import { DirectType, InferredType, PseudoChecker, isInConstContext, } from './transformers/declarations-pseudo.js';
+import { tryGetTextOfPropertyName } from './transformers/declarations-syntactic.js';
+/** Resolves no names: `undefined` in an expression is the undefined value, as tsgo's pseudochecker assumes. */
+class NoNames extends NameResolver {
+    resolve(_location, _name, _meaning, _nameNotFoundMessage, _isUse, _excludeGlobals) {
+        return undefined;
+    }
+}
+/** A pseudochecker for declaration emit with the checker. */
+export function newPseudoChecker(c) {
+    return new PseudoChecker(c.strictNullChecks, new Map(), new NoNames(c.compilerOptions));
+}
+function isDeclaration(node) {
+    if (node.kind === 169 /* SyntaxKind.TypeParameter */)
+        return node.parent !== undefined;
+    return isDeclarationNode(node);
+}
+function getContainingFunction(node) {
+    for (let current = node.parent; current !== undefined; current = current.parent)
+        if (isFunctionLike(current))
+            return current;
+    return undefined;
+}
+export function containsNonMissingUndefinedType(c, t) {
+    const candidate = (t.flags & 134217728 /* TypeFlags.Union */) !== 0 ? typesOfUnion(t)[0] : t;
+    return (candidate.flags & 4 /* TypeFlags.Undefined */) !== 0 && candidate !== c.missingType;
+}
+function typesOfUnion(t) {
+    return t.types;
+}
+export function getRegularTypeOfExpression(c, node) {
+    const parent = node.parent;
+    let expr = node;
+    if ((parent instanceof QualifiedName && parent.right === node) ||
+        (parent instanceof PropertyAccessExpression && parent.name === node))
+        expr = parent;
+    return getRegularTypeOfLiteralType(c, checkExpressionCached(c, expr));
+}
+function keyword(b, kind) {
+    return b.created(new KeywordTypeNode(kind));
+}
+/**
+ * Like `pseudoTypeToNode`, but an inferred pseudo-type (or an annotation that can't be reused)
+ * reports its fallback and is written from the checker's type.
+ */
+export function pseudoTypeToNodeWithCheckerFallback(b, t, checkerType) {
+    if (t instanceof InferredType) {
+        if (!b.suppressReportInferenceFallback) {
+            if (t.errorNodes.length > 0)
+                for (const n of t.errorNodes)
+                    b.tracker.reportInferenceFallback(n);
+            else
+                b.tracker.reportInferenceFallback(t.expression);
+        }
+        return typeToTypeNodeSuppressed(b, checkerType);
+    }
+    if (t instanceof DirectType) {
+        if (!canReuseExistingJSTypeNode(b, t.typeNode, checkerType)) {
+            if (!b.suppressReportInferenceFallback)
+                b.tracker.reportInferenceFallback(t.typeNode);
+            return typeToTypeNodeSuppressed(b, checkerType);
+        }
+    }
+    return pseudoTypeToNode(b, t);
+}
+function typeToTypeNodeSuppressed(b, t) {
+    const old = b.suppressReportInferenceFallback;
+    b.suppressReportInferenceFallback = true;
+    const result = b.typeToTypeNode(t);
+    b.suppressReportInferenceFallback = old;
+    return result;
+}
+/** The type node of a pseudo-type, reporting the fallbacks its structure implies. */
+export function pseudoTypeToNode(b, t) {
+    const c = b.c;
+    switch (t.kind) {
+        case 0 /* PseudoTypeKind.Direct */:
+            return reuseTypeNode(b, t.typeNode);
+        case 1 /* PseudoTypeKind.Inferred */: {
+            const inferred = t;
+            const node = inferred.expression;
+            if (inferred.errorNodes.length > 0)
+                for (const n of inferred.errorNodes)
+                    b.tracker.reportInferenceFallback(n);
+            else if (isEntityNameExpression(node, false) && node.parent !== undefined && isDeclaration(node.parent))
+                b.tracker.reportInferenceFallback(node.parent);
+            else
+                b.tracker.reportInferenceFallback(node);
+            if (inferred.isSignatureReturn)
+                return b.serializeReturnTypeForSignatureEx(getSignatureFromDeclaration(c, node), false);
+            const parent = node.parent;
+            // The declaration's type is widened as the checker widens it.
+            if (parent.kind === 254 /* SyntaxKind.ReturnStatement */) {
+                const enclosing = getContainingFunction(node);
+                if (isAccessorKind(enclosing))
+                    return b.serializeTypeForDeclaration(enclosing, undefined, undefined, false);
+                return b.serializeReturnTypeForSignatureEx(getSignatureFromDeclaration(c, enclosing), false);
+            }
+            if (parent.kind === 220 /* SyntaxKind.ArrowFunction */ && getBody(parent) === node)
+                return b.serializeReturnTypeForSignatureEx(getSignatureFromDeclaration(c, parent), false);
+            if (isDeclaration(parent))
+                return b.serializeTypeForDeclaration(parent, undefined, undefined, false);
+            return b.typeToTypeNode(getTypeOfExpressionForPseudo(c, node));
+        }
+        case 2 /* PseudoTypeKind.NoResult */: {
+            const node = t.declaration;
+            b.tracker.reportInferenceFallback(node);
+            if (isFunctionLike(node) && !isAccessorKind(node))
+                return b.serializeReturnTypeForSignatureEx(getSignatureFromDeclaration(c, node), false);
+            return b.serializeTypeForDeclaration(node, undefined, undefined, false);
+        }
+        case 3 /* PseudoTypeKind.MaybeConstLocation */: {
+            const d = t;
+            let inConstContext = isConstContext(c, d.node);
+            if (!inConstContext && isInConstContext(d.node)) {
+                // The contextual type only counts where syntax also finds a const context.
+                const contextualType = getContextualType(c, d.node);
+                const constType = pseudoTypeToType(b, d.constType);
+                if (constType !== undefined &&
+                    isLiteralOfContextualType(c, constType, instantiateContextualType(c, contextualType, d.node, 0 /* ContextFlags.None */)))
+                    inConstContext = true;
+            }
+            return pseudoTypeToNode(b, inConstContext ? d.constType : d.regularType);
+        }
+        case 4 /* PseudoTypeKind.Union */: {
+            const res = [];
+            let hasElidedType = false;
+            let hasUndefined = false;
+            const append = (node) => {
+                if (node === undefined)
+                    return;
+                if (node instanceof UnionTypeNode) {
+                    for (const member of node.types.nodes)
+                        append(member);
+                    return;
+                }
+                if (node.kind === 157 /* SyntaxKind.UndefinedKeyword */) {
+                    if (hasUndefined)
+                        return;
+                    hasUndefined = true;
+                }
+                res.push(node);
+            };
+            for (const m of t.types) {
+                if (!c.strictNullChecks && (m.kind === 5 /* PseudoTypeKind.Undefined */ || m.kind === 6 /* PseudoTypeKind.Null */)) {
+                    hasElidedType = true;
+                    continue;
+                }
+                append(pseudoTypeToNode(b, m));
+            }
+            if (res.length === 1)
+                return res[0];
+            if (res.length === 0)
+                return keyword(b, hasElidedType ? 132 /* SyntaxKind.AnyKeyword */ : 146 /* SyntaxKind.NeverKeyword */);
+            return b.created(new UnionTypeNode(b.list(res)));
+        }
+        case 5 /* PseudoTypeKind.Undefined */:
+            return keyword(b, c.strictNullChecks ? 157 /* SyntaxKind.UndefinedKeyword */ : 132 /* SyntaxKind.AnyKeyword */);
+        case 6 /* PseudoTypeKind.Null */:
+            if (!c.strictNullChecks)
+                return keyword(b, 132 /* SyntaxKind.AnyKeyword */);
+            return b.created(new LiteralTypeNode(b.factory.createKeywordExpression(105 /* SyntaxKind.NullKeyword */)));
+        case 7 /* PseudoTypeKind.Any */:
+            return keyword(b, 132 /* SyntaxKind.AnyKeyword */);
+        case 8 /* PseudoTypeKind.String */:
+            return keyword(b, 154 /* SyntaxKind.StringKeyword */);
+        case 9 /* PseudoTypeKind.Number */:
+            return keyword(b, 150 /* SyntaxKind.NumberKeyword */);
+        case 10 /* PseudoTypeKind.BigInt */:
+            return keyword(b, 163 /* SyntaxKind.BigIntKeyword */);
+        case 11 /* PseudoTypeKind.Boolean */:
+            return keyword(b, 135 /* SyntaxKind.BooleanKeyword */);
+        case 12 /* PseudoTypeKind.False */:
+            return b.created(new LiteralTypeNode(b.factory.createKeywordExpression(96 /* SyntaxKind.FalseKeyword */)));
+        case 13 /* PseudoTypeKind.True */:
+            return b.created(new LiteralTypeNode(b.factory.createKeywordExpression(111 /* SyntaxKind.TrueKeyword */)));
+        case 14 /* PseudoTypeKind.SingleCallSignature */: {
+            const d = t;
+            const signature = getSignatureFromDeclaration(c, d.signature);
+            const expandedParams = getExpandedParameters(c, signature, true)[0];
+            const cleanup = b.enterNewScope(d.signature, expandedParams, signature.typeParameters, signature.parameters, signature.mapper);
+            const typeParams = reuseTypeParameters(b, d.typeParameters);
+            const params = pseudoParametersToNodes(b, d.parameters);
+            const returnType = pseudoTypeToNode(b, d.returnType);
+            cleanup();
+            return b.created(new FunctionTypeNode(typeParams, b.list(params), returnType));
+        }
+        case 15 /* PseudoTypeKind.Tuple */: {
+            const res = [];
+            for (const e of t.elements) {
+                const node = pseudoTypeToNode(b, e);
+                if (node !== undefined)
+                    res.push(node);
+            }
+            // `as const` arrays are readonly.
+            const result = b.created(new TupleTypeNode(b.list(res)));
+            b.context.addEmitFlags(result, 1 /* EmitFlags.SingleLine */);
+            return b.created(new TypeOperatorNode(148 /* SyntaxKind.ReadonlyKeyword */, result));
+        }
+        case 16 /* PseudoTypeKind.ObjectLiteral */:
+            return objectLiteralToNode(b, t);
+        case 17 /* PseudoTypeKind.StringLiteral */:
+        case 18 /* PseudoTypeKind.NumericLiteral */:
+        case 19 /* PseudoTypeKind.BigIntLiteral */: {
+            const reused = reuseNode(b, t.node);
+            return reused === undefined ? undefined : b.created(new LiteralTypeNode(reused));
+        }
+    }
+    return undefined;
+}
+function objectLiteralToNode(b, t) {
+    const c = b.c;
+    const elements = t.members;
+    if (elements.length === 0) {
+        const empty = b.created(new TypeLiteralNode(b.list([])));
+        b.context.addEmitFlags(empty, 1 /* EmitFlags.SingleLine */);
+        return empty;
+    }
+    // The checker's const context, which includes const type parameters' contexts.
+    const isConst = isConstContext(c, elements[0].name.parent.parent);
+    const newElements = [];
+    const savedFlags = b.flags;
+    // As `createTypeNodeFromObjectType`, so inaccessible `this` in members is reported.
+    b.flags |= 4194304 /* NodeBuilderFlags.InObjectTypeLiteral */;
+    for (const e of elements) {
+        const modifiers = isConst || (e.kind === 1 /* PseudoMemberKind.Property */ && e.readonly)
+            ? b.modifierList([b.token(148 /* SyntaxKind.ReadonlyKeyword */)])
+            : undefined;
+        let cleanup = undefined;
+        if (e.kind !== 1 /* PseudoMemberKind.Property */ && e.signature !== undefined) {
+            const signature = getSignatureFromDeclaration(c, e.signature);
+            const expandedParams = getExpandedParameters(c, signature, true)[0];
+            cleanup = b.enterNewScope(e.signature, expandedParams, signature.typeParameters, signature.parameters, signature.mapper);
+        }
+        let newProp;
+        switch (e.kind) {
+            case 0 /* PseudoMemberKind.Method */: {
+                const typeParams = reuseTypeParameters(b, e.typeParameters);
+                if (isConst) {
+                    newProp = b.created(new PropertySignatureDeclaration(modifiers, reuseName(b, e.name, false), undefined, b.created(new FunctionTypeNode(typeParams, b.list(pseudoParametersToNodes(b, e.parameters)), pseudoTypeToNode(b, e.type))), undefined));
+                    break;
+                }
+                newProp = b.created(new MethodSignatureDeclaration(modifiers, reuseName(b, e.name, true), undefined, typeParams, b.list(pseudoParametersToNodes(b, e.parameters)), pseudoTypeToNode(b, e.type)));
+                break;
+            }
+            case 1 /* PseudoMemberKind.Property */:
+                newProp = b.created(new PropertySignatureDeclaration(modifiers, reuseName(b, e.name, false), undefined, pseudoTypeToNode(b, e.type), undefined));
+                break;
+            case 2 /* PseudoMemberKind.SetAccessor */:
+                newProp = b.created(new SetAccessorDeclaration(undefined, reuseName(b, e.name, false), undefined, b.list(e.parameters.length > 0 ? [pseudoParameterToNode(b, e.parameters[0])] : []), undefined, undefined, undefined));
+                break;
+            default:
+                newProp = b.created(new GetAccessorDeclaration(undefined, reuseName(b, e.name, false), undefined, b.list([]), pseudoTypeToNode(b, e.type), undefined, undefined));
+                break;
+        }
+        if (b.enclosingFile === getSourceFileOfNode(e.name)) {
+            const declaration = e.name.parent;
+            b.context.setCommentRange(newProp, declaration.pos, declaration.end);
+        }
+        newElements.push(newProp);
+        if (cleanup !== undefined)
+            cleanup();
+    }
+    b.flags = savedFlags;
+    const result = b.created(new TypeLiteralNode(b.list(newElements)));
+    if ((b.flags & 1024 /* NodeBuilderFlags.MultilineObjectLiterals */) === 0)
+        b.context.addEmitFlags(result, 1 /* EmitFlags.SingleLine */);
+    return result;
+}
+function reuseTypeParameters(b, typeParameters) {
+    if (typeParameters.length === 0)
+        return undefined;
+    const res = [];
+    for (const tp of typeParameters) {
+        const reused = reuseNode(b, tp);
+        if (reused !== undefined)
+            res.push(reused);
+    }
+    return b.list(res);
+}
+function pseudoParametersToNodes(b, params) {
+    const res = [];
+    for (const p of params)
+        res.push(pseudoParameterToNode(b, p));
+    return res;
+}
+function pseudoParameterToNode(b, p) {
+    const original = p.name.parent;
+    const parameter = b.created(new ParameterDeclaration(undefined, p.rest ? b.token(25 /* SyntaxKind.DotDotDotToken */) : undefined, 
+    // Parameter names are always written from scratch.
+    b.parameterToParameterDeclarationName(getSymbol(original), original), p.optional ? b.token(57 /* SyntaxKind.QuestionToken */) : undefined, pseudoTypeToNode(b, p.type), undefined));
+    if (original.kind === 170 /* SyntaxKind.Parameter */)
+        b.setCommentRange(parameter, original);
+    return parameter;
+}
+function reuseNode(b, node) {
+    return tryReuseExistingNode(b, node);
+}
+function reuseName(b, node, isMethod) {
+    const res = reuseNode(b, node);
+    if (res === undefined)
+        return node;
+    const text = tryGetTextOfPropertyName(res);
+    if (text === undefined)
+        return res;
+    const kind = classifyPropertyName(text, res.kind === 10 /* SyntaxKind.StringLiteral */, isMethod);
+    if (res.kind === 79 /* SyntaxKind.Identifier */ && kind === 0 /* PropertyNameKind.Identifier */)
+        return res;
+    if (res.kind === 10 /* SyntaxKind.StringLiteral */ && kind === 2 /* PropertyNameKind.StringLiteral */)
+        return res;
+    let renamed;
+    if (kind === 0 /* PropertyNameKind.Identifier */)
+        renamed = b.identifier(text);
+    else if (kind === 2 /* PropertyNameKind.StringLiteral */)
+        renamed = b.created(new StringLiteral(text, 0 /* TokenFlags.None */));
+    else
+        return res;
+    b.context.setOriginal(renamed, res);
+    return b.setTextRange(renamed, res);
+}
+/** A copy of an annotation; when its names can't be written here, the type it denotes. */
+function reuseTypeNode(b, node) {
+    const r = reuseNode(b, node);
+    if (r !== undefined)
+        return r;
+    b.tracker.reportInferenceFallback(node);
+    const t = b.getTypeFromTypeNode(node, false);
+    return b.typeToTypeNode(t);
+}
+/**
+ * Whether a pseudo-type denotes `type_`. Reports the parts that need inference when
+ * `reportErrors`; an error type matches anything.
+ */
+export function pseudoTypeEquivalentToType(b, t, type_, isOptionalAnnotated, reportErrors) {
+    const c = b.c;
+    if (type_ !== undefined && isErrorType(c, type_))
+        return true;
+    const typeFromPseudo = pseudoTypeToType(b, t);
+    if (typeFromPseudo === type_)
+        return true;
+    let undefinedStripped = type_;
+    if (isOptionalAnnotated && type_ !== undefined)
+        undefinedStripped = getTypeWithFacts(c, type_, 524288 /* TypeFacts.NEUndefined */);
+    if (typeFromPseudo !== undefined && type_ !== undefined) {
+        if (isOptionalAnnotated) {
+            if (undefinedStripped === typeFromPseudo)
+                return true;
+            if ((typeFromPseudo.flags & 134217728 /* TypeFlags.Union */) !== 0 &&
+                (undefinedStripped.flags & 134217728 /* TypeFlags.Union */) !== 0 &&
+                compareTypesIdentical(c, typeFromPseudo, undefinedStripped) === -1 /* Ternary.True */)
+                return true;
+        }
+        // Freshness differs, such as `true` in `as const`.
+        if (getRegularTypeOfLiteralType(c, typeFromPseudo) === getRegularTypeOfLiteralType(c, type_))
+            return true;
+        if ((typeFromPseudo.flags & 134217728 /* TypeFlags.Union */) !== 0 &&
+            (type_.flags & 134217728 /* TypeFlags.Union */) !== 0 &&
+            compareTypesIdentical(c, typeFromPseudo, type_) === -1 /* Ternary.True */)
+            return true;
+    }
+    switch (t.kind) {
+        case 1 /* PseudoTypeKind.Inferred */: {
+            const inferred = t;
+            if (reportErrors) {
+                if (inferred.errorNodes.length > 0)
+                    for (const n of inferred.errorNodes)
+                        b.tracker.reportInferenceFallback(n);
+                else
+                    b.tracker.reportInferenceFallback(inferred.expression);
+            }
+            return false;
+        }
+        case 16 /* PseudoTypeKind.ObjectLiteral */: {
+            if (undefinedStripped === undefined)
+                return false;
+            const pt = t;
+            const targetProps = getPropertiesOfType(c, undefinedStripped);
+            // Accessor pairs are two members but one property.
+            let targetDeclCount = 0;
+            for (const prop of targetProps)
+                targetDeclCount += prop.declarations.length;
+            if (pt.members.length !== targetDeclCount)
+                return false;
+            for (const e of pt.members) {
+                let targetProp = undefined;
+                const elemSymbol = getSymbol(e.name.parent);
+                if (elemSymbol !== undefined)
+                    targetProp = getPropertyOfType(c, undefinedStripped, elemSymbol.name);
+                if (targetProp === undefined) {
+                    for (const prop of targetProps) {
+                        const vd = prop.valueDeclaration;
+                        if (vd !== undefined && getName(vd) === e.name) {
+                            targetProp = prop;
+                            break;
+                        }
+                    }
+                    if (targetProp === undefined) {
+                        if (reportErrors)
+                            b.tracker.reportInferenceFallback(e.name.parent);
+                        return false;
+                    }
+                }
+                const targetIsOptional = (targetProp.flags & 16777216 /* SymbolFlags.Optional */) !== 0;
+                if (e.optional !== targetIsOptional) {
+                    if (reportErrors)
+                        b.tracker.reportInferenceFallback(e.name.parent);
+                    return false;
+                }
+                const propType = removeMissingType(c, getTypeOfSymbol(c, targetProp), targetIsOptional);
+                switch (e.kind) {
+                    case 1 /* PseudoMemberKind.Property */:
+                        if (!pseudoTypeEquivalentToType(b, e.type, propType, e.optional, false)) {
+                            if (reportErrors) {
+                                if (e.type instanceof InferredType && e.type.errorNodes.length > 0)
+                                    for (const n of e.type.errorNodes)
+                                        b.tracker.reportInferenceFallback(n);
+                                else if (!isStructuralPseudoType(e.type))
+                                    b.tracker.reportInferenceFallback(e.name.parent);
+                            }
+                            return false;
+                        }
+                        break;
+                    case 0 /* PseudoMemberKind.Method */: {
+                        const targetSig = getSingleCallSignature(c, propType);
+                        if (targetSig === undefined)
+                            continue;
+                        if (!pseudoParametersEquivalentToParameters(b, e.parameters, targetSig, reportErrors, e.name.parent))
+                            return false;
+                        const targetPredicate = getTypePredicateOfSignature(c, targetSig);
+                        if (targetPredicate !== undefined) {
+                            if (!pseudoReturnTypeMatchesPredicate(b, e.type, targetPredicate)) {
+                                if (reportErrors)
+                                    b.tracker.reportInferenceFallback(e.name.parent);
+                                return false;
+                            }
+                        }
+                        else if (!pseudoTypeEquivalentToType(b, e.type, getReturnTypeOfSignature(c, targetSig), false, false)) {
+                            if (reportErrors)
+                                b.tracker.reportInferenceFallback(e.name.parent);
+                            return false;
+                        }
+                        break;
+                    }
+                    case 3 /* PseudoMemberKind.GetAccessor */:
+                        if (!pseudoTypeEquivalentToType(b, e.type, propType, false, false)) {
+                            if (reportErrors)
+                                b.tracker.reportInferenceFallback(e.name.parent);
+                            return false;
+                        }
+                        break;
+                    case 2 /* PseudoMemberKind.SetAccessor */: {
+                        const writeType = getWriteTypeOfSymbol(c, targetProp);
+                        const parameterType = e.parameters.length > 0 ? e.parameters[0].type : undefined;
+                        if (parameterType === undefined || !pseudoTypeEquivalentToType(b, parameterType, writeType, false, false)) {
+                            if (reportErrors)
+                                b.tracker.reportInferenceFallback(e.name.parent);
+                            return false;
+                        }
+                        break;
+                    }
+                }
+            }
+            return true;
+        }
+        case 15 /* PseudoTypeKind.Tuple */: {
+            if (undefinedStripped === undefined || !isTupleType(undefinedStripped))
+                return false;
+            const pt = t;
+            const tupleTarget = undefinedStripped.target;
+            // `as const` arrays have only required elements.
+            if ((tupleTarget.combinedFlags & 14 /* ElementFlags.NonRequired */) !== 0)
+                return false;
+            const elementTypes = getTypeArguments(c, undefinedStripped);
+            if (pt.elements.length !== elementTypes.length)
+                return false;
+            for (let i = 0; i < pt.elements.length; i++)
+                if (!pseudoTypeEquivalentToType(b, pt.elements[i], elementTypes[i], false, reportErrors))
+                    return false;
+            return true;
+        }
+        case 14 /* PseudoTypeKind.SingleCallSignature */: {
+            if (undefinedStripped === undefined)
+                return false;
+            const targetSig = getSingleCallSignature(c, undefinedStripped);
+            if (targetSig === undefined)
+                return false;
+            const pt = t;
+            const targetTypeParameters = targetSig.typeParameters;
+            if ((targetTypeParameters === undefined ? 0 : targetTypeParameters.length) !== pt.typeParameters.length) {
+                if (reportErrors)
+                    b.tracker.reportInferenceFallback(pt.signature);
+                return false;
+            }
+            if (!pseudoParametersEquivalentToParameters(b, pt.parameters, targetSig, reportErrors, pt.signature))
+                return false;
+            const targetPredicate = getTypePredicateOfSignature(c, targetSig);
+            if (targetPredicate !== undefined) {
+                if (!pseudoReturnTypeMatchesPredicate(b, pt.returnType, targetPredicate)) {
+                    if (reportErrors)
+                        b.tracker.reportInferenceFallback(pt.signature);
+                    return false;
+                }
+            }
+            else if (!pseudoTypeEquivalentToType(b, pt.returnType, getReturnTypeOfSignature(c, targetSig), false, reportErrors))
+                return false;
+            return true;
+        }
+        case 2 /* PseudoTypeKind.NoResult */:
+            if (reportErrors)
+                b.tracker.reportInferenceFallback(t.declaration);
+            return false;
+    }
+    return false;
+}
+function pseudoParametersEquivalentToParameters(b, paramsIn, targetSig, reportErrors, nonParamErrorLocation) {
+    const c = b.c;
+    let params = paramsIn;
+    const thisParameter = targetSig.thisParameter;
+    if (thisParameter !== undefined && params.length === 0) {
+        if (reportErrors)
+            b.tracker.reportInferenceFallback(nonParamErrorLocation);
+        return false;
+    }
+    else if (thisParameter !== undefined && isThisIdentifier(params[0].name)) {
+        const paramType = getTypeOfParameter(c, thisParameter);
+        if (!pseudoTypeEquivalentToType(b, params[0].type, paramType, params[0].optional, false)) {
+            if (reportErrors)
+                b.tracker.reportInferenceFallback(params[0].name.parent);
+            return false;
+        }
+        params = params.slice(1);
+    }
+    else if (thisParameter !== undefined) {
+        if (reportErrors)
+            b.tracker.reportInferenceFallback(nonParamErrorLocation);
+        return false;
+    }
+    if (targetSig.parameters.length !== params.length) {
+        if (reportErrors)
+            b.tracker.reportInferenceFallback(nonParamErrorLocation);
+        return false;
+    }
+    for (let i = 0; i < params.length; i++) {
+        const p = params[i];
+        const targetParam = targetSig.parameters[i];
+        const vd = targetParam.valueDeclaration;
+        if (p.optional !== (vd !== undefined && isOptionalParameter(c, vd))) {
+            if (reportErrors)
+                b.tracker.reportInferenceFallback(p.name.parent);
+            return false;
+        }
+        const paramType = getTypeOfParameter(c, targetParam);
+        if (!pseudoTypeEquivalentToType(b, p.type, paramType, p.optional, false)) {
+            if (reportErrors)
+                b.tracker.reportInferenceFallback(p.name.parent);
+            return false;
+        }
+    }
+    return true;
+}
+function isThisIdentifier(node) {
+    return node instanceof Identifier && getText(node) === 'this';
+}
+function isStructuralPseudoType(t) {
+    switch (t.kind) {
+        case 16 /* PseudoTypeKind.ObjectLiteral */:
+        case 15 /* PseudoTypeKind.Tuple */:
+        case 14 /* PseudoTypeKind.SingleCallSignature */:
+            return true;
+        case 3 /* PseudoTypeKind.MaybeConstLocation */: {
+            const d = t;
+            return isStructuralPseudoType(d.constType) || isStructuralPseudoType(d.regularType);
+        }
+    }
+    return false;
+}
+/** Whether a pseudo return type is a type predicate annotation matching `predicate`. */
+export function pseudoReturnTypeMatchesPredicate(b, rt, predicate) {
+    if (!(rt instanceof DirectType))
+        return false;
+    const node = rt.typeNode;
+    if (!(node instanceof TypePredicateNode))
+        return false;
+    const isAsserts = node.assertsModifier !== undefined;
+    const predicateIsAsserts = predicate.kind === 2 /* TypePredicateKind.AssertsThis */ || predicate.kind === 3 /* TypePredicateKind.AssertsIdentifier */;
+    if (isAsserts !== predicateIsAsserts)
+        return false;
+    const isThis = node.parameterName.kind === 198 /* SyntaxKind.ThisType */;
+    const predicateIsThis = predicate.kind === 0 /* TypePredicateKind.This */ || predicate.kind === 2 /* TypePredicateKind.AssertsThis */;
+    if (isThis !== predicateIsThis)
+        return false;
+    if (!isThis && getText(node.parameterName) !== predicate.parameterName)
+        return false;
+    if (predicate.type !== undefined) {
+        if (node.type === undefined)
+            return false;
+        const fromNode = getTypeFromTypeNode(b.c, node.type);
+        if (fromNode !== predicate.type && compareTypesIdentical(b.c, fromNode, predicate.type) !== -1 /* Ternary.True */)
+            return false;
+    }
+    else if (node.type !== undefined)
+        return false;
+    return true;
+}
+function getTypeOfExpressionForPseudo(c, node) {
+    return checkExpressionCached(c, node);
+}
+/** The type a pseudo-type denotes, for the kinds that map to one directly. */
+export function pseudoTypeToType(b, t) {
+    const c = b.c;
+    switch (t.kind) {
+        case 0 /* PseudoTypeKind.Direct */:
+            return getTypeFromTypeNode(c, t.typeNode);
+        case 1 /* PseudoTypeKind.Inferred */: {
+            const inferred = t;
+            if (inferred.isSignatureReturn)
+                return getReturnTypeOfSignature(c, getSignatureFromDeclaration(c, inferred.expression));
+            return getWidenedType(c, getRegularTypeOfExpression(c, inferred.expression));
+        }
+        case 2 /* PseudoTypeKind.NoResult */:
+            return undefined;
+        case 3 /* PseudoTypeKind.MaybeConstLocation */: {
+            const d = t;
+            return pseudoTypeToType(b, isConstContext(c, d.node) ? d.constType : d.regularType);
+        }
+        case 4 /* PseudoTypeKind.Union */: {
+            const res = [];
+            let hasElidedType = false;
+            for (const m of t.types) {
+                if (!c.strictNullChecks && (m.kind === 5 /* PseudoTypeKind.Undefined */ || m.kind === 6 /* PseudoTypeKind.Null */)) {
+                    hasElidedType = true;
+                    continue;
+                }
+                const mt = pseudoTypeToType(b, m);
+                if (mt === undefined)
+                    return undefined;
+                res.push(mt);
+            }
+            if (res.length === 1)
+                return res[0];
+            if (res.length === 0)
+                return hasElidedType ? c.anyType : c.neverType;
+            return getUnionType(c, res);
+        }
+        case 5 /* PseudoTypeKind.Undefined */:
+            return c.undefinedWideningType;
+        case 6 /* PseudoTypeKind.Null */:
+            return c.nullWideningType;
+        case 7 /* PseudoTypeKind.Any */:
+            return c.anyType;
+        case 8 /* PseudoTypeKind.String */:
+            return c.stringType;
+        case 9 /* PseudoTypeKind.Number */:
+            return c.numberType;
+        case 10 /* PseudoTypeKind.BigInt */:
+            return c.bigintType;
+        case 11 /* PseudoTypeKind.Boolean */:
+            return c.booleanType;
+        case 12 /* PseudoTypeKind.False */:
+            return c.falseType;
+        case 13 /* PseudoTypeKind.True */:
+            return c.trueType;
+        case 17 /* PseudoTypeKind.StringLiteral */:
+        case 18 /* PseudoTypeKind.NumericLiteral */:
+        case 19 /* PseudoTypeKind.BigIntLiteral */:
+            return getRegularTypeOfExpression(c, t.node);
+    }
+    return undefined;
+}
+/**
+ * Whether the type written for a parameter or property needs `| undefined`: a parameter
+ * initialized before a required one, or an optional property of a reverse mapped type.
+ */
+export function requiresAddingImplicitUndefinedForDeclaration(c, declaration, symbolIn, enclosingDeclaration) {
+    if ((declaration.flags & 16 /* NodeFlags.Synthesized */) !== 0)
+        return false;
+    switch (declaration.kind) {
+        case 173 /* SyntaxKind.PropertyDeclaration */:
+        case 172 /* SyntaxKind.PropertySignature */:
+        case 340 /* SyntaxKind.JSDocPropertyTag */: {
+            const symbol = symbolIn ?? getSymbolOfDeclaration(c, declaration);
+            if (symbol === undefined)
+                return false;
+            const t = getTypeOfSymbol(c, symbol);
+            return ((symbol.flags & 4 /* SymbolFlags.Property */) !== 0 &&
+                (symbol.flags & 16777216 /* SymbolFlags.Optional */) !== 0 &&
+                hasQuestionToken(declaration) &&
+                (symbol.checkFlags & 8192 /* CheckFlags.ReverseMapped */) !== 0 &&
+                c.symbolLinks(symbol).reverseMappedMappedType !== undefined &&
+                containsNonMissingUndefinedType(c, t));
+        }
+        case 170 /* SyntaxKind.Parameter */:
+            return requiresAddingImplicitUndefined(c, declaration, enclosingDeclaration);
+    }
+    return false;
+}
+/** Declarations whose type the builder writes from the declaration, as tsgo's `HasInferredType`. */
+export function hasInferredTypeKind(node) {
+    switch (node.kind) {
+        case 170 /* SyntaxKind.Parameter */:
+        case 172 /* SyntaxKind.PropertySignature */:
+        case 173 /* SyntaxKind.PropertyDeclaration */:
+        case 209 /* SyntaxKind.BindingElement */:
+        case 212 /* SyntaxKind.PropertyAccessExpression */:
+        case 213 /* SyntaxKind.ElementAccessExpression */:
+        case 227 /* SyntaxKind.BinaryExpression */:
+        case 214 /* SyntaxKind.CallExpression */:
+        case 261 /* SyntaxKind.VariableDeclaration */:
+        case 278 /* SyntaxKind.ExportAssignment */:
+        case 303 /* SyntaxKind.PropertyAssignment */:
+        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+        case 333 /* SyntaxKind.JSDocParameterTag */:
+        case 340 /* SyntaxKind.JSDocPropertyTag */:
+            return true;
+    }
+    return false;
+}
+export function isAccessorKind(node) {
+    return node.kind === 178 /* SyntaxKind.GetAccessor */ || node.kind === 179 /* SyntaxKind.SetAccessor */;
+}
+/** Whether a declaration is marked optional with `?`, as tsgo's `HasQuestionToken`. */
+export function hasQuestionToken(node) {
+    const token = getQuestionToken(node) ?? getPostfixToken(node);
+    return token !== undefined && token.kind === 57 /* SyntaxKind.QuestionToken */;
+}