tsc-ts 0.0.9 → 0.1.0

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

@@ -17,7 +17,7 @@ import { isTypeAssignableTo } from './relations.js';
 import { checkDeclarationInitializer, checkExpression, checkExpressionCached, checkExpressionEx, checkNonNullType, checkTypeAssignableToAndOptionallyElaborate, } from './checker-expressions.js';
 import { checkIteratedTypeOrElementType, createIterableType } from './checker-iteration.js';
 import { ScriptTarget } from './options.js';
-import { checkBinaryExpression, checkReferenceExpression, removeDefinitelyFalsyTypes } from './checker-operators.js';
+import { checkBinaryExpression, checkReferenceExpression, grammarErrorOnNode, removeDefinitelyFalsyTypes, } from './checker-operators.js';
 import { getNonNullableType, getTypeWithFacts, hasTypeFacts } from './checker-flow.js';
 import { sliceTupleType } from './checker-signatures.js';
 import { getPropertyNameFromType, isTypeUsableAsPropertyName, maybeTypeOfKind } from './checker-utilities.js';
@@ -25,7 +25,7 @@ import { checkPropertyAccessibility } from './checker-property-access.js';
 import { copyDeclarations, declarationAt, declarationCount, getSymbolId, } from './symbol.js';
 function isBindingPatternNode(node) {
     return (node !== undefined &&
-        (node.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || node.kind === 208 /* SyntaxKind.ArrayBindingPattern */));
+        (node.kind === 208 /* SyntaxKind.ObjectBindingPattern */ || node.kind === 209 /* SyntaxKind.ArrayBindingPattern */));
 }
 /** The type of a binding element, from the type of the declaration it destructures. */
 export function getTypeForBindingElement(c, declaration) {
@@ -75,14 +75,14 @@ function getSyntheticElementAccess(c, node) {
 function getParentElementAccess(c, node) {
     const ancestor = node.parent.parent;
     switch (ancestor.kind) {
-        case 209 /* SyntaxKind.BindingElement */:
-        case 303 /* SyntaxKind.PropertyAssignment */:
+        case 210 /* SyntaxKind.BindingElement */:
+        case 304 /* SyntaxKind.PropertyAssignment */:
             return getSyntheticElementAccess(c, ancestor);
-        case 210 /* SyntaxKind.ArrayLiteralExpression */:
+        case 211 /* SyntaxKind.ArrayLiteralExpression */:
             return getSyntheticElementAccess(c, node.parent);
-        case 261 /* SyntaxKind.VariableDeclaration */:
+        case 262 /* SyntaxKind.VariableDeclaration */:
             return getInitializer(ancestor);
-        case 227 /* SyntaxKind.BinaryExpression */:
+        case 228 /* SyntaxKind.BinaryExpression */:
             return ancestor.right;
     }
     return undefined;
@@ -115,11 +115,11 @@ export function getBindingElementTypeFromParentType(c, declaration, parentTypeIn
     const accessFlags = 32 /* AccessFlags.ExpressionPosition */ |
         (noTupleBoundsCheck || declaration.initializer !== undefined ? 16 /* AccessFlags.AllowMissing */ : 0);
     let t;
-    if (pattern.kind === 207 /* SyntaxKind.ObjectBindingPattern */) {
+    if (pattern.kind === 208 /* SyntaxKind.ObjectBindingPattern */) {
         if (declaration.dotDotDotToken !== undefined) {
             parentType = getReducedType(c, parentType);
             if ((parentType.flags & 2 /* TypeFlags.Unknown */) !== 0 || !isValidSpreadType(c, parentType)) {
-                c.error(declaration, 832 /* Diagnostics.Rest_types_may_only_be_created_from_object_types */);
+                c.error(declaration, 839 /* Diagnostics.Rest_types_may_only_be_created_from_object_types */);
                 return c.errorType;
             }
             const literalMembers = [];
@@ -167,7 +167,7 @@ export function getBindingElementTypeFromParentType(c, declaration, parentTypeIn
 /** The binding pattern's root declaration: the variable or parameter it destructures. */
 function walkUpBindingElementsAndPatterns(node) {
     let current = node.parent;
-    while (current.kind === 209 /* SyntaxKind.BindingElement */ || isBindingPatternNode(current))
+    while (current.kind === 210 /* SyntaxKind.BindingElement */ || isBindingPatternNode(current))
         current = current.parent;
     return current;
 }
@@ -189,7 +189,7 @@ export function getTypeFromBindingPattern(c, pattern, includePatternInType, repo
     // References to the pattern's own elements in its initializers are `any` while its type is a contextual type.
     if (includePatternInType)
         c.contextualBindingPatterns.push(pattern);
-    const result = pattern.kind === 207 /* SyntaxKind.ObjectBindingPattern */
+    const result = pattern.kind === 208 /* SyntaxKind.ObjectBindingPattern */
         ? getTypeFromObjectBindingPattern(c, pattern, includePatternInType, reportErrors)
         : getTypeFromArrayBindingPattern(c, pattern, includePatternInType, reportErrors);
     if (includePatternInType)
@@ -228,7 +228,7 @@ function getTypeFromArrayBindingPattern(c, pattern, includePatternInType, report
     const elements = getElements(pattern).nodes;
     const last = elements.length > 0 ? elements[elements.length - 1] : undefined;
     const restElement = last !== undefined &&
-        last.kind === 209 /* SyntaxKind.BindingElement */ &&
+        last.kind === 210 /* SyntaxKind.BindingElement */ &&
         last.dotDotDotToken !== undefined
         ? last
         : undefined;
@@ -283,14 +283,14 @@ function getTypeFromBindingElement(c, element, includePatternInType, reportError
  * pattern defaults or binds past the end of a tuple.
  */
 export function padParameterInitializerType(c, declaration, t) {
-    if (getRootDeclaration(declaration).kind !== 170 /* SyntaxKind.Parameter */)
+    if (getRootDeclaration(declaration).kind !== 171 /* SyntaxKind.Parameter */)
         return t;
     const name = getName(declaration);
     if (name === undefined)
         return t;
-    if (name.kind === 207 /* SyntaxKind.ObjectBindingPattern */ && (t.objectFlags & 128 /* ObjectFlags.ObjectLiteral */) !== 0)
+    if (name.kind === 208 /* SyntaxKind.ObjectBindingPattern */ && (t.objectFlags & 128 /* ObjectFlags.ObjectLiteral */) !== 0)
         return padObjectLiteralType(c, t, name);
-    if (name.kind === 208 /* SyntaxKind.ArrayBindingPattern */ && isTupleType(t))
+    if (name.kind === 209 /* SyntaxKind.ArrayBindingPattern */ && isTupleType(t))
         return padTupleType(c, t, name);
     return t;
 }
@@ -299,7 +299,7 @@ function padObjectLiteralType(c, t, pattern) {
     const missingElements = [];
     for (const node of getElements(pattern).nodes) {
         const e = node;
-        if (e.initializer === undefined)
+        if (e.dotDotDotToken !== undefined)
             continue;
         const name = getPropertyNameFromBindingElement(c, e);
         if (name !== undefined && getPropertyOfType(c, t, name) === undefined)
@@ -312,7 +312,7 @@ function padObjectLiteralType(c, t, pattern) {
         members.set(prop.name, prop);
     for (const e of missingElements) {
         const symbol = c.newSymbol(4 /* SymbolFlags.Property */ | 16777216 /* SymbolFlags.Optional */, getPropertyNameFromBindingElement(c, e));
-        c.symbolTypes.set(getSymbolId(symbol), getTypeFromBindingElement(c, e, false, false));
+        c.symbolTypes.set(getSymbolId(symbol), getTypeFromBindingElement(c, e, false, true));
         members.set(symbol.name, symbol);
     }
     const result = createAnonymousType(c, t.symbol, members, [], [], getIndexInfosOfType(c, t));
@@ -338,8 +338,8 @@ export function padTupleType(c, t, pattern) {
     for (let i = arity; i < patternElements.length; i++) {
         const e = patternElements[i];
         if (i < patternElements.length - 1 ||
-            !(e.kind === 209 /* SyntaxKind.BindingElement */ && e.dotDotDotToken !== undefined)) {
-            const omitted = e.kind === 233 /* SyntaxKind.OmittedExpression */;
+            !(e.kind === 210 /* SyntaxKind.BindingElement */ && e.dotDotDotToken !== undefined)) {
+            const omitted = e.kind === 234 /* SyntaxKind.OmittedExpression */;
             elementTypes.push(!omitted && hasDefaultValue(e) ? getTypeFromBindingElement(c, e, false, false) : c.anyType);
             elementInfos.push(new TupleElementInfo(2 /* ElementFlags.Optional */, undefined));
             if (!omitted && !hasDefaultValue(e))
@@ -353,7 +353,7 @@ export function padTupleType(c, t, pattern) {
 export function checkDestructuringAssignment(c, node, sourceTypeIn, checkMode, rightIsThis) {
     let sourceType = sourceTypeIn;
     let target = node;
-    if (node.kind === 304 /* SyntaxKind.ShorthandPropertyAssignment */) {
+    if (node.kind === 305 /* SyntaxKind.ShorthandPropertyAssignment */) {
         const shorthand = node;
         const initializer = shorthand.objectAssignmentInitializer;
         if (initializer !== undefined) {
@@ -364,16 +364,16 @@ export function checkDestructuringAssignment(c, node, sourceTypeIn, checkMode, r
         }
         target = shorthand.name;
     }
-    if (target.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+    if (target.kind === 228 /* SyntaxKind.BinaryExpression */ &&
         target.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */) {
         checkBinaryExpression(c, target, checkMode);
         target = target.left;
         if (c.strictNullChecks)
             sourceType = getTypeWithFacts(c, sourceType, 524288 /* TypeFacts.NEUndefined */);
     }
-    if (target.kind === 211 /* SyntaxKind.ObjectLiteralExpression */)
+    if (target.kind === 212 /* SyntaxKind.ObjectLiteralExpression */)
         return checkObjectLiteralAssignment(c, target, sourceType, rightIsThis);
-    if (target.kind === 210 /* SyntaxKind.ArrayLiteralExpression */)
+    if (target.kind === 211 /* SyntaxKind.ArrayLiteralExpression */)
         return checkArrayLiteralAssignment(c, target, sourceType, checkMode);
     return checkReferenceAssignment(c, target, sourceType, checkMode);
 }
@@ -381,7 +381,7 @@ export function checkDestructuringAssignment(c, node, sourceTypeIn, checkMode, r
 function checkShorthandDefault(c, node, initializer, checkMode) {
     const leftType = checkExpressionCached(c, node.name);
     const rightType = checkExpressionEx(c, initializer, checkMode);
-    if (checkReferenceExpression(c, node.name, 538 /* Diagnostics.The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access */, 911 /* Diagnostics.The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access */))
+    if (checkReferenceExpression(c, node.name, 545 /* Diagnostics.The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access */, 918 /* Diagnostics.The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access */))
         checkTypeAssignableToAndOptionallyElaborate(c, rightType, leftType, node.name, initializer);
 }
 function checkObjectLiteralAssignment(c, node, sourceType, rightIsThis) {
@@ -394,8 +394,10 @@ function checkObjectLiteralAssignment(c, node, sourceType, rightIsThis) {
 }
 function checkObjectLiteralDestructuringPropertyAssignment(c, properties, objectLiteralType, propertyIndex, rightIsThis) {
     const property = properties[propertyIndex];
-    if (property.kind === 303 /* SyntaxKind.PropertyAssignment */ || property.kind === 304 /* SyntaxKind.ShorthandPropertyAssignment */) {
+    if (property.kind === 304 /* SyntaxKind.PropertyAssignment */ || property.kind === 305 /* SyntaxKind.ShorthandPropertyAssignment */) {
         const name = getName(property);
+        if (name.kind === 80 /* SyntaxKind.PrivateIdentifier */)
+            grammarErrorOnNode(c, name, 1899 /* Diagnostics.Private_identifiers_cannot_be_used_in_destructuring_patterns */);
         markDestructuredPropertyAsReferenced(c, objectLiteralType, name, property, rightIsThis);
         const exprType = getLiteralTypeFromPropertyName(c, name) ?? c.errorType;
         if (isTypeUsableAsPropertyName(exprType)) {
@@ -404,20 +406,20 @@ function checkObjectLiteralDestructuringPropertyAssignment(c, properties, object
                 checkPropertyAccessibility(c, property, false, true, objectLiteralType, prop);
         }
         const elementType = getIndexedAccessTypeEx(c, objectLiteralType, exprType, 32 /* AccessFlags.ExpressionPosition */ | (hasDefaultValue(property) ? 16 /* AccessFlags.AllowMissing */ : 0), name, undefined);
-        const expr = property.kind === 303 /* SyntaxKind.PropertyAssignment */ ? property.initializer : property;
+        const expr = property.kind === 304 /* SyntaxKind.PropertyAssignment */ ? property.initializer : property;
         checkDestructuringAssignment(c, expr, getFlowTypeOfDestructuring(c, property, elementType), 0 /* CheckMode.Normal */, false);
         return;
     }
-    if (property.kind === 305 /* SyntaxKind.SpreadAssignment */) {
+    if (property.kind === 306 /* SyntaxKind.SpreadAssignment */) {
         if (propertyIndex < properties.length - 1) {
-            c.error(property, 628 /* Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern */);
+            c.error(property, 635 /* Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern */);
             return;
         }
         if (c.languageVersion < ScriptTarget.ES2018)
             checkExternalEmitHelpers(c, property, 1 /* ExternalEmitHelpers.Rest */);
         const nonRestNames = [];
         for (const other of properties)
-            if (other.kind !== 305 /* SyntaxKind.SpreadAssignment */)
+            if (other.kind !== 306 /* SyntaxKind.SpreadAssignment */)
                 nonRestNames.push(getName(other));
         const t = getRestType(c, objectLiteralType, nonRestNames, objectLiteralType.symbol);
         checkGrammarRestTrailingComma(c, property.parent, getProperties(property.parent));
@@ -433,7 +435,7 @@ function checkArrayLiteralAssignment(c, node, sourceType, checkMode) {
     let inBoundsType = c.noUncheckedIndexedAccess ? undefined : possiblyOutOfBoundsType;
     for (let i = 0; i < elements.length; i++) {
         let t = possiblyOutOfBoundsType;
-        if (elements[i].kind === 231 /* SyntaxKind.SpreadElement */) {
+        if (elements[i].kind === 232 /* SyntaxKind.SpreadElement */) {
             if (inBoundsType === undefined)
                 inBoundsType = checkIteratedTypeOrElementType(c, 65 /* IterationUse.Destructuring */, sourceType, c.undefinedType, node);
             t = inBoundsType;
@@ -444,14 +446,14 @@ function checkArrayLiteralAssignment(c, node, sourceType, checkMode) {
 }
 function checkArrayLiteralDestructuringElementAssignment(c, elements, sourceType, elementIndex, elementType, checkMode) {
     const element = elements[elementIndex];
-    if (element.kind === 233 /* SyntaxKind.OmittedExpression */)
+    if (element.kind === 234 /* SyntaxKind.OmittedExpression */)
         return;
-    if (element.kind !== 231 /* SyntaxKind.SpreadElement */) {
+    if (element.kind !== 232 /* SyntaxKind.SpreadElement */) {
         if (isArrayLikeType(c, sourceType)) {
             const indexType = getNumberLiteralType(c, elementIndex);
             const accessFlags = 32 /* AccessFlags.ExpressionPosition */ | (hasDefaultValue(element) ? 16 /* AccessFlags.AllowMissing */ : 0);
             // Element access targets would be mistaken for the access itself.
-            const accessNode = element.kind === 213 /* SyntaxKind.ElementAccessExpression */ ? undefined : element;
+            const accessNode = element.kind === 214 /* SyntaxKind.ElementAccessExpression */ ? undefined : element;
             const t = getIndexedAccessTypeOrUndefinedEx(c, sourceType, indexType, accessFlags, accessNode, undefined) ?? c.errorType;
             const assigned = hasDefaultValue(element) ? getTypeWithFacts(c, t, 524288 /* TypeFacts.NEUndefined */) : t;
             checkDestructuringAssignment(c, element, getFlowTypeOfDestructuring(c, element, assigned), checkMode, false);
@@ -461,11 +463,11 @@ function checkArrayLiteralDestructuringElementAssignment(c, elements, sourceType
         return;
     }
     if (elementIndex < elements.length - 1) {
-        c.error(element, 628 /* Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern */);
+        c.error(element, 635 /* Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern */);
         return;
     }
     const restExpression = element.expression;
-    if (restExpression.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+    if (restExpression.kind === 228 /* SyntaxKind.BinaryExpression */ &&
         restExpression.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */) {
         c.error(restExpression.operatorToken, 142 /* Diagnostics.A_rest_element_cannot_have_an_initializer */);
         return;
@@ -478,25 +480,25 @@ function checkArrayLiteralDestructuringElementAssignment(c, elements, sourceType
 }
 function checkReferenceAssignment(c, target, sourceType, checkMode) {
     const targetType = checkExpressionEx(c, target, checkMode);
-    const inRest = target.parent.kind === 305 /* SyntaxKind.SpreadAssignment */;
+    const inRest = target.parent.kind === 306 /* SyntaxKind.SpreadAssignment */;
     if (checkReferenceExpression(c, target, inRest
-        ? 833 /* Diagnostics.The_target_of_an_object_rest_assignment_must_be_a_variable_or_a_property_access */
-        : 538 /* Diagnostics.The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access */, inRest
-        ? 910 /* Diagnostics.The_target_of_an_object_rest_assignment_may_not_be_an_optional_property_access */
-        : 911 /* Diagnostics.The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access */))
+        ? 840 /* Diagnostics.The_target_of_an_object_rest_assignment_must_be_a_variable_or_a_property_access */
+        : 545 /* Diagnostics.The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access */, inRest
+        ? 917 /* Diagnostics.The_target_of_an_object_rest_assignment_may_not_be_an_optional_property_access */
+        : 918 /* Diagnostics.The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access */))
         checkTypeAssignableToAndOptionallyElaborate(c, sourceType, targetType, target, target);
     return sourceType;
 }
 /** Whether a destructuring element has a default value. */
 export function hasDefaultValue(node) {
     switch (node.kind) {
-        case 209 /* SyntaxKind.BindingElement */:
+        case 210 /* SyntaxKind.BindingElement */:
             return node.initializer !== undefined;
-        case 303 /* SyntaxKind.PropertyAssignment */:
+        case 304 /* SyntaxKind.PropertyAssignment */:
             return hasDefaultValue(node.initializer);
-        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+        case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
             return node.objectAssignmentInitializer !== undefined;
-        case 227 /* SyntaxKind.BinaryExpression */:
+        case 228 /* SyntaxKind.BinaryExpression */:
             return node.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */;
     }
     return false;
@@ -562,7 +564,7 @@ export function getSpreadSymbol(c, prop, readonly) {
     const isSetonlyAccessor = (prop.flags & 65536 /* SymbolFlags.SetAccessor */) !== 0 && (prop.flags & 32768 /* SymbolFlags.GetAccessor */) === 0;
     if (!isSetonlyAccessor && readonly === isReadonlySymbol(c, prop))
         return prop;
-    const result = c.newSymbolWithCheckFlags(4 /* SymbolFlags.Property */ | (prop.flags & 16777216 /* SymbolFlags.Optional */), prop.name, (prop.checkFlags & 4096 /* CheckFlags.Late */) | (readonly ? 8 /* CheckFlags.Readonly */ : 0));
+    const result = c.newSymbolWithCheckFlags(4 /* SymbolFlags.Property */ | (prop.flags & 16777216 /* SymbolFlags.Optional */), prop.name, (prop.checkFlags & 32768 /* CheckFlags.Late */) | (readonly ? 8 /* CheckFlags.Readonly */ : 0));
     const id = getSymbolId(result);
     c.symbolTypes.set(id, isSetonlyAccessor ? c.undefinedType : getTypeOfSymbol(c, prop));
     copyDeclarations(result, prop);

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

@@ -40,27 +40,27 @@ export function elaborateError(c, node, source, target, relation, headMessage, d
         elaborateDidYouMeanToCallOrConstruct(c, node, source, target, relation, 0 /* SignatureKind.Call */, headMessage, diagnosticOutput))
         return true;
     switch (node.kind) {
-        case 235 /* SyntaxKind.AsExpression */:
+        case 236 /* SyntaxKind.AsExpression */:
             if (!isConstAssertion(node))
                 break;
             return elaborateError(c, getExpression(node), source, target, relation, headMessage, diagnosticOutput);
-        case 295 /* SyntaxKind.JsxExpression */:
-        case 218 /* SyntaxKind.ParenthesizedExpression */:
+        case 296 /* SyntaxKind.JsxExpression */:
+        case 219 /* SyntaxKind.ParenthesizedExpression */:
             return elaborateError(c, getExpression(node), source, target, relation, headMessage, diagnosticOutput);
-        case 227 /* SyntaxKind.BinaryExpression */: {
+        case 228 /* 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 */:
+        case 212 /* SyntaxKind.ObjectLiteralExpression */:
             return elaborateObjectLiteral(c, node, source, target, relation, diagnosticOutput);
-        case 210 /* SyntaxKind.ArrayLiteralExpression */:
+        case 211 /* SyntaxKind.ArrayLiteralExpression */:
             return elaborateArrayLiteral(c, node, source, target, relation, diagnosticOutput);
-        case 220 /* SyntaxKind.ArrowFunction */:
+        case 221 /* SyntaxKind.ArrowFunction */:
             return elaborateArrowFunction(c, node, source, target, relation, diagnosticOutput);
-        case 293 /* SyntaxKind.JsxAttributes */:
+        case 294 /* SyntaxKind.JsxAttributes */:
             return elaborateJsxComponents(c, node, source, target, relation, diagnosticOutput);
     }
     return false;
@@ -95,8 +95,8 @@ function elaborateDidYouMeanToCallOrConstruct(c, node, source, target, relation,
         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 */, []));
+        ? 1377 /* Diagnostics.Did_you_mean_to_use_new_with_this_expression */
+        : 1376 /* Diagnostics.Did_you_mean_to_call_this_expression */, []));
     reportDiagnostic(c, diagnostic, diagnosticOutput);
     return true;
 }
@@ -105,7 +105,7 @@ function elaborateObjectLiteral(c, node, source, target, relation, diagnosticOut
         return false;
     let reportedError = false;
     for (const prop of getProperties(node).nodes) {
-        if (prop.kind === 305 /* SyntaxKind.SpreadAssignment */)
+        if (prop.kind === 306 /* SyntaxKind.SpreadAssignment */)
             continue;
         const symbol = getSymbolOfDeclaration(c, prop);
         if (symbol === undefined)
@@ -114,17 +114,17 @@ function elaborateObjectLiteral(c, node, source, target, relation, diagnosticOut
         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 */:
+            case 180 /* SyntaxKind.SetAccessor */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
                 reportedError =
                     elaborateElement(c, source, target, relation, getName(prop), undefined, nameType, undefined, undefined, [], diagnosticOutput) || reportedError;
                 break;
-            case 303 /* SyntaxKind.PropertyAssignment */: {
+            case 304 /* 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 */
+                    ? 596 /* 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;
@@ -135,7 +135,7 @@ function elaborateObjectLiteral(c, node, source, target, relation, diagnosticOut
     return reportedError;
 }
 function isComputedNonLiteralName(name) {
-    if (name.kind !== 168 /* SyntaxKind.ComputedPropertyName */)
+    if (name.kind !== 169 /* SyntaxKind.ComputedPropertyName */)
         return false;
     const expression = getExpression(name);
     return expression.kind !== 10 /* SyntaxKind.StringLiteral */ && expression.kind !== 8 /* SyntaxKind.NumericLiteral */;
@@ -157,7 +157,7 @@ function elaborateArrayLiteral(c, node, source, target, relation, diagnosticOutp
     const elements = getElements(node).nodes;
     for (let i = 0; i < elements.length; i++) {
         const element = elements[i];
-        if (element.kind === 233 /* SyntaxKind.OmittedExpression */ ||
+        if (element.kind === 234 /* SyntaxKind.OmittedExpression */ ||
             (isTupleLikeType(c, target) && getPropertyOfType(c, target, String(i)) === undefined))
             continue;
         const checkNode = getEffectiveCheckNode(element);
@@ -188,7 +188,7 @@ export function elaborateElement(c, source, target, relation, prop, next, nameTy
     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)]));
+        diagnostics.push(createDiagnosticForNode(prop, 590 /* 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;
@@ -218,7 +218,7 @@ export function elaborateElement(c, source, target, relation, prop, next, nameTy
             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 */, []));
+            diagnostic.addRelatedInfo(createDiagnosticForNode(indexInfo.declaration, 1527 /* Diagnostics.The_expected_type_comes_from_this_index_signature */, []));
         }
     }
     if (!issuedElaboration &&
@@ -230,7 +230,7 @@ export function elaborateElement(c, source, target, relation, prop, next, nameTy
         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)]));
+            diagnostic.addRelatedInfo(createDiagnosticForNode(targetNode, 1526 /* 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;
@@ -254,7 +254,7 @@ export function checkExpressionForMutableLocationWithContextualType(c, next, sou
 }
 function elaborateArrowFunction(c, node, source, target, relation, diagnosticOutput) {
     // Blocks and functions with annotated parameters aren't elaborated.
-    if (node.body.kind === 242 /* SyntaxKind.Block */)
+    if (node.body.kind === 243 /* SyntaxKind.Block */)
         return false;
     for (const p of getParameters(node).nodes)
         if (getType(p) !== undefined)
@@ -281,7 +281,7 @@ function elaborateArrowFunction(c, node, source, target, relation, diagnosticOut
         return false;
     const diagnostic = diagnostics[0];
     if (target.symbol !== undefined && declarationCount(target.symbol) !== 0)
-        diagnostic.addRelatedInfo(createDiagnosticForNode(target.symbol.declaration, 1517 /* Diagnostics.The_expected_type_comes_from_the_return_type_of_this_signature */, []));
+        diagnostic.addRelatedInfo(createDiagnosticForNode(target.symbol.declaration, 1528 /* 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))

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

@@ -62,14 +62,14 @@ export function checkExternalEmitHelpers(c, location, helpers) {
             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);
+                    c.error(location, 526 /* 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');
+                        c.error(location, 945 /* 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');
+                        c.error(location, 945 /* 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');
                 }
             }
         }
@@ -105,7 +105,7 @@ 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;
+            resolveExternalModule(c, c.host.getImportHelpersImportSpecifier(file) ?? errorNode, 'tslib', 537 /* Diagnostics.This_syntax_requires_an_imported_helper_but_module_0_cannot_be_found */, errorNode, false, undefined) ?? c.unknownSymbol;
     return links.helpersModule;
 }
 function getHelperNames(c, helper) {

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

@@ -1,6 +1,6 @@
 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 { CompilerOptions } from './options.js';
 import type { EmitContext } from './printer/emit-context.js';
 import { DeclarationEmitResolver, NodeBuilderFlags, type SymbolAccessibilityResult, type SymbolTracker } from './transformers/declarations-resolver.js';
 import type { SyntacticDeclarationEmitResolver } from './transformers/declarations-syntactic.js';
@@ -13,6 +13,9 @@ export declare class CheckerDeclarationEmitResolver extends DeclarationEmitResol
     /** Answers the queries that don't need types. */
     private readonly syntactic;
     private readonly aliasesMarked;
+    /** The emit context of the last node builder, and the caches the builders for it share. */
+    private builderContext;
+    private builderCaches;
     constructor(checker: Checker, syntactic: SyntacticDeclarationEmitResolver);
     markLinkedReferences(file: SourceFile): boolean;
     isReferencedAliasDeclaration(node: Node): boolean;
@@ -46,7 +49,6 @@ export declare class CheckerDeclarationEmitResolver extends DeclarationEmitResol
     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;

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

@@ -17,7 +17,7 @@ import { getExportsOfModule, getFirstIdentifier, getGlobalSymbol, getGlobalValue
 import { isArrayType, isErrorType, isFreshLiteralType, isTupleType } from './checker-type-factory.js';
 import { isTypeAssignableToKind } from './checker-type-operators.js';
 import { hasLateBindableName } from './checker-utilities.js';
-import { NodeBuilder, isEntityNameVisible, isOptionalParameter } from './node-builder.js';
+import { NodeBuilder, NodeBuilderCaches, isEntityNameVisible, isOptionalParameter } from './node-builder.js';
 import { getRegularTypeOfExpression, newPseudoChecker, requiresAddingImplicitUndefinedForDeclaration, } from './node-builder-pseudo.js';
 import { symbolToExpression } from './node-builder-names.js';
 import { tryReuseExistingNode } from './node-builder-reuse.js';
@@ -25,6 +25,7 @@ import { isTypeIdenticalTo } from './relations.js';
 import { beginDeclarationEmitVisibility, isDeclarationVisible, isSymbolAccessible, markDeclarationVisible, } from './symbol-accessibility.js';
 import { DeclarationEmitResolver, } from './transformers/declarations-resolver.js';
 import { SyntacticEmitResolver } from './transformers/emit-resolver.js';
+import { getSignatureOfFullSignatureType } from './checker-jsdoc.js';
 import { declarationCount, getDeclarations } from './symbol.js';
 const declarationEmitInternalFlags = 8 /* NodeBuilderInternalFlags.AllowUnresolvedNames */;
 const aliasMeaning = 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */ | 2097152 /* SymbolFlags.Alias */;
@@ -33,11 +34,16 @@ export class CheckerDeclarationEmitResolver extends DeclarationEmitResolver {
     /** Answers the queries that don't need types. */
     syntactic;
     aliasesMarked;
+    /** The emit context of the last node builder, and the caches the builders for it share. */
+    builderContext;
+    builderCaches;
     constructor(checker, syntactic) {
         super();
         this.checker = checker;
         this.syntactic = syntactic;
         this.aliasesMarked = new Set();
+        this.builderContext = undefined;
+        this.builderCaches = undefined;
     }
     // JavaScript emit
     markLinkedReferences(file) {
@@ -98,9 +104,9 @@ export class CheckerDeclarationEmitResolver extends DeclarationEmitResolver {
         let exportSymbol = undefined;
         if (node.kind !== 10 /* SyntaxKind.StringLiteral */ &&
             parent !== undefined &&
-            (parent.kind === 278 /* SyntaxKind.ExportAssignment */ || isCommonJSModuleExports(parent)))
+            (parent.kind === 279 /* SyntaxKind.ExportAssignment */ || isCommonJSModuleExports(parent)))
             exportSymbol = resolveName(c, node, getText(node), aliasMeaning, undefined, false, false);
-        else if (parent !== undefined && parent.kind === 282 /* SyntaxKind.ExportSpecifier */)
+        else if (parent !== undefined && parent.kind === 283 /* SyntaxKind.ExportSpecifier */)
             exportSymbol = getTargetOfExportSpecifier(c, parent, aliasMeaning, false);
         const visited = new Set();
         while (exportSymbol !== undefined && !visited.has(exportSymbol)) {
@@ -109,7 +115,7 @@ export class CheckerDeclarationEmitResolver extends DeclarationEmitResolver {
             for (const declaration of getDeclarations(exportSymbol)) {
                 markDeclarationVisible(c, declaration);
                 if (declaration instanceof ImportEqualsDeclaration &&
-                    declaration.moduleReference.kind !== 284 /* SyntaxKind.ExternalModuleReference */) {
+                    declaration.moduleReference.kind !== 285 /* SyntaxKind.ExternalModuleReference */) {
                     const first = getFirstIdentifier(declaration.moduleReference);
                     next = resolveName(c, declaration, getText(first), aliasMeaning, undefined, false, false);
                 }
@@ -159,13 +165,16 @@ export class CheckerDeclarationEmitResolver extends DeclarationEmitResolver {
         if ((node.flags & 16 /* NodeFlags.Synthesized */) !== 0 || !nodeIsPresent(getBody(node)))
             return false;
         // Accessors have up to two signatures but never overloads.
-        if (node.kind === 178 /* SyntaxKind.GetAccessor */ || node.kind === 179 /* SyntaxKind.SetAccessor */)
+        if (node.kind === 179 /* SyntaxKind.GetAccessor */ || node.kind === 180 /* SyntaxKind.SetAccessor */)
             return false;
         const c = this.checker;
         const signatures = getSignaturesOfSymbol(c, getSymbolOfDeclaration(c, node));
         if (signatures.length > 1)
             return true;
         if (signatures.length === 1) {
+            // A JSDoc `@type` signature of the function itself is not an overload.
+            if (signatures[0] === getSignatureOfFullSignatureType(c, node))
+                return false;
             const declaration = signatures[0].declaration;
             if (declaration !== node && declaration !== undefined && (declaration.flags & 4194304 /* NodeFlags.JSDoc */) === 0)
                 return true;
@@ -176,7 +185,7 @@ export class CheckerDeclarationEmitResolver extends DeclarationEmitResolver {
         if ((node.flags & 16 /* NodeFlags.Synthesized */) !== 0)
             return false;
         const symbol = getSymbolOfDeclaration(this.checker, node);
-        return symbol !== undefined && (symbol.checkFlags & 4096 /* CheckFlags.Late */) !== 0;
+        return symbol !== undefined && (symbol.checkFlags & 32768 /* CheckFlags.Late */) !== 0;
     }
     isDefinitelyReferenceToGlobalSymbolObject(node) {
         if (!(node instanceof PropertyAccessExpression) || node.name.kind !== 79 /* SyntaxKind.Identifier */)
@@ -219,14 +228,14 @@ export class CheckerDeclarationEmitResolver extends DeclarationEmitResolver {
         if ((node.flags & 16 /* NodeFlags.Synthesized */) !== 0)
             return false;
         for (const p of this.getPropertiesOfContainerFunction(node))
-            if (p.valueDeclaration !== undefined && p.valueDeclaration.kind === 227 /* SyntaxKind.BinaryExpression */)
+            if (p.valueDeclaration !== undefined && p.valueDeclaration.kind === 228 /* SyntaxKind.BinaryExpression */)
                 return true;
         return false;
     }
     getExpandoPropertyDeclarations(node) {
         const result = [];
         for (const p of this.getPropertiesOfContainerFunction(node))
-            if (p.valueDeclaration !== undefined && p.valueDeclaration.kind === 227 /* SyntaxKind.BinaryExpression */)
+            if (p.valueDeclaration !== undefined && p.valueDeclaration.kind === 228 /* SyntaxKind.BinaryExpression */)
                 result.push(p.valueDeclaration);
         return result;
     }
@@ -237,9 +246,6 @@ export class CheckerDeclarationEmitResolver extends DeclarationEmitResolver {
             return [];
         return getPropertiesOfType(c, getTypeOfSymbol(c, symbol));
     }
-    getResolutionModeOverride(node) {
-        return this.syntactic.getResolutionModeOverride(node);
-    }
     getSourceFileFromReference(file, reference) {
         return this.syntactic.getSourceFileFromReference(file, reference);
     }
@@ -281,6 +287,12 @@ export class CheckerDeclarationEmitResolver extends DeclarationEmitResolver {
         const b = new NodeBuilder(this.checker, enclosingDeclaration, flags, declarationEmitInternalFlags, tracker, context);
         b.pseudo = newPseudoChecker(this.checker);
         b.declarationOrder = true;
+        // tsgo's emit resolver, one per emit context, keeps one node builder for all its requests.
+        if (context !== this.builderContext || this.builderCaches === undefined) {
+            this.builderContext = context;
+            this.builderCaches = new NodeBuilderCaches();
+        }
+        b.useCaches(this.builderCaches);
         return b;
     }
     createTypeOfDeclaration(context, declaration, enclosingDeclaration, flags, tracker) {
@@ -429,7 +441,7 @@ export function getTypeReferenceSerializationKind(c, typeName, location) {
         return 0 /* TypeReferenceSerializationKind.Unknown */;
     // The value must be reachable at runtime.
     let isTypeOnly = false;
-    if (typeName.kind === 167 /* SyntaxKind.QualifiedName */) {
+    if (typeName.kind === 168 /* SyntaxKind.QualifiedName */) {
         const root = resolveEntityName(c, getFirstIdentifier(typeName), 111551 /* SymbolFlags.Value */, true, true, location);
         if (root !== undefined && declarationCount(root) > 0)
             isTypeOnly = getDeclarations(root).every(isTypeOnlyImportOrExportDeclaration);
@@ -535,7 +547,7 @@ function areComponentsSerializable(c, components, enclosingDeclaration) {
     for (const component of components) {
         const name = getName(component);
         if (name === undefined ||
-            name.kind !== 168 /* SyntaxKind.ComputedPropertyName */ ||
+            name.kind !== 169 /* SyntaxKind.ComputedPropertyName */ ||
             !isEntityNameExpressionNode(getExpression(name)) ||
             isEntityNameVisible(c, getExpression(name), enclosingDeclaration, false).accessibility !==
                 0 /* SymbolAccessibility.Accessible */)