tsc-ts 0.0.9 → 0.1.0

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

@@ -3,7 +3,7 @@
 import { checkDeprecatedSignature } from './checker-deprecation.js';
 import { Node, getArguments as getArgumentList, getExpression, getName, getParameters, getText, getTypeArguments as getTypeArgumentList, getNodeId, getBody, getSymbol, callQuestionDotToken, callTypeArguments, } from './ast.js';
 import { canHaveDecorators, getEffectiveCheckNode, isFunctionLikeDeclarationKind, isImportCall, nodeIsPresent, } from './ast-utilities.js';
-import { getContainingClass, getSourceFileOfNode, isAccessExpression, isExpressionOfOptionalChainRoot, isOptionalChain, isOutermostOptionalChain, isDottedName, } from './binder-utilities.js';
+import { getContainingClass, getSourceFileOfNode, isAccessExpression, isExpressionOfOptionalChainRoot, isOptionalChain, isOutermostOptionalChain, isDottedName, isFunctionExpressionOrArrowFunction, } from './binder-utilities.js';
 import { Diagnostic, chainDiagnostic } from './diagnostics.js';
 import { resolveInstanceofExpression } from './checker-operators.js';
 import { skipTrivia } from './scanner.js';
@@ -20,7 +20,7 @@ import { getEffectsSignature } from './checker-narrowing.js';
 import { addOptionalTypeMarker, getOptionalType, getTypeOfSymbol, removeOptionalTypeMarker, } from './checker-symbol-types.js';
 import { checkTypeRelatedTo, getRegularTypeOfObjectLiteral, isTypeAssignableTo } from './relations.js';
 import { getNonNullableType } from './checker-flow.js';
-import { checkExpression, checkExpressionCached, checkNonNullType, checkNonNullTypeEx, checkTypeQueryExpression, } from './checker-expressions.js';
+import { checkExpression, checkExpressionCached, checkNonNullType, checkNonNullTypeEx, checkTypeQueryExpression, getResolvedSymbol, } from './checker-expressions.js';
 import { checkIteratedTypeOrElementType } from './checker-iteration.js';
 import { isContextSensitive } from './checker-functions.js';
 import { getExtendsHeritageClauseElement, getInstantiatedConstructorsForTypeArguments, fillMissingTypeArguments, getConstraintOfTypeParameter, getDefaultFromTypeParameter, getMinTypeArgumentCount, } from './checker-declared-types.js';
@@ -29,7 +29,7 @@ import { getIndexedAccessTypeEx, getRestTypeOfTupleType } from './checker-type-o
 import { instantiateType, isNodeDescendantOf } from './instantiation.js';
 import { maybeTypeOfKind } from './checker-utilities.js';
 import { checkSourceElement, checkNodeDeferred } from './checker-source-file.js';
-import { InferenceInfo, applyToParameterTypes, applyToReturnTypes, hasOverlappingInferences, instantiateSignatureInContextOf, mergeInferences, cloneInferenceContext, cloneInferredPartOfContext, createInferenceContext, createOuterReturnMapper, getInferredTypes, getMapperFromContext, everyInferenceHasCandidates, someInferenceHasCandidates, inferTypes, isConstTypeVariable, isMutableArrayLikeType, } from './checker-inference.js';
+import { InferenceInfo, applyToParameterTypes, applyToReturnTypes, hasOverlappingInferences, instantiateSignatureInContextOf, mergeInferences, cloneInferenceContext, cloneInferredPartOfContext, createInferenceContext, createOuterReturnMapper, getInferredTypes, getMapperFromContext, everyInferenceHasCandidates, someInferenceHasCandidates, inferTypes, inferTypesFromUnstarted, isConstTypeVariable, isMutableArrayLikeType, } from './checker-inference.js';
 import { checkExpressionWithContextualType, getApparentTypeOfContextualTypeEx, getContextualTypeEx, getContextualTypeForElementExpression, getInferenceContext, } from './checker-contextual.js';
 import { couldContainTypeVariables } from './instantiation.js';
 import { typeToString } from './type-printer.js';
@@ -38,7 +38,7 @@ import { getGlobalValueSymbol, getSymbolOfDeclaration, resolveName } from './che
 import { checkImportCallExpression } from './checker-modules.js';
 import { checkApplicableSignatureForJsxCallLikeElement, getAttributesOf, getEffectiveJsxArguments, inferJsxTypeArguments, isJsxOpeningLikeElement, resolveJsxOpeningLikeElement, } from './checker-jsx.js';
 import { isCommonJSRequire, resolveExternalModuleTypeByLiteral } from './checker-javascript.js';
-import { declarationCount, getDeclarations } from './symbol.js';
+import { copyDeclarations, declarationCount, getDeclarations, } from './symbol.js';
 /** The type of an optional chain's expression with the chain's `undefined` removed. */
 export function getOptionalExpressionType(c, exprType, expression) {
     if (isExpressionOfOptionalChainRoot(expression))
@@ -73,26 +73,26 @@ export function checkCallExpression(c, node, checkMode) {
         return getESSymbolLikeTypeForNode(c, walkUpParenthesizedExpressions(node.parent));
     // An assertion call must name its target through explicitly typed declarations.
     if (callQuestionDotToken(call) === undefined &&
-        node.parent.kind === 245 /* SyntaxKind.ExpressionStatement */ &&
+        node.parent.kind === 246 /* SyntaxKind.ExpressionStatement */ &&
         (returnType.flags & 16 /* TypeFlags.Void */) !== 0 &&
         getTypePredicateOfSignature(c, signature) !== undefined) {
         if (!isDottedName(callee))
-            c.error(callee, 908 /* Diagnostics.Assertions_require_the_call_target_to_be_an_identifier_or_qualified_name */);
+            c.error(callee, 915 /* Diagnostics.Assertions_require_the_call_target_to_be_an_identifier_or_qualified_name */);
         else if (getEffectsSignature(c, node) === undefined)
-            c.error(callee, 907 /* Diagnostics.Assertions_require_every_name_in_the_call_target_to_be_declared_with_an_explicit_type_annotation */);
+            c.error(callee, 914 /* Diagnostics.Assertions_require_every_name_in_the_call_target_to_be_declared_with_an_explicit_type_annotation */);
     }
     return returnType;
 }
 function walkUpParenthesizedExpressions(node) {
     let current = node;
-    while (current.kind === 218 /* SyntaxKind.ParenthesizedExpression */)
+    while (current.kind === 219 /* SyntaxKind.ParenthesizedExpression */)
         current = current.parent;
     return current;
 }
 /** Whether `node` calls the global `Symbol` or `Symbol.for`. */
 export function isSymbolOrSymbolForCall(c, node) {
     let left = node.expression;
-    if (left.kind === 212 /* SyntaxKind.PropertyAccessExpression */ && getText(getName(left)) === 'for')
+    if (left.kind === 213 /* SyntaxKind.PropertyAccessExpression */ && getText(getName(left)) === 'for')
         left = getExpression(left);
     if (left.kind !== 79 /* SyntaxKind.Identifier */ || getText(left) !== 'Symbol')
         return false;
@@ -107,12 +107,12 @@ export function checkNewExpression(c, node, checkMode) {
     checkDeprecatedSignature(c, signature, node);
     const declaration = signature.declaration;
     if (declaration !== undefined &&
-        declaration.kind !== 177 /* SyntaxKind.Constructor */ &&
-        declaration.kind !== 181 /* SyntaxKind.ConstructSignature */ &&
-        declaration.kind !== 186 /* SyntaxKind.ConstructorType */) {
+        declaration.kind !== 178 /* SyntaxKind.Constructor */ &&
+        declaration.kind !== 182 /* SyntaxKind.ConstructSignature */ &&
+        declaration.kind !== 187 /* SyntaxKind.ConstructorType */) {
         // A call signature resolved for `new` makes the result `any`.
         if (c.noImplicitAny)
-            c.error(node, 1681 /* Diagnostics.X_new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type */);
+            c.error(node, 1700 /* Diagnostics.X_new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type */);
         return c.anyType;
     }
     return getReturnTypeOfSignature(c, signature);
@@ -154,19 +154,19 @@ export function resolveCallSignatureForContext(c, call) {
 }
 function resolveSignature(c, node, checkMode) {
     switch (node.kind) {
-        case 214 /* SyntaxKind.CallExpression */:
+        case 215 /* SyntaxKind.CallExpression */:
             return resolveCallExpression(c, node, checkMode);
-        case 215 /* SyntaxKind.NewExpression */:
+        case 216 /* SyntaxKind.NewExpression */:
             return resolveNewExpression(c, node, checkMode);
-        case 216 /* SyntaxKind.TaggedTemplateExpression */:
+        case 217 /* SyntaxKind.TaggedTemplateExpression */:
             return resolveTaggedTemplateExpression(c, node, checkMode);
-        case 287 /* SyntaxKind.JsxOpeningElement */:
-        case 286 /* SyntaxKind.JsxSelfClosingElement */:
-        case 290 /* SyntaxKind.JsxOpeningFragment */:
+        case 288 /* SyntaxKind.JsxOpeningElement */:
+        case 287 /* SyntaxKind.JsxSelfClosingElement */:
+        case 291 /* SyntaxKind.JsxOpeningFragment */:
             return resolveJsxOpeningLikeElement(c, node, checkMode);
-        case 171 /* SyntaxKind.Decorator */:
+        case 172 /* SyntaxKind.Decorator */:
             return resolveDecorator(c, node, checkMode);
-        case 227 /* SyntaxKind.BinaryExpression */:
+        case 228 /* SyntaxKind.BinaryExpression */:
             return resolveInstanceofExpression(c, node, checkMode);
     }
     return resolveUntypedCall(c, node);
@@ -197,12 +197,12 @@ function resolveCallExpression(c, node, checkMode) {
     const numConstructSignatures = getSignaturesOfType(c, apparentType, 1 /* SignatureKind.Construct */).length;
     if (isUntypedFunctionCall(c, funcType, apparentType, callSignatures.length, numConstructSignatures)) {
         if (!isErrorType(c, funcType) && callTypeArguments(node) !== undefined)
-            c.error(node, 523 /* Diagnostics.Untyped_function_calls_may_not_accept_type_arguments */);
+            c.error(node, 530 /* Diagnostics.Untyped_function_calls_may_not_accept_type_arguments */);
         return resolveUntypedCall(c, node);
     }
     if (callSignatures.length === 0) {
         if (numConstructSignatures !== 0)
-            c.error(node, 524 /* Diagnostics.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new */, typeToString(c, funcType));
+            c.error(node, 531 /* Diagnostics.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new */, typeToString(c, funcType));
         else
             invocationError(c, callee, apparentType, 0 /* SignatureKind.Call */);
         return resolveErrorCall(c, node);
@@ -246,15 +246,15 @@ function resolveNewExpression(c, node, checkMode) {
         return resolveErrorCall(c, node);
     if ((expressionType.flags & 1 /* TypeFlags.Any */) !== 0) {
         if (node.typeArguments !== undefined && node.typeArguments.nodes.length !== 0)
-            c.error(node, 523 /* Diagnostics.Untyped_function_calls_may_not_accept_type_arguments */);
+            c.error(node, 530 /* Diagnostics.Untyped_function_calls_may_not_accept_type_arguments */);
         return resolveUntypedCall(c, node);
     }
     const constructSignatures = getSignaturesOfType(c, expressionType, 1 /* SignatureKind.Construct */);
     if (constructSignatures.length !== 0) {
-        if (!isConstructorAccessible(c, node, constructSignatures[0]))
+        if (!isConstructorAccessible(c, node, constructSignatures))
             return resolveErrorCall(c, node);
         if (someSignature(constructSignatures, (s) => (s.flags & 8 /* SignatureFlags.Abstract */) !== 0)) {
-            c.error(node, 671 /* Diagnostics.Cannot_create_an_instance_of_an_abstract_class */);
+            c.error(node, 678 /* Diagnostics.Cannot_create_an_instance_of_an_abstract_class */);
             return resolveErrorCall(c, node);
         }
         return resolveCall(c, node, constructSignatures, checkMode, 0 /* SignatureFlags.None */, undefined);
@@ -265,9 +265,9 @@ function resolveNewExpression(c, node, checkMode) {
         const signature = resolveCall(c, node, callSignatures, checkMode, 0 /* SignatureFlags.None */, undefined);
         if (!c.noImplicitAny) {
             if (signature.declaration !== undefined && getReturnTypeOfSignature(c, signature) !== c.voidType)
-                c.error(node, 526 /* Diagnostics.Only_a_void_function_can_be_called_with_the_new_keyword */);
+                c.error(node, 533 /* Diagnostics.Only_a_void_function_can_be_called_with_the_new_keyword */);
             if (getThisTypeOfSignature(c, signature) === c.voidType)
-                c.error(node, 813 /* Diagnostics.A_function_that_is_called_with_the_new_keyword_cannot_have_a_this_type_that_is_void */);
+                c.error(node, 820 /* Diagnostics.A_function_that_is_called_with_the_new_keyword_cannot_have_a_this_type_that_is_void */);
         }
         return signature;
     }
@@ -312,8 +312,8 @@ function resolveTaggedTemplateExpression(c, node, checkMode) {
     if (isUntypedFunctionCall(c, tagType, apparentType, callSignatures.length, numConstructSignatures))
         return resolveUntypedCall(c, node);
     if (callSignatures.length === 0) {
-        if (node.parent !== undefined && node.parent.kind === 210 /* SyntaxKind.ArrayLiteralExpression */) {
-            c.error(tag, 928 /* Diagnostics.It_is_likely_that_you_are_missing_a_comma_to_separate_these_two_template_expressions_They_form_a_tagged_template_expression_which_cannot_be_invoked */);
+        if (node.parent !== undefined && node.parent.kind === 211 /* SyntaxKind.ArrayLiteralExpression */) {
+            c.error(tag, 935 /* Diagnostics.It_is_likely_that_you_are_missing_a_comma_to_separate_these_two_template_expressions_They_form_a_tagged_template_expression_which_cannot_be_invoked */);
             return resolveErrorCall(c, node);
         }
         invocationError(c, tag, apparentType, 0 /* SignatureKind.Call */);
@@ -335,7 +335,7 @@ function resolveDecorator(c, node, checkMode) {
     if (isUntypedFunctionCall(c, funcType, apparentType, callSignatures.length, numConstructSignatures))
         return resolveUntypedCall(c, node);
     if (isPotentiallyUncalledDecorator(c, node, callSignatures) &&
-        expression.kind !== 218 /* SyntaxKind.ParenthesizedExpression */) {
+        expression.kind !== 219 /* SyntaxKind.ParenthesizedExpression */) {
         c.error(node, 265 /* Diagnostics.X_0_accepts_too_few_arguments_to_be_used_as_a_decorator_here_Did_you_mean_to_call_it_first_and_write_0 */, getUncalledDecoratorText(node));
         return resolveErrorCall(c, node);
     }
@@ -360,15 +360,15 @@ export function isUntypedFunctionCall(c, funcType, apparentFuncType, numCallSign
 }
 export function resolveUntypedCall(c, node) {
     // Type arguments are checked even though untyped calls can't accept them.
-    if (node.kind === 214 /* SyntaxKind.CallExpression */ ||
-        node.kind === 215 /* SyntaxKind.NewExpression */ ||
-        node.kind === 216 /* SyntaxKind.TaggedTemplateExpression */ ||
+    if (node.kind === 215 /* SyntaxKind.CallExpression */ ||
+        node.kind === 216 /* SyntaxKind.NewExpression */ ||
+        node.kind === 217 /* SyntaxKind.TaggedTemplateExpression */ ||
         isJsxOpeningLikeElement(node))
         for (const t of getCallTypeArguments(node))
             checkSourceElement(c, t);
-    if (node.kind === 216 /* SyntaxKind.TaggedTemplateExpression */) {
+    if (node.kind === 217 /* SyntaxKind.TaggedTemplateExpression */) {
         const template = node.template;
-        if (template.kind === 229 /* SyntaxKind.TemplateExpression */)
+        if (template.kind === 230 /* SyntaxKind.TemplateExpression */)
             for (const span of template.templateSpans.nodes)
                 checkExpression(c, getExpression(span));
     }
@@ -384,29 +384,29 @@ export function resolveErrorCall(c, node) {
 function invocationError(c, errorTarget, apparentType, kind) {
     const isCall = kind === 0 /* SignatureKind.Call */;
     const parent = errorTarget.parent;
-    const target = errorTarget.kind === 212 /* SyntaxKind.PropertyAccessExpression */ &&
+    const target = errorTarget.kind === 213 /* SyntaxKind.PropertyAccessExpression */ &&
         parent !== undefined &&
-        parent.kind === 214 /* SyntaxKind.CallExpression */
+        parent.kind === 215 /* SyntaxKind.CallExpression */
         ? getName(errorTarget)
         : errorTarget;
     let headMessage = isCall
-        ? 525 /* Diagnostics.This_expression_is_not_callable */
-        : 527 /* Diagnostics.This_expression_is_not_constructable */;
+        ? 532 /* Diagnostics.This_expression_is_not_callable */
+        : 534 /* Diagnostics.This_expression_is_not_constructable */;
     // A get accessor called as a function.
     if (parent !== undefined &&
-        parent.kind === 214 /* SyntaxKind.CallExpression */ &&
+        parent.kind === 215 /* SyntaxKind.CallExpression */ &&
         parent.arguments.nodes.length === 0) {
         const resolvedSymbol = c.resolvedSymbols.get(errorTarget.id);
         if (resolvedSymbol !== undefined && (resolvedSymbol.flags & 32768 /* SymbolFlags.GetAccessor */) !== 0)
             headMessage =
-                1386 /* Diagnostics.This_expression_is_not_callable_because_it_is_a_get_accessor_Did_you_mean_to_use_it_without */;
+                1397 /* Diagnostics.This_expression_is_not_callable_because_it_is_a_get_accessor_Did_you_mean_to_use_it_without */;
     }
     c.addDiagnostic(chainDiagnostic(getInvocationErrorDetails(c, target, apparentType, isCall), headMessage));
 }
 function getInvocationErrorDetails(c, target, apparentType, isCall) {
     const kind = isCall ? 0 /* SignatureKind.Call */ : 1 /* SignatureKind.Construct */;
     if ((apparentType.flags & 134217728 /* TypeFlags.Union */) === 0)
-        return createDiagnosticForNode(target, isCall ? 889 /* Diagnostics.Type_0_has_no_call_signatures */ : 893 /* Diagnostics.Type_0_has_no_construct_signatures */, [typeToString(c, apparentType)]);
+        return createDiagnosticForNode(target, isCall ? 896 /* Diagnostics.Type_0_has_no_call_signatures */ : 900 /* Diagnostics.Type_0_has_no_construct_signatures */, [typeToString(c, apparentType)]);
     let diagnostic = undefined;
     let hasSignatures = false;
     for (const constituent of typesOf(apparentType)) {
@@ -418,19 +418,19 @@ function getInvocationErrorDetails(c, target, apparentType, isCall) {
         }
         else if (diagnostic === undefined) {
             // The first non-callable constituent.
-            diagnostic = chainDiagnostic(createDiagnosticForNode(target, isCall ? 889 /* Diagnostics.Type_0_has_no_call_signatures */ : 893 /* Diagnostics.Type_0_has_no_construct_signatures */, [typeToString(c, constituent)]), isCall
-                ? 888 /* Diagnostics.Not_all_constituents_of_type_0_are_callable */
-                : 892 /* Diagnostics.Not_all_constituents_of_type_0_are_constructable */, typeToString(c, apparentType));
+            diagnostic = chainDiagnostic(createDiagnosticForNode(target, isCall ? 896 /* Diagnostics.Type_0_has_no_call_signatures */ : 900 /* Diagnostics.Type_0_has_no_construct_signatures */, [typeToString(c, constituent)]), isCall
+                ? 895 /* Diagnostics.Not_all_constituents_of_type_0_are_callable */
+                : 899 /* Diagnostics.Not_all_constituents_of_type_0_are_constructable */, typeToString(c, apparentType));
             if (hasSignatures)
                 break;
         }
     }
     if (!hasSignatures)
-        return createDiagnosticForNode(target, isCall ? 887 /* Diagnostics.No_constituent_of_type_0_is_callable */ : 891 /* Diagnostics.No_constituent_of_type_0_is_constructable */, [typeToString(c, apparentType)]);
+        return createDiagnosticForNode(target, isCall ? 894 /* Diagnostics.No_constituent_of_type_0_is_callable */ : 898 /* Diagnostics.No_constituent_of_type_0_is_constructable */, [typeToString(c, apparentType)]);
     return (diagnostic ??
         createDiagnosticForNode(target, isCall
-            ? 890 /* Diagnostics.Each_member_of_the_union_type_0_has_signatures_but_none_of_those_signatures_are_compatible_with_each_other */
-            : 894 /* Diagnostics.Each_member_of_the_union_type_0_has_construct_signatures_but_none_of_those_signatures_are_compatible_with_each_other */, [typeToString(c, apparentType)]));
+            ? 897 /* Diagnostics.Each_member_of_the_union_type_0_has_signatures_but_none_of_those_signatures_are_compatible_with_each_other */
+            : 901 /* Diagnostics.Each_member_of_the_union_type_0_has_construct_signatures_but_none_of_those_signatures_are_compatible_with_each_other */, [typeToString(c, apparentType)]));
 }
 function checkNonNullTypeForCall(c, t, node) {
     return checkNonNullTypeEx(c, t, node, true);
@@ -456,7 +456,7 @@ export class SyntheticExpression extends Node {
     isSpread;
     tupleNameSource;
     constructor(parent, type, isSpread, tupleNameSource) {
-        super(238 /* SyntaxKind.SyntheticExpression */);
+        super(239 /* SyntaxKind.SyntheticExpression */);
         this.parent = parent;
         this.pos = parent.pos;
         this.end = parent.end;
@@ -473,12 +473,12 @@ export class SyntheticExpression extends Node {
     }
 }
 function getCallArgumentNodes(node) {
-    if (node.kind === 227 /* SyntaxKind.BinaryExpression */)
+    if (node.kind === 228 /* SyntaxKind.BinaryExpression */)
         return [node.left];
-    if (node.kind === 216 /* SyntaxKind.TaggedTemplateExpression */) {
+    if (node.kind === 217 /* SyntaxKind.TaggedTemplateExpression */) {
         const template = node.template;
         const args = [template];
-        if (template.kind === 229 /* SyntaxKind.TemplateExpression */)
+        if (template.kind === 230 /* SyntaxKind.TemplateExpression */)
             for (const span of template.templateSpans.nodes)
                 args.push(getExpression(span));
         return args;
@@ -489,11 +489,11 @@ function getCallArgumentNodes(node) {
 /** The arguments of a call, with spreads of tuples expanded and a tagged template's strings first. */
 export function getEffectiveCallArguments(c, node) {
     // A fragment's attributes have no `children` yet, like those of `<React.Fragment>`.
-    if (node.kind === 290 /* SyntaxKind.JsxOpeningFragment */)
+    if (node.kind === 291 /* SyntaxKind.JsxOpeningFragment */)
         return [new SyntheticExpression(node, c.emptyFreshJsxObjectType, false, undefined)];
     if (isJsxOpeningLikeElement(node))
         return getEffectiveJsxArguments(node);
-    if (node.kind === 171 /* SyntaxKind.Decorator */) {
+    if (node.kind === 172 /* SyntaxKind.Decorator */) {
         // One synthetic argument per parameter of the decorator's call signature.
         const expression = node.expression;
         const args = [];
@@ -501,10 +501,10 @@ export function getEffectiveCallArguments(c, node) {
             args.push(new SyntheticExpression(expression, t, false, undefined));
         return args;
     }
-    if (node.kind === 216 /* SyntaxKind.TaggedTemplateExpression */) {
+    if (node.kind === 217 /* SyntaxKind.TaggedTemplateExpression */) {
         const template = node.template;
         const args = [new SyntheticExpression(template, getGlobalTemplateStringsArrayType(c), false, undefined)];
-        if (template.kind === 229 /* SyntaxKind.TemplateExpression */)
+        if (template.kind === 230 /* SyntaxKind.TemplateExpression */)
             for (const span of template.templateSpans.nodes)
                 args.push(getExpression(span));
         return args;
@@ -518,7 +518,7 @@ export function getEffectiveCallArguments(c, node) {
     for (let i = spreadIndex; i < args.length; i++) {
         const arg = args[i];
         // Spread expressions never have a contextual type, so caching is safe.
-        const spreadType = arg.kind === 231 /* SyntaxKind.SpreadElement */
+        const spreadType = arg.kind === 232 /* SyntaxKind.SpreadElement */
             ? c.flowLoopStack.length !== 0
                 ? checkExpression(c, arg.expression)
                 : checkExpressionCached(c, arg.expression)
@@ -538,7 +538,7 @@ export function getEffectiveCallArguments(c, node) {
 }
 /** Checks an argument with the parameter type as its contextual type. */
 function checkArgument(c, arg, paramType, context, checkMode) {
-    if (arg.kind === 238 /* SyntaxKind.SyntheticExpression */)
+    if (arg.kind === 239 /* SyntaxKind.SyntheticExpression */)
         return checkSyntheticExpression(c, arg);
     return checkExpressionWithContextualType(c, arg, paramType, context, checkMode);
 }
@@ -555,8 +555,8 @@ function getSpreadArgumentIndex(args) {
     return -1;
 }
 function isSpreadArgument(arg) {
-    return (arg.kind === 231 /* SyntaxKind.SpreadElement */ ||
-        (arg.kind === 238 /* SyntaxKind.SyntheticExpression */ && arg.isSpread));
+    return (arg.kind === 232 /* SyntaxKind.SpreadElement */ ||
+        (arg.kind === 239 /* SyntaxKind.SyntheticExpression */ && arg.isSpread));
 }
 /** The rest arguments from `index` as a tuple, or an array for a trailing spread to a rest parameter. */
 function getSpreadArgumentType(c, call, args, index, argCount, restType, context, checkMode) {
@@ -565,12 +565,12 @@ function getSpreadArgumentType(c, call, args, index, argCount, restType, context
         const arg = args[argCount - 1];
         if (isSpreadArgument(arg)) {
             // A spread in the last position to a rest parameter: both are `...x` forms.
-            const spreadType = arg.kind === 238 /* SyntaxKind.SyntheticExpression */
+            const spreadType = arg.kind === 239 /* SyntaxKind.SyntheticExpression */
                 ? arg.type
                 : checkExpressionWithContextualType(c, arg.expression, restType, context, checkMode);
             if (isArrayLikeType(c, spreadType))
                 return getMutableArrayOrTupleType(c, spreadType);
-            const errorNode = arg.kind === 231 /* SyntaxKind.SpreadElement */ ? arg.expression : arg;
+            const errorNode = arg.kind === 232 /* SyntaxKind.SpreadElement */ ? arg.expression : arg;
             return createArrayTypeEx(c, checkIteratedTypeOrElementType(c, 33 /* IterationUse.Spread */, spreadType, c.undefinedType, errorNode), inConstContext);
         }
     }
@@ -579,7 +579,7 @@ function getSpreadArgumentType(c, call, args, index, argCount, restType, context
     for (let i = index; i < argCount; i++) {
         const arg = args[i];
         if (isSpreadArgument(arg)) {
-            const spreadType = arg.kind === 238 /* SyntaxKind.SyntheticExpression */
+            const spreadType = arg.kind === 239 /* SyntaxKind.SyntheticExpression */
                 ? arg.type
                 : checkExpression(c, arg.expression);
             if (isArrayLikeType(c, spreadType)) {
@@ -587,7 +587,7 @@ function getSpreadArgumentType(c, call, args, index, argCount, restType, context
                 infos.push(new TupleElementInfo(8 /* ElementFlags.Variadic */, undefined));
             }
             else {
-                const errorNode = arg.kind === 231 /* SyntaxKind.SpreadElement */ ? arg.expression : arg;
+                const errorNode = arg.kind === 232 /* SyntaxKind.SpreadElement */ ? arg.expression : arg;
                 types.push(checkIteratedTypeOrElementType(c, 33 /* IterationUse.Spread */, spreadType, c.undefinedType, errorNode));
                 infos.push(new TupleElementInfo(4 /* ElementFlags.Rest */, undefined));
             }
@@ -600,7 +600,7 @@ function getSpreadArgumentType(c, call, args, index, argCount, restType, context
         const hasPrimitiveContextualType = inConstContext ||
             maybeTypeOfKind(contextualType, 12713980 /* TypeFlags.Primitive */ | 2097152 /* TypeFlags.Index */ | 4194304 /* TypeFlags.TemplateLiteral */ | 8388608 /* TypeFlags.StringMapping */);
         types.push(hasPrimitiveContextualType ? getRegularTypeOfLiteralType(c, argType) : getWidenedLiteralType(c, argType));
-        infos.push(new TupleElementInfo(1 /* ElementFlags.Required */, arg.kind === 238 /* SyntaxKind.SyntheticExpression */ ? arg.tupleNameSource : undefined));
+        infos.push(new TupleElementInfo(1 /* ElementFlags.Required */, arg.kind === 239 /* SyntaxKind.SyntheticExpression */ ? arg.tupleNameSource : undefined));
     }
     return createTupleTypeEx(c, types, infos, inConstContext && !someType(restType, (t) => isMutableArrayLikeType(c, t)));
 }
@@ -626,6 +626,8 @@ class CallState {
     candidates;
     argCheckMode = 0 /* CheckMode.Normal */;
     isSingleNonGenericCandidate = false;
+    /** The call is resolved while its own resolution is in progress. */
+    recursiveResolution = false;
     candidatesForArgumentError = [];
     candidateForArgumentArityError = undefined;
     candidateForTypeArgumentError = undefined;
@@ -637,9 +639,9 @@ class CallState {
     }
 }
 function getCallTypeArguments(node) {
-    if (node.kind === 290 /* SyntaxKind.JsxOpeningFragment */ || node.kind === 171 /* SyntaxKind.Decorator */)
+    if (node.kind === 291 /* SyntaxKind.JsxOpeningFragment */ || node.kind === 172 /* SyntaxKind.Decorator */)
         return [];
-    if (node.kind === 214 /* SyntaxKind.CallExpression */ && node.expression.kind === 107 /* SyntaxKind.SuperKeyword */)
+    if (node.kind === 215 /* SyntaxKind.CallExpression */ && node.expression.kind === 107 /* SyntaxKind.SuperKeyword */)
         return [];
     const list = getTypeArgumentList(node);
     return list !== undefined ? list.nodes : [];
@@ -656,14 +658,27 @@ export function resolveCall(c, node, signatures, checkMode, callChainFlags, head
     // included in a second pass with their contextual types fixed.
     s.isSingleNonGenericCandidate = candidates.length === 1 && candidates[0].typeParameters.length === 0;
     // Decorator arguments are synthetic, so never context sensitive.
-    if (node.kind !== 171 /* SyntaxKind.Decorator */ && !s.isSingleNonGenericCandidate && someContextSensitive(c, s.args))
+    if (node.kind !== 172 /* SyntaxKind.Decorator */ && !s.isSingleNonGenericCandidate && someContextSensitive(c, s.args))
         s.argCheckMode = 4 /* CheckMode.SkipContextSensitive */;
     // A subtype pass picks the best overload; assignability decides whether the call is an error.
     let result = undefined;
+    const callResolutionDepth = c.callResolutionDepth;
+    const callResolutionStack = c.callResolutionStack;
+    for (let i = 0; i < callResolutionDepth; i++)
+        if (callResolutionStack[i] === node) {
+            s.recursiveResolution = true;
+            break;
+        }
+    if (callResolutionDepth < callResolutionStack.length)
+        callResolutionStack[callResolutionDepth] = node;
+    else
+        callResolutionStack.push(node);
+    c.callResolutionDepth = callResolutionDepth + 1;
     if (candidates.length > 1)
         result = chooseOverload(c, s, c.subtypeRelation);
     if (result === undefined)
         result = chooseOverload(c, s, c.assignableRelation);
+    c.callResolutionDepth = callResolutionDepth;
     if (result !== undefined)
         return result;
     result = getCandidateForOverloadFailure(c, node, s.candidates, s.args, checkMode);
@@ -709,7 +724,11 @@ export function reorderCandidates(c, signatures, callChainFlags) {
             spliceIndex = index;
         if (callChainFlags !== 0)
             signature = getOptionalCallSignature(c, signature, callChainFlags);
-        result.splice(spliceIndex, 0, signature);
+        // Most signatures go at the end, where a push is cheaper than an inserting splice.
+        if (spliceIndex === result.length)
+            result.push(signature);
+        else
+            result.splice(spliceIndex, 0, signature);
     }
     return result;
 }
@@ -760,7 +779,12 @@ function chooseOverload(c, s, relation) {
                 }
             }
             else {
-                inferenceContext = createInferenceContext(c, candidate.typeParameters, candidate, isInJSFile(s.node) ? 2 /* InferenceFlags.AnyDefault */ : 0 /* InferenceFlags.None */, undefined);
+                inferenceContext = createInferenceContext(c, candidate.typeParameters, candidate, 
+                // A recursive resolution of a call with one candidate skips constraint checks during inference, which
+                // would otherwise report circularities.
+                (s.recursiveResolution && s.candidates.length === 1
+                    ? 8 /* InferenceFlags.NoConstraintChecks */
+                    : 0 /* InferenceFlags.None */) | (isInJSFile(s.node) ? 2 /* InferenceFlags.AnyDefault */ : 0 /* InferenceFlags.None */), undefined);
                 typeArgumentTypes = inferTypeArguments(c, s.node, candidate, s.args, s.argCheckMode | 8 /* CheckMode.SkipGenericFunctions */, inferenceContext);
                 if ((inferenceContext.flags & 4 /* InferenceFlags.SkippedGenericFunction */) !== 0)
                     s.argCheckMode |= 8 /* CheckMode.SkipGenericFunctions */;
@@ -804,7 +828,7 @@ function isInJSFile(node) {
     return node !== undefined && (node.flags & 65536 /* NodeFlags.JavaScriptFile */) !== 0;
 }
 function hasCorrectArity(c, node, args, signature) {
-    if (node.kind === 290 /* SyntaxKind.JsxOpeningFragment */)
+    if (node.kind === 291 /* SyntaxKind.JsxOpeningFragment */)
         return true;
     let argCount;
     let callIsIncomplete = false;
@@ -821,10 +845,10 @@ function hasCorrectArity(c, node, args, signature) {
         // A component's extra parameters, such as a legacy context, are provided by the library.
         effectiveMinimumArguments = Math.min(effectiveMinimumArguments, 1);
     }
-    else if (node.kind === 216 /* SyntaxKind.TaggedTemplateExpression */) {
+    else if (node.kind === 217 /* SyntaxKind.TaggedTemplateExpression */) {
         argCount = args.length;
         const template = node.template;
-        if (template.kind === 229 /* SyntaxKind.TemplateExpression */) {
+        if (template.kind === 230 /* SyntaxKind.TemplateExpression */) {
             // A template without a tail literal makes the call incomplete.
             const spans = template.templateSpans.nodes;
             const literal = spans[spans.length - 1].literal;
@@ -833,10 +857,10 @@ function hasCorrectArity(c, node, args, signature) {
         else
             callIsIncomplete = isUnterminatedLiteral(template);
     }
-    else if (node.kind === 171 /* SyntaxKind.Decorator */) {
+    else if (node.kind === 172 /* SyntaxKind.Decorator */) {
         argCount = getDecoratorArgumentCount(c, node, signature);
     }
-    else if (node.kind === 215 /* SyntaxKind.NewExpression */ && node.arguments === undefined) {
+    else if (node.kind === 216 /* SyntaxKind.NewExpression */ && node.arguments === undefined) {
         // `new C`
         return getMinArgumentCount(c, signature) === 0;
     }
@@ -882,7 +906,7 @@ function checkTypeArguments(c, signature, typeArgumentNodes, reportErrors, headM
             continue;
         const typeArgument = typeArgumentTypes[i];
         const diagnostics = [];
-        if (!checkTypeRelatedTo(c, typeArgument, getTypeWithThisArgument(c, instantiateType(c, constraint, mapper), typeArgument, false), c.assignableRelation, reportErrors ? typeArgumentNodes[i] : undefined, headMessage ?? 520 /* Diagnostics.Type_0_does_not_satisfy_the_constraint_1 */, diagnostics)) {
+        if (!checkTypeRelatedTo(c, typeArgument, getTypeWithThisArgument(c, instantiateType(c, constraint, mapper), typeArgument, false), c.assignableRelation, reportErrors ? typeArgumentNodes[i] : undefined, headMessage ?? 527 /* Diagnostics.Type_0_does_not_satisfy_the_constraint_1 */, diagnostics)) {
             if (diagnostics.length !== 0)
                 c.addDiagnostic(diagnostics[0]);
             return undefined;
@@ -891,26 +915,26 @@ function checkTypeArguments(c, signature, typeArgumentNodes, reportErrors, headM
     return typeArgumentTypes;
 }
 function isSignatureApplicable(c, node, args, signature, relation, checkMode, reportErrors, diagnosticOutput) {
-    if (isJsxOpeningLikeElement(node) || node.kind === 290 /* SyntaxKind.JsxOpeningFragment */)
+    if (isJsxOpeningLikeElement(node) || node.kind === 291 /* SyntaxKind.JsxOpeningFragment */)
         return checkApplicableSignatureForJsxCallLikeElement(c, node, signature, relation, checkMode, reportErrors, diagnosticOutput);
     const thisType = getThisTypeOfSignature(c, signature);
     if (thisType !== undefined &&
         thisType !== c.voidType &&
-        !(node.kind === 215 /* SyntaxKind.NewExpression */ ||
-            (node.kind === 214 /* SyntaxKind.CallExpression */ && isSuperProperty(getExpression(node))))) {
+        !(node.kind === 216 /* SyntaxKind.NewExpression */ ||
+            (node.kind === 215 /* SyntaxKind.CallExpression */ && isSuperProperty(getExpression(node))))) {
         // Without an `x.f` callee the `this` argument is `void`.
         const thisArgumentNode = getThisArgumentOfCall(c, node);
         const thisArgumentType = getThisArgumentType(c, thisArgumentNode);
         const errorNode = reportErrors ? (thisArgumentNode ?? node) : undefined;
-        if (!checkTypeRelatedTo(c, thisArgumentType, thisType, relation, errorNode, 817 /* Diagnostics.The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1 */, diagnosticOutput))
+        if (!checkTypeRelatedTo(c, thisArgumentType, thisType, relation, errorNode, 824 /* Diagnostics.The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1 */, diagnosticOutput))
             return false;
     }
-    const headMessage = 521 /* Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1 */;
+    const headMessage = 528 /* Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1 */;
     const restType = getNonArrayRestType(c, signature);
     const argCount = restType !== undefined ? Math.min(getParameterCount(c, signature) - 1, args.length) : args.length;
     for (let i = 0; i < argCount; i++) {
         const arg = args[i];
-        if (arg.kind === 233 /* SyntaxKind.OmittedExpression */)
+        if (arg.kind === 234 /* SyntaxKind.OmittedExpression */)
             continue;
         const paramType = getTypeAtPosition(c, signature, i);
         const argType = checkArgument(c, arg, paramType, undefined, checkMode);
@@ -956,20 +980,20 @@ function isUnterminatedLiteral(node) {
     return false;
 }
 function isSuperProperty(node) {
-    return ((node.kind === 212 /* SyntaxKind.PropertyAccessExpression */ || node.kind === 213 /* SyntaxKind.ElementAccessExpression */) &&
+    return ((node.kind === 213 /* SyntaxKind.PropertyAccessExpression */ || node.kind === 214 /* SyntaxKind.ElementAccessExpression */) &&
         getExpression(node).kind === 107 /* SyntaxKind.SuperKeyword */);
 }
 /** The `this` argument of `x.f(...)` and `x[f](...)`. */
 function getThisArgumentOfCall(c, node) {
     // `x instanceof C` calls `C[Symbol.hasInstance](x)`.
-    if (node.kind === 227 /* SyntaxKind.BinaryExpression */)
+    if (node.kind === 228 /* SyntaxKind.BinaryExpression */)
         return node.right;
     let expression = undefined;
-    if (node.kind === 214 /* SyntaxKind.CallExpression */)
+    if (node.kind === 215 /* SyntaxKind.CallExpression */)
         expression = node.expression;
-    else if (node.kind === 216 /* SyntaxKind.TaggedTemplateExpression */)
+    else if (node.kind === 217 /* SyntaxKind.TaggedTemplateExpression */)
         expression = node.tag;
-    else if (node.kind === 171 /* SyntaxKind.Decorator */ && !c.legacyDecorators)
+    else if (node.kind === 172 /* SyntaxKind.Decorator */ && !c.legacyDecorators)
         expression = node.expression;
     if (expression === undefined)
         return undefined;
@@ -979,13 +1003,13 @@ function getThisArgumentOfCall(c, node) {
 function skipOuterExpressionsForCall(node) {
     for (;;) {
         switch (node.kind) {
-            case 218 /* SyntaxKind.ParenthesizedExpression */:
-            case 235 /* SyntaxKind.AsExpression */:
-            case 217 /* SyntaxKind.TypeAssertionExpression */:
-            case 239 /* SyntaxKind.SatisfiesExpression */:
-            case 236 /* SyntaxKind.NonNullExpression */:
-            case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
-            case 348 /* SyntaxKind.PartiallyEmittedExpression */:
+            case 219 /* SyntaxKind.ParenthesizedExpression */:
+            case 236 /* SyntaxKind.AsExpression */:
+            case 218 /* SyntaxKind.TypeAssertionExpression */:
+            case 240 /* SyntaxKind.SatisfiesExpression */:
+            case 237 /* SyntaxKind.NonNullExpression */:
+            case 235 /* SyntaxKind.ExpressionWithTypeArguments */:
+            case 349 /* SyntaxKind.PartiallyEmittedExpression */:
                 node = getExpression(node);
                 continue;
         }
@@ -1014,7 +1038,7 @@ function inferTypeArguments(c, node, signature, args, checkMode, context) {
         }
     }
     // Decorators have no contextual type.
-    const contextualType = node.kind === 171 /* SyntaxKind.Decorator */
+    const contextualType = node.kind === 172 /* SyntaxKind.Decorator */
         ? undefined
         : getContextualTypeEx(c, node, skipBindingPatterns ? 8 /* ContextFlags.SkipBindingPatterns */ : 0 /* ContextFlags.None */);
     if (contextualType !== undefined) {
@@ -1034,14 +1058,14 @@ function inferTypeArguments(c, node, signature, args, checkMode, context) {
                     ? getOrCreateTypeFromSignature(c, getSignatureInstantiationWithoutFillingInTypeArguments(c, contextualSignature, contextualSignature.typeParameters))
                     : instantiatedType;
                 // Return type inferences have the lowest priority.
-                inferTypes(c, context.inferences, inferenceSourceType, inferenceTargetType, 128 /* InferencePriority.ReturnType */, false);
+                inferTypesFromUnstarted(c, signature, context.inferences, inferenceSourceType, inferenceTargetType, 128 /* InferencePriority.ReturnType */);
             }
             // A separate pass for the mapper used to instantiate generic contextual types, from the outer
             // return mapper so that inferences can't reference the type parameters being inferred.
             const returnContext = createInferenceContext(c, signature.typeParameters, signature, context.flags, undefined);
             const outerReturnMapper = outerContext !== undefined ? createOuterReturnMapper(c, outerContext) : undefined;
             const returnSourceType = instantiateType(c, contextualType, outerReturnMapper);
-            inferTypes(c, returnContext.inferences, returnSourceType, inferenceTargetType, 0 /* InferencePriority.None */, false);
+            inferTypesFromUnstarted(c, signature, returnContext.inferences, returnSourceType, inferenceTargetType, 0 /* InferencePriority.None */);
             context.returnMapper = someInferenceHasCandidates(returnContext.inferences)
                 ? getMapperFromContext(cloneInferredPartOfContext(c, returnContext))
                 : undefined;
@@ -1061,7 +1085,7 @@ function inferTypeArguments(c, node, signature, args, checkMode, context) {
         inferTypes(c, context.inferences, getThisArgumentType(c, getThisArgumentOfCall(c, node)), thisType, 0 /* InferencePriority.None */, false);
     for (let i = 0; i < argCount; i++) {
         const arg = args[i];
-        if (arg.kind === 233 /* SyntaxKind.OmittedExpression */)
+        if (arg.kind === 234 /* SyntaxKind.OmittedExpression */)
             continue;
         const paramType = getTypeAtPosition(c, signature, i);
         if (couldContainTypeVariables(c, paramType)) {
@@ -1218,13 +1242,13 @@ function reportCallResolutionErrors(c, s, signatures, headMessage) {
         isSignatureApplicable(c, s.node, s.args, last, c.assignableRelation, 0 /* CheckMode.Normal */, true, diagnostics);
         for (let diagnostic of diagnostics) {
             if (s.candidatesForArgumentError.length > 1) {
-                diagnostic = chainDiagnostic(diagnostic, 902 /* Diagnostics.The_last_overload_gave_the_following_error */);
-                diagnostic = chainDiagnostic(diagnostic, 901 /* Diagnostics.No_overload_matches_this_call */);
+                diagnostic = chainDiagnostic(diagnostic, 909 /* Diagnostics.The_last_overload_gave_the_following_error */);
+                diagnostic = chainDiagnostic(diagnostic, 908 /* Diagnostics.No_overload_matches_this_call */);
             }
             if (headMessage !== undefined)
                 diagnostic = chainDiagnostic(diagnostic, headMessage);
             if (last.declaration !== undefined && s.candidatesForArgumentError.length > 1)
-                diagnostic.addRelatedInfo(createDiagnosticForNode(last.declaration, 903 /* Diagnostics.The_last_overload_is_declared_here */, []));
+                diagnostic.addRelatedInfo(createDiagnosticForNode(last.declaration, 910 /* Diagnostics.The_last_overload_is_declared_here */, []));
             addImplementationSuccessElaboration(c, s, last, diagnostic);
             c.addDiagnostic(diagnostic);
         }
@@ -1233,7 +1257,7 @@ function reportCallResolutionErrors(c, s, signatures, headMessage) {
         c.addDiagnostic(getArgumentArityError(c, s.node, [s.candidateForArgumentArityError], s.args, headMessage));
     else if (s.candidateForTypeArgumentError !== undefined)
         checkTypeArguments(c, s.candidateForTypeArgumentError, getCallTypeArguments(s.node), true, headMessage);
-    else if (s.node.kind !== 290 /* SyntaxKind.JsxOpeningFragment */) {
+    else if (s.node.kind !== 291 /* SyntaxKind.JsxOpeningFragment */) {
         const withCorrectTypeArgumentArity = [];
         for (const sig of signatures)
             if (hasCorrectTypeArgumentArity(c, sig, s.typeArguments))
@@ -1266,15 +1290,35 @@ function addImplementationSuccessElaboration(c, s, failed, diagnostic) {
     localState.candidateForArgumentArityError = s.candidateForArgumentArityError;
     localState.candidateForTypeArgumentError = s.candidateForTypeArgumentError;
     if (chooseOverload(c, localState, c.assignableRelation) !== undefined)
-        diagnostic.addRelatedInfo(createDiagnosticForNode(implementation, 925 /* Diagnostics.The_call_would_have_succeeded_against_this_implementation_but_implementation_signatures_of_overloads_are_not_externally_visible */, []));
+        diagnostic.addRelatedInfo(createDiagnosticForNode(implementation, 932 /* Diagnostics.The_call_would_have_succeeded_against_this_implementation_but_implementation_signatures_of_overloads_are_not_externally_visible */, []));
 }
 function withHeadMessage(diagnostic, headMessage) {
     return headMessage !== undefined ? chainDiagnostic(diagnostic, headMessage) : diagnostic;
 }
+/** Whether `node` calls the `resolve` parameter of an executor passed to the global `new Promise`. */
+function isPromiseResolveArityError(c, node) {
+    if (node.kind !== 215 /* SyntaxKind.CallExpression */)
+        return false;
+    const callee = getExpression(node);
+    if (callee.kind !== 79 /* SyntaxKind.Identifier */)
+        return false;
+    const symbol = resolveName(c, callee, getText(callee), 111551 /* SymbolFlags.Value */, undefined, false, false);
+    const declaration = symbol?.valueDeclaration;
+    if (declaration === undefined ||
+        declaration.kind !== 171 /* SyntaxKind.Parameter */ ||
+        !isFunctionExpressionOrArrowFunction(declaration.parent) ||
+        declaration.parent.parent?.kind !== 216 /* SyntaxKind.NewExpression */)
+        return false;
+    const constructor = getExpression(declaration.parent.parent);
+    if (constructor === undefined || constructor.kind !== 79 /* SyntaxKind.Identifier */)
+        return false;
+    const globalPromiseSymbol = getGlobalValueSymbol(c, 'Promise', false);
+    return globalPromiseSymbol !== undefined && getResolvedSymbol(c, constructor) === globalPromiseSymbol;
+}
 function getArgumentArityError(c, node, signatures, args, headMessage) {
     const spreadIndex = getSpreadArgumentIndex(args);
     if (spreadIndex > -1)
-        return createDiagnosticForNode(args[spreadIndex], 711 /* Diagnostics.A_spread_argument_must_either_have_a_tuple_type_or_be_passed_to_a_rest_parameter */, []);
+        return createDiagnosticForNode(args[spreadIndex], 718 /* Diagnostics.A_spread_argument_must_either_have_a_tuple_type_or_be_passed_to_a_rest_parameter */, []);
     let minCount = Number.MAX_SAFE_INTEGER;
     let maxCount = Number.MIN_SAFE_INTEGER;
     let maxBelow = Number.MIN_SAFE_INTEGER;
@@ -1305,17 +1349,23 @@ function getArgumentArityError(c, node, signatures, args, headMessage) {
         : minCount < maxCount
             ? minCount + '-' + maxCount
             : String(minCount);
+    // `resolve()` without an argument, where `resolve` is the parameter of a `new Promise` executor.
+    const isVoidPromiseError = !hasRestParameter && parameterRange === '1' && args.length === 0 && isPromiseResolveArityError(c, node);
     const errorNode = getErrorNodeForCallNode(node);
-    const message = node.kind === 171 /* SyntaxKind.Decorator */
+    if (isVoidPromiseError && isInJSFile(node))
+        return createDiagnosticForNode(errorNode, 948 /* Diagnostics.Expected_1_argument_but_got_0_new_Promise_needs_a_JSDoc_hint_to_produce_a_resolve_that_can_be_called_without_arguments */, []);
+    const message = node.kind === 172 /* SyntaxKind.Decorator */
         ? hasRestParameter
             ? 228 /* Diagnostics.The_runtime_will_invoke_the_decorator_with_1_arguments_but_the_decorator_expects_at_least_0 */
             : 227 /* Diagnostics.The_runtime_will_invoke_the_decorator_with_1_arguments_but_the_decorator_expects_0 */
         : hasRestParameter
-            ? 710 /* Diagnostics.Expected_at_least_0_arguments_but_got_1 */
-            : 709 /* Diagnostics.Expected_0_arguments_but_got_1 */;
+            ? 717 /* Diagnostics.Expected_at_least_0_arguments_but_got_1 */
+            : isVoidPromiseError
+                ? 933 /* Diagnostics.Expected_0_arguments_but_got_1_Did_you_forget_to_include_void_in_your_type_argument_to_Promise */
+                : 716 /* Diagnostics.Expected_0_arguments_but_got_1 */;
     if (minCount < args.length && args.length < maxCount)
         // Between min and max, but no overload matches.
-        return withHeadMessage(createDiagnosticForNode(errorNode, 726 /* Diagnostics.No_overload_expects_0_arguments_but_overloads_do_exist_that_expect_either_1_or_2_arguments */, [String(args.length), String(maxBelow), String(minAbove)]), headMessage);
+        return withHeadMessage(createDiagnosticForNode(errorNode, 733 /* Diagnostics.No_overload_expects_0_arguments_but_overloads_do_exist_that_expect_either_1_or_2_arguments */, [String(args.length), String(maxBelow), String(minAbove)]), headMessage);
     if (args.length < minCount) {
         // Too short: the error spans the callee.
         const diagnostic = withHeadMessage(createDiagnosticForNode(errorNode, message, [parameterRange, String(args.length)]), headMessage);
@@ -1325,14 +1375,14 @@ function getArgumentArityError(c, node, signatures, args, headMessage) {
         const parameter = params !== undefined && index < params.nodes.length ? params.nodes[index] : undefined;
         if (parameter !== undefined) {
             const name = getName(parameter);
-            if (name.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 208 /* SyntaxKind.ArrayBindingPattern */)
-                diagnostic.addRelatedInfo(createDiagnosticForNode(parameter, 1364 /* Diagnostics.An_argument_matching_this_binding_pattern_was_not_provided */, []));
+            if (name.kind === 208 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 209 /* SyntaxKind.ArrayBindingPattern */)
+                diagnostic.addRelatedInfo(createDiagnosticForNode(parameter, 1375 /* Diagnostics.An_argument_matching_this_binding_pattern_was_not_provided */, []));
             else if (parameter.dotDotDotToken !== undefined)
-                diagnostic.addRelatedInfo(createDiagnosticForNode(parameter, 1388 /* Diagnostics.Arguments_for_the_rest_parameter_0_were_not_provided */, [
+                diagnostic.addRelatedInfo(createDiagnosticForNode(parameter, 1399 /* Diagnostics.Arguments_for_the_rest_parameter_0_were_not_provided */, [
                     getTextOfName(name),
                 ]));
             else
-                diagnostic.addRelatedInfo(createDiagnosticForNode(parameter, 1363 /* Diagnostics.An_argument_for_0_was_not_provided */, [getTextOfName(name)]));
+                diagnostic.addRelatedInfo(createDiagnosticForNode(parameter, 1374 /* Diagnostics.An_argument_for_0_was_not_provided */, [getTextOfName(name)]));
         }
         return diagnostic;
     }
@@ -1362,7 +1412,7 @@ function getTypeArgumentArityError(c, node, signatures, typeArguments, headMessa
         const minCount = getMinTypeArgumentCount(c, sig.typeParameters);
         const maxCount = sig.typeParameters.length;
         const expected = minCount < maxCount ? minCount + '-' + maxCount : String(minCount);
-        diagnostic = new Diagnostic(file.diagnosticFile(), pos, end, 712 /* Diagnostics.Expected_0_type_arguments_but_got_1 */, [
+        diagnostic = new Diagnostic(file.diagnosticFile(), pos, end, 719 /* Diagnostics.Expected_0_type_arguments_but_got_1 */, [
             expected,
             String(argCount),
         ]);
@@ -1380,8 +1430,8 @@ function getTypeArgumentArityError(c, node, signatures, typeArguments, headMessa
         }
         diagnostic =
             belowArgCount !== Number.MIN_SAFE_INTEGER && aboveArgCount !== Number.MAX_SAFE_INTEGER
-                ? new Diagnostic(file.diagnosticFile(), pos, end, 875 /* Diagnostics.No_overload_expects_0_type_arguments_but_overloads_do_exist_that_expect_either_1_or_2_type_arguments */, [String(argCount), String(belowArgCount), String(aboveArgCount)])
-                : new Diagnostic(file.diagnosticFile(), pos, end, 712 /* Diagnostics.Expected_0_type_arguments_but_got_1 */, [
+                ? new Diagnostic(file.diagnosticFile(), pos, end, 882 /* Diagnostics.No_overload_expects_0_type_arguments_but_overloads_do_exist_that_expect_either_1_or_2_type_arguments */, [String(argCount), String(belowArgCount), String(aboveArgCount)])
+                : new Diagnostic(file.diagnosticFile(), pos, end, 719 /* Diagnostics.Expected_0_type_arguments_but_got_1 */, [
                     String(belowArgCount === Number.MIN_SAFE_INTEGER ? aboveArgCount : belowArgCount),
                     String(argCount),
                 ]);
@@ -1392,9 +1442,9 @@ function getTextOfName(name) {
     return name.kind === 79 /* SyntaxKind.Identifier */ ? getText(name) : '';
 }
 function getErrorNodeForCallNode(node) {
-    if (node.kind === 214 /* SyntaxKind.CallExpression */) {
+    if (node.kind === 215 /* SyntaxKind.CallExpression */) {
         const callee = node.expression;
-        if (callee.kind === 212 /* SyntaxKind.PropertyAccessExpression */)
+        if (callee.kind === 213 /* SyntaxKind.PropertyAccessExpression */)
             return getName(callee);
         return callee;
     }
@@ -1516,14 +1566,14 @@ export function checkExpressionWithTypeArguments(c, node) {
         for (const a of typeArguments.nodes)
             checkSourceElement(c, a);
     let exprType;
-    if (node.kind === 234 /* SyntaxKind.ExpressionWithTypeArguments */) {
+    if (node.kind === 235 /* SyntaxKind.ExpressionWithTypeArguments */) {
         let parent = node.parent;
-        while (parent.kind === 218 /* SyntaxKind.ParenthesizedExpression */)
+        while (parent.kind === 219 /* SyntaxKind.ParenthesizedExpression */)
             parent = parent.parent;
-        if (parent.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+        if (parent.kind === 228 /* SyntaxKind.BinaryExpression */ &&
             parent.operatorToken.kind === 103 /* SyntaxKind.InstanceOfKeyword */ &&
             isNodeDescendantOf(node, parent.right))
-            c.error(node, 968 /* Diagnostics.The_right_hand_side_of_an_instanceof_expression_must_not_be_an_instantiation_expression */);
+            c.error(node, 975 /* Diagnostics.The_right_hand_side_of_an_instanceof_expression_must_not_be_an_instantiation_expression */);
         exprType = checkExpression(c, getExpression(node));
     }
     else
@@ -1545,7 +1595,7 @@ export function getInstantiationExpressionType(c, exprType, node) {
     const errorType = instantiator.hasSomeApplicableSignature ? instantiator.nonApplicableType : exprType;
     if (errorType !== undefined) {
         const file = getSourceFileOfNode(node);
-        c.addDiagnostic(new Diagnostic(file.diagnosticFile(), skipTrivia(file.text, typeArgumentList.pos), typeArgumentList.end, 778 /* Diagnostics.Type_0_has_no_signatures_for_which_the_type_argument_list_is_applicable */, [typeToString(c, errorType)]));
+        c.addDiagnostic(new Diagnostic(file.diagnosticFile(), skipTrivia(file.text, typeArgumentList.pos), typeArgumentList.end, 785 /* Diagnostics.Type_0_has_no_signatures_for_which_the_type_argument_list_is_applicable */, [typeToString(c, errorType)]));
     }
     return result;
 }
@@ -1588,7 +1638,11 @@ class InstantiationExpressionInstantiator {
             if (callSignatures.length !== 0 || constructSignatures.length !== 0)
                 this.hasApplicableSignature = true;
             if (callSignatures !== resolved.callSignatures || constructSignatures !== resolved.constructSignatures) {
-                const result = newObjectType(c, 16 /* ObjectFlags.Anonymous */ | 16777216 /* ObjectFlags.InstantiationExpressionType */, c.newSymbol(0 /* SymbolFlags.None */, "\uFFFEinstantiationExpression" /* InternalSymbolName.InstantiationExpression */));
+                // A symbol of its own, with the declarations of the instantiated type's symbol.
+                const symbol = c.newSymbol(0 /* SymbolFlags.None */, "\uFFFEinstantiationExpression" /* InternalSymbolName.InstantiationExpression */);
+                if (t.symbol !== undefined)
+                    copyDeclarations(symbol, t.symbol);
+                const result = newObjectType(c, 16 /* ObjectFlags.Anonymous */ | 16777216 /* ObjectFlags.InstantiationExpressionType */, symbol);
                 setStructuredTypeMembers(c, result, resolved.members, callSignatures, constructSignatures, resolved.indexInfos);
                 result.node = this.node;
                 return result;