tsc-ts 0.0.3 → 0.0.5

package/src/compiler/checker-elaboration.ts

@@ -0,0 +1,477 @@
+// 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 {
+  type ArrowFunction,
+  type BinaryExpression,
+  type Node,
+  type PropertyAssignment,
+  getElements,
+  getExpression,
+  getName,
+  getParameters,
+  getProperties,
+  getType,
+} from './ast.js';
+import { getSourceFileOfNode } from './binder-utilities.js';
+import { type Diagnostic, type DiagnosticMessage, Diagnostics } from './diagnostics.js';
+import { SyntaxKind } from './syntax-kind.js';
+import { type Symbol, SymbolFlags } from './symbol.js';
+import { type Checker, createDiagnosticForNode } from './checker.js';
+import { AccessFlags, SignatureKind, type Type, TypeFlags } from './checker-types.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 {
+  type Relation,
+  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 { FunctionFlags, getFunctionFlags } from './checker-utilities.js';
+import { typeToString } from './type-printer.js';
+import { CheckMode } from './checker-types.js';
+import { elaborateJsxComponents } from './checker-jsx.js';
+
+/** Checks that `source` relates to `target`, elaborating into `expr` when possible. */
+export function checkTypeRelatedToAndOptionallyElaborate(
+  c: Checker,
+  source: Type,
+  target: Type,
+  relation: Relation,
+  errorNode: Node | undefined,
+  expr: Node | undefined,
+  headMessage: DiagnosticMessage | undefined,
+  diagnosticOutput: Diagnostic[] | undefined,
+): boolean {
+  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: Checker, diagnostic: Diagnostic, output: Diagnostic[] | undefined): void {
+  if (output !== undefined) output.push(diagnostic);
+  else c.addDiagnostic(diagnostic);
+}
+
+export function elaborateError(
+  c: Checker,
+  node: Node | undefined,
+  source: Type,
+  target: Type,
+  relation: Relation,
+  headMessage: DiagnosticMessage | undefined,
+  diagnosticOutput: Diagnostic[] | undefined,
+): boolean {
+  if (node === undefined || isOrHasGenericConditional(target)) return false;
+  if (
+    elaborateDidYouMeanToCallOrConstruct(
+      c,
+      node,
+      source,
+      target,
+      relation,
+      SignatureKind.Construct,
+      headMessage,
+      diagnosticOutput,
+    ) ||
+    elaborateDidYouMeanToCallOrConstruct(
+      c,
+      node,
+      source,
+      target,
+      relation,
+      SignatureKind.Call,
+      headMessage,
+      diagnosticOutput,
+    )
+  )
+    return true;
+  switch (node.kind) {
+    case SyntaxKind.AsExpression:
+      if (!isConstAssertion(node)) break;
+      return elaborateError(c, getExpression(node), source, target, relation, headMessage, diagnosticOutput);
+    case SyntaxKind.JsxExpression:
+    case SyntaxKind.ParenthesizedExpression:
+      return elaborateError(c, getExpression(node), source, target, relation, headMessage, diagnosticOutput);
+    case SyntaxKind.BinaryExpression: {
+      const binary = node as BinaryExpression;
+      const op = binary.operatorToken.kind;
+      if (op === SyntaxKind.EqualsToken || op === SyntaxKind.CommaToken)
+        return elaborateError(c, binary.right, source, target, relation, headMessage, diagnosticOutput);
+      break;
+    }
+    case SyntaxKind.ObjectLiteralExpression:
+      return elaborateObjectLiteral(c, node, source, target, relation, diagnosticOutput);
+    case SyntaxKind.ArrayLiteralExpression:
+      return elaborateArrayLiteral(c, node, source, target, relation, diagnosticOutput);
+    case SyntaxKind.ArrowFunction:
+      return elaborateArrowFunction(c, node as ArrowFunction, source, target, relation, diagnosticOutput);
+    case SyntaxKind.JsxAttributes:
+      return elaborateJsxComponents(c, node, source, target, relation, diagnosticOutput);
+  }
+  return false;
+}
+
+function isConstAssertion(node: Node): boolean {
+  const typeNode = getType(node);
+  return typeNode !== undefined && isConstTypeReference(typeNode);
+}
+
+function isOrHasGenericConditional(t: Type): boolean {
+  if ((t.flags & TypeFlags.Conditional) !== 0) return true;
+  if ((t.flags & TypeFlags.Intersection) !== 0)
+    for (const u of typesOf(t)) if (isOrHasGenericConditional(u)) return true;
+  return false;
+}
+
+function elaborateDidYouMeanToCallOrConstruct(
+  c: Checker,
+  node: Node,
+  source: Type,
+  target: Type,
+  relation: Relation,
+  kind: SignatureKind,
+  headMessage: DiagnosticMessage | undefined,
+  diagnosticOutput: Diagnostic[] | undefined,
+): boolean {
+  let callable = false;
+  for (const s of getSignaturesOfType(c, source, kind)) {
+    const returnType = getReturnTypeOfSignature(c, s);
+    if (
+      (returnType.flags & (TypeFlags.Any | TypeFlags.Never)) === 0 &&
+      checkTypeRelatedTo(c, returnType, target, relation, undefined, undefined, undefined)
+    ) {
+      callable = true;
+      break;
+    }
+  }
+  if (!callable) return false;
+  const diagnostics: Diagnostic[] = [];
+  if (checkTypeRelatedTo(c, source, target, relation, node, headMessage, diagnostics)) return false;
+  const diagnostic = diagnostics[0]!;
+  diagnostic.addRelatedInfo(
+    createDiagnosticForNode(
+      node,
+      kind === SignatureKind.Construct
+        ? Diagnostics.Did_you_mean_to_use_new_with_this_expression
+        : Diagnostics.Did_you_mean_to_call_this_expression,
+      [],
+    ),
+  );
+  reportDiagnostic(c, diagnostic, diagnosticOutput);
+  return true;
+}
+
+function elaborateObjectLiteral(
+  c: Checker,
+  node: Node,
+  source: Type,
+  target: Type,
+  relation: Relation,
+  diagnosticOutput: Diagnostic[] | undefined,
+): boolean {
+  if ((target.flags & (TypeFlags.Primitive | TypeFlags.Never)) !== 0) return false;
+  let reportedError = false;
+  for (const prop of getProperties(node)!.nodes) {
+    if (prop.kind === SyntaxKind.SpreadAssignment) continue;
+    const symbol = getSymbolOfDeclaration(c, prop);
+    if (symbol === undefined) continue;
+    const nameType = getLiteralTypeFromProperty(c, symbol, TypeFlags.StringOrNumberLiteralOrUnique, false);
+    if ((nameType.flags & TypeFlags.Never) !== 0) continue;
+    switch (prop.kind) {
+      case SyntaxKind.SetAccessor:
+      case SyntaxKind.GetAccessor:
+      case SyntaxKind.MethodDeclaration:
+      case SyntaxKind.ShorthandPropertyAssignment:
+        reportedError =
+          elaborateElement(
+            c,
+            source,
+            target,
+            relation,
+            getName(prop)!,
+            undefined,
+            nameType,
+            undefined,
+            undefined,
+            [],
+            diagnosticOutput,
+          ) || reportedError;
+        break;
+      case SyntaxKind.PropertyAssignment: {
+        const name = getName(prop)!;
+        const message = isComputedNonLiteralName(name)
+          ? 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 as PropertyAssignment).initializer,
+            nameType,
+            message,
+            undefined,
+            [],
+            diagnosticOutput,
+          ) || reportedError;
+        break;
+      }
+    }
+  }
+  return reportedError;
+}
+
+function isComputedNonLiteralName(name: Node): boolean {
+  if (name.kind !== SyntaxKind.ComputedPropertyName) return false;
+  const expression = getExpression(name)!;
+  return expression.kind !== SyntaxKind.StringLiteral && expression.kind !== SyntaxKind.NumericLiteral;
+}
+
+function isTupleLikeType(c: Checker, t: Type): boolean {
+  return isTupleType(t) || getPropertyOfType(c, t, '0') !== undefined;
+}
+
+function elaborateArrayLiteral(
+  c: Checker,
+  node: Node,
+  source: Type,
+  target: Type,
+  relation: Relation,
+  diagnosticOutput: Diagnostic[] | undefined,
+): boolean {
+  if ((target.flags & (TypeFlags.Primitive | TypeFlags.Never)) !== 0) return false;
+  if (!isTupleLikeType(c, source)) {
+    pushContextualType(c, node, target, false);
+    source = checkExpressionEx(c, node, CheckMode.Contextual | 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 === 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: Checker,
+  source: Type,
+  target: Type,
+  relation: Relation,
+  prop: Node,
+  next: Node | undefined,
+  nameType: Type,
+  errorMessage: DiagnosticMessage | undefined,
+  customMessage: DiagnosticMessage | undefined,
+  customArgs: string[],
+  diagnosticOutput: Diagnostic[] | undefined,
+): boolean {
+  let targetPropType = getBestMatchIndexedAccessTypeOrUndefined(c, source, target, nameType);
+  // Don't elaborate on indexes on generic variables.
+  if (targetPropType === undefined || (targetPropType.flags & TypeFlags.IndexedAccess) !== 0) return false;
+  let sourcePropType = getIndexedAccessTypeOrUndefined(c, source, nameType, 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: Diagnostic[] = [];
+  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,
+        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 & SymbolFlags.Optional) !== 0;
+    const sourceIsOptional = sourceProperty !== undefined && (sourceProperty.flags & 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: Symbol | undefined = 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,
+          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 & TypeFlags.UniqueESSymbol) !== 0)
+      propertyName = typeToString(c, nameType);
+    if (!c.host.isSourceFileDefaultLibrary(getSourceFileOfNode(targetNode)))
+      diagnostic.addRelatedInfo(
+        createDiagnosticForNode(
+          targetNode,
+          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: Checker,
+  source: Type,
+  target: Type,
+  nameType: Type,
+): Type | undefined {
+  const idx = getIndexedAccessTypeOrUndefined(c, target, nameType, AccessFlags.None);
+  if (idx !== undefined) return idx;
+  if ((target.flags & TypeFlags.Union) !== 0) {
+    const best = getBestMatchingTypeForElaboration(c, source, target);
+    if (best !== undefined) return getIndexedAccessTypeOrUndefined(c, best, nameType, AccessFlags.None);
+  }
+  return undefined;
+}
+
+export function checkExpressionForMutableLocationWithContextualType(
+  c: Checker,
+  next: Node,
+  sourcePropType: Type,
+): Type {
+  pushContextualType(c, next, sourcePropType, false);
+  const result = checkExpressionForMutableLocationEx(c, next, CheckMode.Contextual);
+  popContextualType(c);
+  return result;
+}
+
+function elaborateArrowFunction(
+  c: Checker,
+  node: ArrowFunction,
+  source: Type,
+  target: Type,
+  relation: Relation,
+  diagnosticOutput: Diagnostic[] | undefined,
+): boolean {
+  // Blocks and functions with annotated parameters aren't elaborated.
+  if (node.body.kind === 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, SignatureKind.Call);
+  if (targetSignatures.length === 0) return false;
+  const returnExpression = node.body;
+  const sourceReturn = getReturnTypeOfSignature(c, sourceSig);
+  const targetReturnTypes: Type[] = [];
+  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: Diagnostic[] = [];
+  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]!,
+        Diagnostics.The_expected_type_comes_from_the_return_type_of_this_signature,
+        [],
+      ),
+    );
+  if (
+    (getFunctionFlags(node) & FunctionFlags.Async) === 0 &&
+    getTypeOfPropertyOfType(c, sourceReturn, 'then') === undefined &&
+    checkTypeRelatedTo(c, createPromiseType(c, sourceReturn), targetReturn, relation, undefined, undefined, undefined)
+  )
+    diagnostic.addRelatedInfo(
+      createDiagnosticForNode(node, Diagnostics.Did_you_mean_to_mark_this_function_as_async, []),
+    );
+  reportDiagnostic(c, diagnostic, diagnosticOutput);
+  return true;
+}

package/src/compiler/checker-emit-helpers.ts

@@ -0,0 +1,224 @@
+// Emit helpers imported from tslib under --importHelpers: checks that the helpers a file's emit needs exist.
+import type { Node, SourceFile } from './ast.js';
+import { getSourceFileOfNode, isExternalModule } from './binder-utilities.js';
+import type { Checker } from './checker.js';
+import { resolveExternalModule } from './checker-modules.js';
+import { getParameterCount, getSignaturesOfSymbol } from './checker-signatures.js';
+import { getExportsOfModule, getSymbolOfMeaning, resolveSymbol } from './checker-symbols.js';
+import { Diagnostics } from './diagnostics.js';
+import { NodeFlags } from './ast.js';
+import { ModuleKind, getEmitModuleKind } from './options.js';
+import { type Symbol, SymbolFlags } from './symbol.js';
+
+/** The emit helpers tslib provides, in tsgo's order (which orders the errors one check reports). */
+export const enum ExternalEmitHelpers {
+  None = 0,
+  Rest = 1 << 0,
+  Decorate = 1 << 1,
+  Metadata = 1 << 2,
+  Param = 1 << 3,
+  Awaiter = 1 << 4,
+  Await = 1 << 5,
+  AsyncGenerator = 1 << 6,
+  AsyncDelegator = 1 << 7,
+  AsyncValues = 1 << 8,
+  ExportStar = 1 << 9,
+  ImportStar = 1 << 10,
+  ImportDefault = 1 << 11,
+  MakeTemplateObject = 1 << 12,
+  ClassPrivateFieldGet = 1 << 13,
+  ClassPrivateFieldSet = 1 << 14,
+  ClassPrivateFieldIn = 1 << 15,
+  SetFunctionName = 1 << 16,
+  PropKey = 1 << 17,
+  AddDisposableResourceAndDisposeResources = 1 << 18,
+  RewriteRelativeImportExtension = 1 << 19,
+  /** __esDecorate and __runInitializers, for ECMAScript decorators. */
+  ESDecorateAndRunInitializers = Decorate,
+  FirstEmitHelper = Rest,
+  LastEmitHelper = RewriteRelativeImportExtension,
+  /** for await..of before ES2018. */
+  ForAwaitOfIncludes = AsyncValues,
+  /** Async generators before ES2018. */
+  AsyncGeneratorIncludes = Await | AsyncGenerator,
+  /** `yield*` in async generators before ES2018. */
+  AsyncDelegatorIncludes = Await | AsyncDelegator | AsyncValues,
+}
+
+/** A helper check for a node of a file that the checker checks later (checkExternalEmitHelpers). */
+class PendingHelperCheck {
+  constructor(
+    readonly location: Node,
+    readonly helpers: ExternalEmitHelpers,
+  ) {}
+}
+
+/** 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: Symbol | undefined = undefined;
+  requestedHelpers: number = ExternalEmitHelpers.None;
+  pending: PendingHelperCheck[] = [];
+}
+
+function fileLinks(c: Checker, file: SourceFile): EmitHelperFileLinks {
+  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: Checker, location: Node, helpers: ExternalEmitHelpers): void {
+  if (c.compilerOptions.importHelpers !== true) return;
+  const file = getSourceFileOfNode(location);
+  if (!isEffectiveExternalModule(c, file) || (location.flags & 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 = ExternalEmitHelpers.FirstEmitHelper as number;
+      helper <= 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, SymbolFlags.Value),
+        );
+        if (symbol === undefined)
+          c.error(
+            location,
+            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 & ExternalEmitHelpers.ClassPrivateFieldGet) !== 0) {
+          if (!hasSignatureWithArityGreaterThan(c, symbol, 3))
+            c.error(
+              location,
+              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 & ExternalEmitHelpers.ClassPrivateFieldSet) !== 0) {
+          if (!hasSignatureWithArityGreaterThan(c, symbol, 4))
+            c.error(
+              location,
+              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: Checker, file: SourceFile): void {
+  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: Checker, file: SourceFile): boolean {
+  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: Checker, symbol: Symbol, arity: number): boolean {
+  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: Checker, file: SourceFile, errorNode: Node): Symbol {
+  const links = fileLinks(c, file);
+  if (links.helpersModule === undefined)
+    links.helpersModule =
+      resolveExternalModule(
+        c,
+        c.host.getImportHelpersImportSpecifier(file) ?? errorNode,
+        'tslib',
+        Diagnostics.This_syntax_requires_an_imported_helper_but_module_0_cannot_be_found,
+        errorNode,
+        false,
+      ) ?? c.unknownSymbol;
+  return links.helpersModule;
+}
+
+function getHelperNames(c: Checker, helper: number): string[] {
+  switch (helper) {
+    case ExternalEmitHelpers.Rest:
+      return ['__rest'];
+    case ExternalEmitHelpers.Decorate:
+      return c.legacyDecorators ? ['__decorate'] : ['__esDecorate', '__runInitializers'];
+    case ExternalEmitHelpers.Metadata:
+      return ['__metadata'];
+    case ExternalEmitHelpers.Param:
+      return ['__param'];
+    case ExternalEmitHelpers.Awaiter:
+      return ['__awaiter'];
+    case ExternalEmitHelpers.Await:
+      return ['__await'];
+    case ExternalEmitHelpers.AsyncGenerator:
+      return ['__asyncGenerator'];
+    case ExternalEmitHelpers.AsyncDelegator:
+      return ['__asyncDelegator'];
+    case ExternalEmitHelpers.AsyncValues:
+      return ['__asyncValues'];
+    case ExternalEmitHelpers.ExportStar:
+      return ['__exportStar'];
+    case ExternalEmitHelpers.ImportStar:
+      return ['__importStar'];
+    case ExternalEmitHelpers.ImportDefault:
+      return ['__importDefault'];
+    case ExternalEmitHelpers.MakeTemplateObject:
+      return ['__makeTemplateObject'];
+    case ExternalEmitHelpers.ClassPrivateFieldGet:
+      return ['__classPrivateFieldGet'];
+    case ExternalEmitHelpers.ClassPrivateFieldSet:
+      return ['__classPrivateFieldSet'];
+    case ExternalEmitHelpers.ClassPrivateFieldIn:
+      return ['__classPrivateFieldIn'];
+    case ExternalEmitHelpers.SetFunctionName:
+      return ['__setFunctionName'];
+    case ExternalEmitHelpers.PropKey:
+      return ['__propKey'];
+    case ExternalEmitHelpers.AddDisposableResourceAndDisposeResources:
+      return ['__addDisposableResource', '__disposeResources'];
+    case ExternalEmitHelpers.RewriteRelativeImportExtension:
+      return ['__rewriteRelativeImportExtension'];
+  }
+  return [];
+}