tsc-ts 0.0.4 → 0.0.5

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

@@ -0,0 +1,290 @@
+// Error elaboration: assignability errors reported on the innermost part of an expression (an
+// object literal property, an array literal element or an arrow function's returned expression).
+import { getEffectiveCheckNode } from './ast-utilities.js';
+import { getElements, getExpression, getName, getParameters, getProperties, getType, } from './ast.js';
+import { getSourceFileOfNode } from './binder-utilities.js';
+import { createDiagnosticForNode } from './checker.js';
+import { getNumberLiteralType, getUnionType, isTupleType, typesOf } from './checker-type-factory.js';
+import { getApplicableIndexInfo, getPropertyOfType, getSignaturesOfType, getTypeOfPropertyOfType, } from './checker-members.js';
+import { getReturnTypeOfSignature, getSingleCallSignature } from './checker-signatures.js';
+import { removeMissingType } from './checker-symbol-types.js';
+import { getIndexedAccessTypeOrUndefined, getLiteralTypeFromProperty, getPropertyNameFromIndex, } from './checker-type-operators.js';
+import { getPropertyNameFromType, isTypeUsableAsPropertyName } from './checker-utilities.js';
+import { checkTypeRelatedTo, getBestMatchingTypeForElaboration, isExactOptionalPropertyMismatch, isTypeRelatedTo, } from './relations.js';
+import { checkExpressionEx, checkExpressionForMutableLocationEx, isConstTypeReference } from './checker-expressions.js';
+import { popContextualType, pushContextualType } from './checker-contextual.js';
+import { getSymbolOfDeclaration } from './checker-symbols.js';
+import { createPromiseType } from './checker-iteration.js';
+import { getFunctionFlags } from './checker-utilities.js';
+import { typeToString } from './type-printer.js';
+import { elaborateJsxComponents } from './checker-jsx.js';
+/** Checks that `source` relates to `target`, elaborating into `expr` when possible. */
+export function checkTypeRelatedToAndOptionallyElaborate(c, source, target, relation, errorNode, expr, headMessage, diagnosticOutput) {
+    if (isTypeRelatedTo(c, source, target, relation))
+        return true;
+    if (errorNode !== undefined && !elaborateError(c, expr, source, target, relation, headMessage, diagnosticOutput))
+        return checkTypeRelatedTo(c, source, target, relation, errorNode, headMessage, diagnosticOutput);
+    return false;
+}
+function reportDiagnostic(c, diagnostic, output) {
+    if (output !== undefined)
+        output.push(diagnostic);
+    else
+        c.addDiagnostic(diagnostic);
+}
+export function elaborateError(c, node, source, target, relation, headMessage, diagnosticOutput) {
+    if (node === undefined || isOrHasGenericConditional(target))
+        return false;
+    if (elaborateDidYouMeanToCallOrConstruct(c, node, source, target, relation, 1 /* SignatureKind.Construct */, headMessage, diagnosticOutput) ||
+        elaborateDidYouMeanToCallOrConstruct(c, node, source, target, relation, 0 /* SignatureKind.Call */, headMessage, diagnosticOutput))
+        return true;
+    switch (node.kind) {
+        case 235 /* SyntaxKind.AsExpression */:
+            if (!isConstAssertion(node))
+                break;
+            return elaborateError(c, getExpression(node), source, target, relation, headMessage, diagnosticOutput);
+        case 295 /* SyntaxKind.JsxExpression */:
+        case 218 /* SyntaxKind.ParenthesizedExpression */:
+            return elaborateError(c, getExpression(node), source, target, relation, headMessage, diagnosticOutput);
+        case 227 /* SyntaxKind.BinaryExpression */: {
+            const binary = node;
+            const op = binary.operatorToken.kind;
+            if (op === 63 /* SyntaxKind.EqualsToken */ || op === 27 /* SyntaxKind.CommaToken */)
+                return elaborateError(c, binary.right, source, target, relation, headMessage, diagnosticOutput);
+            break;
+        }
+        case 211 /* SyntaxKind.ObjectLiteralExpression */:
+            return elaborateObjectLiteral(c, node, source, target, relation, diagnosticOutput);
+        case 210 /* SyntaxKind.ArrayLiteralExpression */:
+            return elaborateArrayLiteral(c, node, source, target, relation, diagnosticOutput);
+        case 220 /* SyntaxKind.ArrowFunction */:
+            return elaborateArrowFunction(c, node, source, target, relation, diagnosticOutput);
+        case 293 /* SyntaxKind.JsxAttributes */:
+            return elaborateJsxComponents(c, node, source, target, relation, diagnosticOutput);
+    }
+    return false;
+}
+function isConstAssertion(node) {
+    const typeNode = getType(node);
+    return typeNode !== undefined && isConstTypeReference(typeNode);
+}
+function isOrHasGenericConditional(t) {
+    if ((t.flags & 67108864 /* TypeFlags.Conditional */) !== 0)
+        return true;
+    if ((t.flags & 268435456 /* TypeFlags.Intersection */) !== 0)
+        for (const u of typesOf(t))
+            if (isOrHasGenericConditional(u))
+                return true;
+    return false;
+}
+function elaborateDidYouMeanToCallOrConstruct(c, node, source, target, relation, kind, headMessage, diagnosticOutput) {
+    let callable = false;
+    for (const s of getSignaturesOfType(c, source, kind)) {
+        const returnType = getReturnTypeOfSignature(c, s);
+        if ((returnType.flags & (1 /* TypeFlags.Any */ | 262144 /* TypeFlags.Never */)) === 0 &&
+            checkTypeRelatedTo(c, returnType, target, relation, undefined, undefined, undefined)) {
+            callable = true;
+            break;
+        }
+    }
+    if (!callable)
+        return false;
+    const diagnostics = [];
+    if (checkTypeRelatedTo(c, source, target, relation, node, headMessage, diagnostics))
+        return false;
+    const diagnostic = diagnostics[0];
+    diagnostic.addRelatedInfo(createDiagnosticForNode(node, kind === 1 /* SignatureKind.Construct */
+        ? 1366 /* Diagnostics.Did_you_mean_to_use_new_with_this_expression */
+        : 1365 /* Diagnostics.Did_you_mean_to_call_this_expression */, []));
+    reportDiagnostic(c, diagnostic, diagnosticOutput);
+    return true;
+}
+function elaborateObjectLiteral(c, node, source, target, relation, diagnosticOutput) {
+    if ((target.flags & (12713980 /* TypeFlags.Primitive */ | 262144 /* TypeFlags.Never */)) !== 0)
+        return false;
+    let reportedError = false;
+    for (const prop of getProperties(node).nodes) {
+        if (prop.kind === 305 /* SyntaxKind.SpreadAssignment */)
+            continue;
+        const symbol = getSymbolOfDeclaration(c, prop);
+        if (symbol === undefined)
+            continue;
+        const nameType = getLiteralTypeFromProperty(c, symbol, 19456 /* TypeFlags.StringOrNumberLiteralOrUnique */, false);
+        if ((nameType.flags & 262144 /* TypeFlags.Never */) !== 0)
+            continue;
+        switch (prop.kind) {
+            case 179 /* SyntaxKind.SetAccessor */:
+            case 178 /* SyntaxKind.GetAccessor */:
+            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+                reportedError =
+                    elaborateElement(c, source, target, relation, getName(prop), undefined, nameType, undefined, undefined, [], diagnosticOutput) || reportedError;
+                break;
+            case 303 /* SyntaxKind.PropertyAssignment */: {
+                const name = getName(prop);
+                const message = isComputedNonLiteralName(name)
+                    ? 589 /* Diagnostics.Type_of_computed_property_s_value_is_0_which_is_not_assignable_to_type_1 */
+                    : undefined;
+                reportedError =
+                    elaborateElement(c, source, target, relation, name, prop.initializer, nameType, message, undefined, [], diagnosticOutput) || reportedError;
+                break;
+            }
+        }
+    }
+    return reportedError;
+}
+function isComputedNonLiteralName(name) {
+    if (name.kind !== 168 /* SyntaxKind.ComputedPropertyName */)
+        return false;
+    const expression = getExpression(name);
+    return expression.kind !== 10 /* SyntaxKind.StringLiteral */ && expression.kind !== 8 /* SyntaxKind.NumericLiteral */;
+}
+function isTupleLikeType(c, t) {
+    return isTupleType(t) || getPropertyOfType(c, t, '0') !== undefined;
+}
+function elaborateArrayLiteral(c, node, source, target, relation, diagnosticOutput) {
+    if ((target.flags & (12713980 /* TypeFlags.Primitive */ | 262144 /* TypeFlags.Never */)) !== 0)
+        return false;
+    if (!isTupleLikeType(c, source)) {
+        pushContextualType(c, node, target, false);
+        source = checkExpressionEx(c, node, 1 /* CheckMode.Contextual */ | 128 /* CheckMode.ForceTuple */);
+        popContextualType(c);
+        if (!isTupleLikeType(c, source))
+            return false;
+    }
+    let reportedError = false;
+    const elements = getElements(node).nodes;
+    for (let i = 0; i < elements.length; i++) {
+        const element = elements[i];
+        if (element.kind === 233 /* SyntaxKind.OmittedExpression */ ||
+            (isTupleLikeType(c, target) && getPropertyOfType(c, target, String(i)) === undefined))
+            continue;
+        const checkNode = getEffectiveCheckNode(element);
+        reportedError =
+            elaborateElement(c, source, target, relation, checkNode, checkNode, getNumberLiteralType(c, i), undefined, undefined, [], diagnosticOutput) || reportedError;
+    }
+    return reportedError;
+}
+/**
+ * Elaborates the element `nameType` of `source` against `target`, reporting at `prop`. With `customMessage`,
+ * that message is reported instead of the relation error.
+ */
+export function elaborateElement(c, source, target, relation, prop, next, nameType, errorMessage, customMessage, customArgs, diagnosticOutput) {
+    let targetPropType = getBestMatchIndexedAccessTypeOrUndefined(c, source, target, nameType);
+    // Don't elaborate on indexes on generic variables.
+    if (targetPropType === undefined || (targetPropType.flags & 33554432 /* TypeFlags.IndexedAccess */) !== 0)
+        return false;
+    let sourcePropType = getIndexedAccessTypeOrUndefined(c, source, nameType, 0 /* AccessFlags.None */);
+    if (sourcePropType === undefined ||
+        checkTypeRelatedTo(c, sourcePropType, targetPropType, relation, undefined, undefined, undefined))
+        return false;
+    if (next !== undefined &&
+        elaborateError(c, next, sourcePropType, targetPropType, relation, undefined, diagnosticOutput))
+        return true;
+    // The property couldn't elaborate, so the error goes on the property itself, with the expression's type.
+    const diagnostics = [];
+    const specificSource = next !== undefined ? checkExpressionForMutableLocationWithContextualType(c, next, sourcePropType) : sourcePropType;
+    if (customMessage !== undefined)
+        diagnostics.push(createDiagnosticForNode(prop, customMessage, customArgs));
+    else if (c.exactOptionalPropertyTypes && isExactOptionalPropertyMismatch(c, specificSource, targetPropType))
+        diagnostics.push(createDiagnosticForNode(prop, 583 /* Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_type_of_the_target */, [typeToString(c, specificSource), typeToString(c, targetPropType)]));
+    else {
+        const propName = getPropertyNameFromIndex(nameType);
+        const targetProperty = propName !== undefined ? getPropertyOfType(c, target, propName) : undefined;
+        const sourceProperty = propName !== undefined ? getPropertyOfType(c, source, propName) : undefined;
+        const targetIsOptional = targetProperty !== undefined && (targetProperty.flags & 16777216 /* SymbolFlags.Optional */) !== 0;
+        const sourceIsOptional = sourceProperty !== undefined && (sourceProperty.flags & 16777216 /* SymbolFlags.Optional */) !== 0;
+        targetPropType = removeMissingType(c, targetPropType, targetIsOptional);
+        sourcePropType = removeMissingType(c, sourcePropType, targetIsOptional && sourceIsOptional);
+        const result = checkTypeRelatedTo(c, specificSource, targetPropType, relation, prop, errorMessage, diagnostics);
+        // When the expression type doesn't fail, the property type still must.
+        if (result && specificSource !== sourcePropType)
+            checkTypeRelatedTo(c, sourcePropType, targetPropType, relation, prop, errorMessage, diagnostics);
+    }
+    if (diagnostics.length === 0)
+        return false;
+    const diagnostic = diagnostics[0];
+    let propertyName = '';
+    let targetProp = undefined;
+    if (isTypeUsableAsPropertyName(nameType)) {
+        propertyName = getPropertyNameFromType(nameType);
+        targetProp = getPropertyOfType(c, target, propertyName);
+    }
+    let issuedElaboration = false;
+    if (targetProp === undefined) {
+        const indexInfo = getApplicableIndexInfo(c, target, nameType);
+        if (indexInfo !== undefined &&
+            indexInfo.declaration !== undefined &&
+            !c.host.isSourceFileDefaultLibrary(getSourceFileOfNode(indexInfo.declaration))) {
+            issuedElaboration = true;
+            diagnostic.addRelatedInfo(createDiagnosticForNode(indexInfo.declaration, 1516 /* Diagnostics.The_expected_type_comes_from_this_index_signature */, []));
+        }
+    }
+    if (!issuedElaboration &&
+        ((targetProp !== undefined && targetProp.declarations.length !== 0) ||
+            (target.symbol !== undefined && target.symbol.declarations.length !== 0))) {
+        const targetNode = targetProp !== undefined && targetProp.declarations.length !== 0
+            ? targetProp.declarations[0]
+            : target.symbol.declarations[0];
+        if (propertyName === '' || (nameType.flags & 16384 /* TypeFlags.UniqueESSymbol */) !== 0)
+            propertyName = typeToString(c, nameType);
+        if (!c.host.isSourceFileDefaultLibrary(getSourceFileOfNode(targetNode)))
+            diagnostic.addRelatedInfo(createDiagnosticForNode(targetNode, 1515 /* Diagnostics.The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1 */, [propertyName, typeToString(c, target)]));
+    }
+    reportDiagnostic(c, diagnostic, diagnosticOutput);
+    return true;
+}
+export function getBestMatchIndexedAccessTypeOrUndefined(c, source, target, nameType) {
+    const idx = getIndexedAccessTypeOrUndefined(c, target, nameType, 0 /* AccessFlags.None */);
+    if (idx !== undefined)
+        return idx;
+    if ((target.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+        const best = getBestMatchingTypeForElaboration(c, source, target);
+        if (best !== undefined)
+            return getIndexedAccessTypeOrUndefined(c, best, nameType, 0 /* AccessFlags.None */);
+    }
+    return undefined;
+}
+export function checkExpressionForMutableLocationWithContextualType(c, next, sourcePropType) {
+    pushContextualType(c, next, sourcePropType, false);
+    const result = checkExpressionForMutableLocationEx(c, next, 1 /* CheckMode.Contextual */);
+    popContextualType(c);
+    return result;
+}
+function elaborateArrowFunction(c, node, source, target, relation, diagnosticOutput) {
+    // Blocks and functions with annotated parameters aren't elaborated.
+    if (node.body.kind === 242 /* SyntaxKind.Block */)
+        return false;
+    for (const p of getParameters(node).nodes)
+        if (getType(p) !== undefined)
+            return false;
+    const sourceSig = getSingleCallSignature(c, source);
+    if (sourceSig === undefined)
+        return false;
+    const targetSignatures = getSignaturesOfType(c, target, 0 /* SignatureKind.Call */);
+    if (targetSignatures.length === 0)
+        return false;
+    const returnExpression = node.body;
+    const sourceReturn = getReturnTypeOfSignature(c, sourceSig);
+    const targetReturnTypes = [];
+    for (const s of targetSignatures)
+        targetReturnTypes.push(getReturnTypeOfSignature(c, s));
+    const targetReturn = getUnionType(c, targetReturnTypes);
+    if (checkTypeRelatedTo(c, sourceReturn, targetReturn, relation, undefined, undefined, undefined))
+        return false;
+    if (elaborateError(c, returnExpression, sourceReturn, targetReturn, relation, undefined, diagnosticOutput))
+        return true;
+    const diagnostics = [];
+    checkTypeRelatedTo(c, sourceReturn, targetReturn, relation, returnExpression, undefined, diagnostics);
+    if (diagnostics.length === 0)
+        return false;
+    const diagnostic = diagnostics[0];
+    if (target.symbol !== undefined && target.symbol.declarations.length !== 0)
+        diagnostic.addRelatedInfo(createDiagnosticForNode(target.symbol.declarations[0], 1517 /* Diagnostics.The_expected_type_comes_from_the_return_type_of_this_signature */, []));
+    if ((getFunctionFlags(node) & 2 /* FunctionFlags.Async */) === 0 &&
+        getTypeOfPropertyOfType(c, sourceReturn, 'then') === undefined &&
+        checkTypeRelatedTo(c, createPromiseType(c, sourceReturn), targetReturn, relation, undefined, undefined, undefined))
+        diagnostic.addRelatedInfo(createDiagnosticForNode(node, 290 /* Diagnostics.Did_you_mean_to_mark_this_function_as_async */, []));
+    reportDiagnostic(c, diagnostic, diagnosticOutput);
+    return true;
+}

package/dist/api/compiler/checker-emit-helpers.d.ts

@@ -0,0 +1,58 @@
+import type { Node, SourceFile } from './ast.js';
+import type { Checker } from './checker.js';
+import { type Symbol } from './symbol.js';
+/** The emit helpers tslib provides, in tsgo's order (which orders the errors one check reports). */
+export declare const enum ExternalEmitHelpers {
+    None = 0,
+    Rest = 1,
+    Decorate = 2,
+    Metadata = 4,
+    Param = 8,
+    Awaiter = 16,
+    Await = 32,
+    AsyncGenerator = 64,
+    AsyncDelegator = 128,
+    AsyncValues = 256,
+    ExportStar = 512,
+    ImportStar = 1024,
+    ImportDefault = 2048,
+    MakeTemplateObject = 4096,
+    ClassPrivateFieldGet = 8192,
+    ClassPrivateFieldSet = 16384,
+    ClassPrivateFieldIn = 32768,
+    SetFunctionName = 65536,
+    PropKey = 131072,
+    AddDisposableResourceAndDisposeResources = 262144,
+    RewriteRelativeImportExtension = 524288,
+    /** __esDecorate and __runInitializers, for ECMAScript decorators. */
+    ESDecorateAndRunInitializers = 2,
+    FirstEmitHelper = 1,
+    LastEmitHelper = 524288,
+    /** for await..of before ES2018. */
+    ForAwaitOfIncludes = 256,
+    /** Async generators before ES2018. */
+    AsyncGeneratorIncludes = 96,
+    /** `yield*` in async generators before ES2018. */
+    AsyncDelegatorIncludes = 416
+}
+/** A helper check for a node of a file that the checker checks later (checkExternalEmitHelpers). */
+declare class PendingHelperCheck {
+    readonly location: Node;
+    readonly helpers: ExternalEmitHelpers;
+    constructor(location: Node, helpers: ExternalEmitHelpers);
+}
+/** A file's tslib module, the helpers checked against it so far, and checks waiting for the file's own check. */
+export declare class EmitHelperFileLinks {
+    helpersModule: Symbol | undefined;
+    requestedHelpers: number;
+    pending: PendingHelperCheck[];
+}
+/**
+ * Under --importHelpers, the emit of the syntax at `location` calls `helpers` from tslib. Reports TS2354 when
+ * tslib can't be resolved (once per file), and TS2343 or TS2807 for a helper tslib lacks or has with too few
+ * parameters.
+ */
+export declare function checkExternalEmitHelpers(c: Checker, location: Node, helpers: ExternalEmitHelpers): void;
+/** Runs the helper checks for nodes of `file` that were reached while checking later files. */
+export declare function checkPendingExternalEmitHelpers(c: Checker, file: SourceFile): void;
+export {};

package/dist/api/compiler/checker-emit-helpers.js

@@ -0,0 +1,154 @@
+import { getSourceFileOfNode, isExternalModule } from './binder-utilities.js';
+import { resolveExternalModule } from './checker-modules.js';
+import { getParameterCount, getSignaturesOfSymbol } from './checker-signatures.js';
+import { getExportsOfModule, getSymbolOfMeaning, resolveSymbol } from './checker-symbols.js';
+import { ModuleKind, getEmitModuleKind } from './options.js';
+/** A helper check for a node of a file that the checker checks later (checkExternalEmitHelpers). */
+class PendingHelperCheck {
+    location;
+    helpers;
+    constructor(location, helpers) {
+        this.location = location;
+        this.helpers = helpers;
+    }
+}
+/** A file's tslib module, the helpers checked against it so far, and checks waiting for the file's own check. */
+export class EmitHelperFileLinks {
+    helpersModule = undefined;
+    requestedHelpers = 0 /* ExternalEmitHelpers.None */;
+    pending = [];
+}
+function fileLinks(c, file) {
+    let links = c.emitHelperFileLinks.get(file);
+    if (links === undefined) {
+        links = new EmitHelperFileLinks();
+        c.emitHelperFileLinks.set(file, links);
+    }
+    return links;
+}
+/**
+ * Under --importHelpers, the emit of the syntax at `location` calls `helpers` from tslib. Reports TS2354 when
+ * tslib can't be resolved (once per file), and TS2343 or TS2807 for a helper tslib lacks or has with too few
+ * parameters.
+ */
+export function checkExternalEmitHelpers(c, location, helpers) {
+    if (c.compilerOptions.importHelpers !== true)
+        return;
+    const file = getSourceFileOfNode(location);
+    if (!isEffectiveExternalModule(c, file) || (location.flags & 8388608 /* NodeFlags.Ambient */) !== 0)
+        return;
+    // TS2354 and each TS2343 are reported once per file, at the first syntax checked that needs the helper. A
+    // checker checks files out of program order, so a check for an earlier file, reached from a later one,
+    // waits for the earlier file's own check, as when files are checked in program order.
+    const checking = c.fileBeingChecked;
+    if (checking !== undefined && checking !== file && !c.nodeLinks(file).typeChecked) {
+        const fileIndex = c.fileIndex.get(file);
+        const checkingIndex = c.fileIndex.get(checking);
+        if (fileIndex !== undefined && checkingIndex !== undefined && fileIndex < checkingIndex) {
+            fileLinks(c, file).pending.push(new PendingHelperCheck(location, helpers));
+            return;
+        }
+    }
+    const helpersModule = resolveHelpersModule(c, file, location);
+    if (helpersModule === c.unknownSymbol)
+        return;
+    const links = fileLinks(c, file);
+    const unchecked = helpers & ~links.requestedHelpers;
+    if (unchecked !== 0) {
+        for (let helper = 1 /* ExternalEmitHelpers.FirstEmitHelper */; helper <= 524288 /* ExternalEmitHelpers.LastEmitHelper */; helper <<= 1) {
+            if ((unchecked & helper) === 0)
+                continue;
+            for (const name of getHelperNames(c, helper)) {
+                const symbol = resolveSymbol(c, getSymbolOfMeaning(c, getExportsOfModule(c, helpersModule), name, 111551 /* SymbolFlags.Value */));
+                if (symbol === undefined)
+                    c.error(location, 519 /* Diagnostics.This_syntax_requires_an_imported_helper_named_1_which_does_not_exist_in_0_Consider_upgrading_your_version_of_0 */, 'tslib', name);
+                else if ((helper & 8192 /* ExternalEmitHelpers.ClassPrivateFieldGet */) !== 0) {
+                    if (!hasSignatureWithArityGreaterThan(c, symbol, 3))
+                        c.error(location, 938 /* Diagnostics.This_syntax_requires_an_imported_helper_named_1_with_2_parameters_which_is_not_compatible_with_the_one_in_0_Consider_upgrading_your_version_of_0 */, 'tslib', name, '4');
+                }
+                else if ((helper & 16384 /* ExternalEmitHelpers.ClassPrivateFieldSet */) !== 0) {
+                    if (!hasSignatureWithArityGreaterThan(c, symbol, 4))
+                        c.error(location, 938 /* Diagnostics.This_syntax_requires_an_imported_helper_named_1_with_2_parameters_which_is_not_compatible_with_the_one_in_0_Consider_upgrading_your_version_of_0 */, 'tslib', name, '5');
+                }
+            }
+        }
+    }
+    links.requestedHelpers |= helpers;
+}
+/** Runs the helper checks for nodes of `file` that were reached while checking later files. */
+export function checkPendingExternalEmitHelpers(c, file) {
+    const links = c.emitHelperFileLinks.get(file);
+    if (links === undefined || links.pending.length === 0)
+        return;
+    const pending = links.pending;
+    links.pending = [];
+    for (const check of pending)
+        checkExternalEmitHelpers(c, check.location, check.helpers);
+}
+/** A module file, or a file the module kind treats as CommonJS when it uses `require` or `exports`. */
+function isEffectiveExternalModule(c, file) {
+    if (isExternalModule(file))
+        return true;
+    const moduleKind = getEmitModuleKind(c.compilerOptions);
+    const commonJSContaining = moduleKind === ModuleKind.CommonJS || (moduleKind >= ModuleKind.Node16 && moduleKind <= ModuleKind.NodeNext);
+    return commonJSContaining && file.commonJSModuleIndicator !== undefined;
+}
+function hasSignatureWithArityGreaterThan(c, symbol, arity) {
+    for (const signature of getSignaturesOfSymbol(c, symbol))
+        if (getParameterCount(c, signature) > arity)
+            return true;
+    return false;
+}
+/** The tslib module for `file`, or the unknown symbol; resolved once per file, reporting TS2354 at `errorNode`. */
+function resolveHelpersModule(c, file, errorNode) {
+    const links = fileLinks(c, file);
+    if (links.helpersModule === undefined)
+        links.helpersModule =
+            resolveExternalModule(c, c.host.getImportHelpersImportSpecifier(file) ?? errorNode, 'tslib', 530 /* Diagnostics.This_syntax_requires_an_imported_helper_but_module_0_cannot_be_found */, errorNode, false) ?? c.unknownSymbol;
+    return links.helpersModule;
+}
+function getHelperNames(c, helper) {
+    switch (helper) {
+        case 1 /* ExternalEmitHelpers.Rest */:
+            return ['__rest'];
+        case 2 /* ExternalEmitHelpers.Decorate */:
+            return c.legacyDecorators ? ['__decorate'] : ['__esDecorate', '__runInitializers'];
+        case 4 /* ExternalEmitHelpers.Metadata */:
+            return ['__metadata'];
+        case 8 /* ExternalEmitHelpers.Param */:
+            return ['__param'];
+        case 16 /* ExternalEmitHelpers.Awaiter */:
+            return ['__awaiter'];
+        case 32 /* ExternalEmitHelpers.Await */:
+            return ['__await'];
+        case 64 /* ExternalEmitHelpers.AsyncGenerator */:
+            return ['__asyncGenerator'];
+        case 128 /* ExternalEmitHelpers.AsyncDelegator */:
+            return ['__asyncDelegator'];
+        case 256 /* ExternalEmitHelpers.AsyncValues */:
+            return ['__asyncValues'];
+        case 512 /* ExternalEmitHelpers.ExportStar */:
+            return ['__exportStar'];
+        case 1024 /* ExternalEmitHelpers.ImportStar */:
+            return ['__importStar'];
+        case 2048 /* ExternalEmitHelpers.ImportDefault */:
+            return ['__importDefault'];
+        case 4096 /* ExternalEmitHelpers.MakeTemplateObject */:
+            return ['__makeTemplateObject'];
+        case 8192 /* ExternalEmitHelpers.ClassPrivateFieldGet */:
+            return ['__classPrivateFieldGet'];
+        case 16384 /* ExternalEmitHelpers.ClassPrivateFieldSet */:
+            return ['__classPrivateFieldSet'];
+        case 32768 /* ExternalEmitHelpers.ClassPrivateFieldIn */:
+            return ['__classPrivateFieldIn'];
+        case 65536 /* ExternalEmitHelpers.SetFunctionName */:
+            return ['__setFunctionName'];
+        case 131072 /* ExternalEmitHelpers.PropKey */:
+            return ['__propKey'];
+        case 262144 /* ExternalEmitHelpers.AddDisposableResourceAndDisposeResources */:
+            return ['__addDisposableResource', '__disposeResources'];
+        case 524288 /* ExternalEmitHelpers.RewriteRelativeImportExtension */:
+            return ['__rewriteRelativeImportExtension'];
+    }
+    return [];
+}

package/dist/api/compiler/checker-emit-resolver.d.ts

@@ -0,0 +1,75 @@
+import { type EntityName, type FileReference, type Identifier, type ImportDeclaration, ModifierFlags, type Node, SourceFile } from './ast.js';
+import type { Checker } from './checker.js';
+import type { CompilerOptions, ModuleKind } from './options.js';
+import type { EmitContext } from './printer/emit-context.js';
+import { type Symbol, SymbolFlags } from './symbol.js';
+import { DeclarationEmitResolver, NodeBuilderFlags, type SymbolAccessibilityResult, type SymbolTracker } from './transformers/declarations-resolver.js';
+import type { SyntacticDeclarationEmitResolver } from './transformers/declarations-syntactic.js';
+import { SyntacticEmitResolver } from './transformers/emit-resolver.js';
+import type { Evaluation, ReferenceResolver } from './transformers/reference-resolver.js';
+import { TypeReferenceSerializationKind } from './transformers/type-serialization.js';
+export declare class CheckerDeclarationEmitResolver extends DeclarationEmitResolver {
+    readonly checker: Checker;
+    /** Answers the queries that don't need types. */
+    private readonly syntactic;
+    private readonly aliasesMarked;
+    constructor(checker: Checker, syntactic: SyntacticDeclarationEmitResolver);
+    markLinkedReferences(file: SourceFile): boolean;
+    isReferencedAliasDeclaration(node: Node): boolean;
+    isValueAliasDeclaration(node: Node): boolean;
+    isTopLevelValueImportEqualsWithEntityName(node: Node): boolean;
+    getTypeReferenceSerializationKind(typeName: Node, location: Node | undefined): TypeReferenceSerializationKind;
+    getReferencedExportContainer(node: Identifier, prefixLocals: boolean): Node | undefined;
+    getReferencedImportDeclaration(node: Identifier): Node | undefined;
+    getReferencedValueDeclaration(node: Identifier): Node | undefined;
+    getReferencedValueDeclarations(node: Identifier): Node[] | undefined;
+    getEnumMemberValue(member: Node): Evaluation;
+    setReferencedImportDeclaration(name: Identifier, declaration: Node): void;
+    getJsxFactoryEntity(file: SourceFile): EntityName | undefined;
+    getJsxFragmentFactoryEntity(file: SourceFile): EntityName | undefined;
+    getConstantValue(node: Node): Evaluation;
+    precalculateDeclarationEmitVisibility(file: SourceFile): boolean;
+    /** Marks the declarations an export names visible, following `import x = a.b` chains. */
+    markLinkedAliases(node: Node): boolean;
+    isDeclarationVisible(node: Node): boolean;
+    isEntityNameVisible(entityName: Node, enclosingDeclaration: Node): SymbolAccessibilityResult;
+    isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags, shouldComputeAliasesToMakeVisible: boolean): SymbolAccessibilityResult;
+    isNameResolvable(location: Node, name: string): boolean;
+    isImportRequiredByAugmentation(node: ImportDeclaration): boolean;
+    getEffectiveDeclarationFlags(node: Node, flags: ModifierFlags): ModifierFlags;
+    isImplementationOfOverload(node: Node): boolean;
+    isLateBound(node: Node): boolean;
+    isDefinitelyReferenceToGlobalSymbolObject(node: Node): boolean;
+    isLiteralConstDeclaration(node: Node): boolean;
+    isOptionalParameter(node: Node): boolean;
+    requiresAddingImplicitUndefined(node: Node, enclosingDeclaration: Node | undefined): boolean;
+    isExpandoFunctionDeclaration(node: Node): boolean;
+    getExpandoPropertyDeclarations(node: Node): Node[];
+    private getPropertiesOfContainerFunction;
+    getResolutionModeOverride(node: Node): ModuleKind | undefined;
+    getSourceFileFromReference(file: SourceFile, reference: FileReference): SourceFile | undefined;
+    getReferencedMemberValueDeclaration(node: Node): Node | undefined;
+    isThisPropertyAssignmentDeclarationRedundant(node: Node): boolean;
+    getElementAccessExpressionName(node: Node): string;
+    private builder;
+    createTypeOfDeclaration(context: EmitContext, declaration: Node, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker): Node | undefined;
+    createReturnTypeOfSignatureDeclaration(context: EmitContext, signature: Node, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker): Node | undefined;
+    createTypeParametersOfSignatureDeclaration(context: EmitContext, signature: Node, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker): Node[] | undefined;
+    createLiteralConstValue(context: EmitContext, nodeIn: Node, tracker: SymbolTracker): Node | undefined;
+    createTypeOfExpression(context: EmitContext, expression: Node, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker): Node | undefined;
+    createLateBoundIndexSignatures(context: EmitContext, containerIn: Node, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker): Node[];
+    tryJSTypeNodeToTypeNode(context: EmitContext, typeNode: Node, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker): Node | undefined;
+}
+/** Visits every node, marking the declarations exports name visible. */
+/** JavaScript emit's resolver, with decorator metadata's type references serialized from the checker's types. */
+export declare class CheckerEmitResolver extends SyntacticEmitResolver {
+    readonly checker: Checker;
+    constructor(options: CompilerOptions, referenceResolver: ReferenceResolver, checker: Checker);
+    getTypeReferenceSerializationKind(typeName: Node, location: Node | undefined): TypeReferenceSerializationKind;
+}
+/**
+ * How decorator metadata serializes a reference to `typeName` from `location`, as tsgo's
+ * `GetTypeReferenceSerializationKind`: the name of a class or another value with construct
+ * signatures that is reachable at runtime, else the kind of the declared type it names.
+ */
+export declare function getTypeReferenceSerializationKind(c: Checker, typeName: Node, location: Node | undefined): TypeReferenceSerializationKind;