tsc-ts 0.0.10 → 0.1.0

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

@@ -10,7 +10,7 @@ import { isPartOfTypeNode } from './transformers/alias-references.js';
 import { createDiagnosticForNode } from './checker.js';
 import { TypePredicate } from './checker-types.js';
 import { filterType, getIntersectionType, getRegularTypeOfLiteralType, getUnionTypeEx, isErrorType, isUnitType, someType, } from './checker-type-factory.js';
-import { getTypeOfSymbol, getWidenedType, isPrivateWithinAmbient, reportErrorsFromWidening, reportImplicitAny, } from './checker-symbol-types.js';
+import { getTypeOfSymbol, getWidenedType, isPrivateWithinAmbient, reportErrorsFromWidening, reportImplicitAny, getWidenedTypeForVariableLikeDeclaration, } from './checker-symbol-types.js';
 import { getMergedSymbol, getSymbolOfDeclaration } from './checker-symbols.js';
 import { getReturnTypeFromAnnotation, getReturnTypeOfSignature, getSignatureFromDeclaration, } from './checker-signatures.js';
 import { checkExpression, checkExpressionCached, getWidenedLiteralLikeTypeForContextualType, isConstContext, } from './checker-expressions.js';
@@ -31,7 +31,7 @@ import { isTypeAssignableTo } from './relations.js';
 import { inferTypes } from './checker-inference.js';
 import { couldContainTypeVariables, instantiateSignature } from './instantiation.js';
 import { getContextualSignatureForFunctionLikeDeclaration, getInferenceContext, instantiateContextualType, } from './checker-contextual.js';
-import { checkJSDocFullSignature, checkUnmatchedJSDocParameters, getFullSignatureTypeNode } from './checker-jsdoc.js';
+import { checkJSDocFullSignature, checkJSDocFullSignatureType, checkUnmatchedJSDocParameters, getFullSignatureTypeNode, } from './checker-jsdoc.js';
 import { getEffectiveCheckNode, isFunctionLike, nodeIsMissing } from './ast-utilities.js';
 import { getFlowTypeOfReferenceAt, isConstantReference, isReachableFlowNode, isSymbolAssigned, } from './checker-narrowing.js';
 import { FlowNode } from './flow.js';
@@ -40,9 +40,10 @@ import { typeToString } from './type-printer.js';
 import { checkGrammarAwaitExpression, checkGrammarFunctionExpression, checkGrammarYieldOfExpression, } from './checker-grammar.js';
 export function checkFunctionExpressionOrObjectLiteralMethod(c, node, checkMode) {
     checkNodeDeferred(c, node);
-    if (node.kind === 219 /* SyntaxKind.FunctionExpression */)
+    checkJSDocFullSignatureType(c, node);
+    if (node.kind === 220 /* SyntaxKind.FunctionExpression */)
         checkCollisionsForDeclarationName(c, node, getName(node));
-    if (node.kind === 178 /* SyntaxKind.GetAccessor */ || node.kind === 179 /* SyntaxKind.SetAccessor */)
+    if (node.kind === 179 /* SyntaxKind.GetAccessor */ || node.kind === 180 /* SyntaxKind.SetAccessor */)
         return c.anyType;
     if ((checkMode & 4 /* CheckMode.SkipContextSensitive */) !== 0 && isContextSensitive(c, node)) {
         // Skip parameters, but keep a return type with the non-contextual parts so that inferences can
@@ -64,7 +65,7 @@ export function checkFunctionExpressionOrObjectLiteralMethod(c, node, checkMode)
         }
         return c.anyFunctionType;
     }
-    if (node.kind === 219 /* SyntaxKind.FunctionExpression */ || node.kind === 220 /* SyntaxKind.ArrowFunction */)
+    if (node.kind === 220 /* SyntaxKind.FunctionExpression */ || node.kind === 221 /* SyntaxKind.ArrowFunction */)
         checkGrammarFunctionExpression(c, node);
     checkJSDocFullSignature(c, node);
     contextuallyCheckFunctionExpressionOrObjectLiteralMethod(c, node, checkMode);
@@ -118,7 +119,8 @@ function contextuallyCheckFunctionExpressionOrObjectLiteralMethod(c, node, check
     if (contextualSignature !== undefined &&
         getType(node) === undefined &&
         resolvedReturnTypeOf(c, signature) === undefined) {
-        const returnType = getReturnTypeFromBodyEx(c, node, checkMode);
+        // The resolved return type is cached, so it is computed without SkipContextSensitive to keep anyFunctionType out of it.
+        const returnType = getReturnTypeFromBodyEx(c, node, checkMode & ~4 /* CheckMode.SkipContextSensitive */);
         if (resolvedReturnTypeOf(c, signature) === undefined)
             signatureSideOf(c, signature).resolvedReturnType = returnType;
     }
@@ -190,7 +192,9 @@ function assignParameterSymbolType(c, parameter, contextualType) {
         return;
     const declaration = parameter.valueDeclaration;
     if (contextualType === undefined) {
-        c.symbolTypes.set(id, getTypeOfSymbol(c, parameter));
+        c.symbolTypes.set(id, declaration !== undefined
+            ? getWidenedTypeForVariableLikeDeclaration(c, declaration, true)
+            : getTypeOfSymbol(c, parameter));
         return;
     }
     c.symbolTypes.set(id, addOptionality(c, contextualType, false, declaration !== undefined && getInitializer(declaration) === undefined && isOptionalDeclaration(declaration)));
@@ -200,10 +204,10 @@ function assignParameterSymbolType(c, parameter, contextualType) {
     // Without a better inference than `unknown`, a binding pattern implies the type.
     if (c.symbolTypes.get(id) === c.unknownType &&
         name !== undefined &&
-        (name.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 208 /* SyntaxKind.ArrayBindingPattern */))
+        (name.kind === 208 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 209 /* SyntaxKind.ArrayBindingPattern */))
         c.symbolTypes.set(id, getTypeFromBindingPattern(c, name, false, false));
     if (name !== undefined &&
-        (name.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 208 /* SyntaxKind.ArrayBindingPattern */))
+        (name.kind === 208 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 209 /* SyntaxKind.ArrayBindingPattern */))
         assignBindingElementTypes(c, name, c.symbolTypes.get(id));
 }
 export function getTypeOfObjectLiteralMethod(c, node, checkMode) {
@@ -245,23 +249,23 @@ export function checkFunctionLikeBody(c, node) {
     // Function and class method declarations without a body or return type return `any`.
     if (returnTypeNode === undefined &&
         nodeIsMissing(body) &&
-        (node.kind === 263 /* SyntaxKind.FunctionDeclaration */ ||
-            (node.kind === 175 /* SyntaxKind.MethodDeclaration */ && node.parent.kind !== 211 /* SyntaxKind.ObjectLiteralExpression */)) &&
+        (node.kind === 264 /* SyntaxKind.FunctionDeclaration */ ||
+            (node.kind === 176 /* SyntaxKind.MethodDeclaration */ && node.parent.kind !== 212 /* SyntaxKind.ObjectLiteralExpression */)) &&
         !isPrivateWithinAmbient(node))
         reportImplicitAny(c, node, c.anyType);
     if (body === undefined)
         return;
-    const returnType = node.kind !== 177 /* SyntaxKind.Constructor */ ? getReturnTypeFromAnnotation(c, node) : undefined;
+    const returnType = node.kind !== 178 /* SyntaxKind.Constructor */ ? getReturnTypeFromAnnotation(c, node) : undefined;
     // Errors only found while inferring the return type (such as of yielded values) need it resolved.
     if (returnTypeNode === undefined &&
         (isFunctionExpressionOrArrowFunction(node) ||
             isObjectLiteralMethod(node) ||
-            ((functionFlags & 1 /* FunctionFlags.Generator */) !== 0 && node.kind !== 177 /* SyntaxKind.Constructor */)))
+            ((functionFlags & 1 /* FunctionFlags.Generator */) !== 0 && node.kind !== 178 /* SyntaxKind.Constructor */)))
         getReturnTypeOfSignature(c, getSignatureFromDeclaration(c, node));
-    if (body.kind === 242 /* SyntaxKind.Block */) {
+    if (body.kind === 243 /* SyntaxKind.Block */) {
         for (const s of getStatements(body).nodes)
             checkSourceElement(c, s);
-        if (node.kind !== 177 /* SyntaxKind.Constructor */ && node.kind !== 179 /* SyntaxKind.SetAccessor */)
+        if (node.kind !== 178 /* SyntaxKind.Constructor */ && node.kind !== 180 /* SyntaxKind.SetAccessor */)
             checkAllCodePathsInNonVoidFunctionReturnOrThrow(c, node, returnType);
     }
     else {
@@ -276,7 +280,7 @@ function checkSignatureReturnType(c, node, returnTypeNode, functionFlags) {
     if ((functionFlags & (4 /* FunctionFlags.Invalid */ | 1 /* FunctionFlags.Generator */)) === 1 /* FunctionFlags.Generator */) {
         const returnType = getTypeFromTypeNode(c, returnTypeNode);
         if (returnType === c.voidType)
-            c.error(returnTypeNode, 665 /* Diagnostics.A_generator_cannot_have_a_void_type_annotation */);
+            c.error(returnTypeNode, 672 /* Diagnostics.A_generator_cannot_have_a_void_type_annotation */);
         else
             checkGeneratorInstantiationAssignabilityToReturnType(c, returnType, functionFlags, returnTypeNode);
     }
@@ -304,20 +308,20 @@ function checkAllCodePathsInNonVoidFunctionReturnOrThrow(c, func, returnType) {
         return;
     // Signatures, expression bodies and bodies that end in a return or throw have nothing to check.
     const body = getBody(func);
-    if (func.kind === 174 /* SyntaxKind.MethodSignature */ ||
+    if (func.kind === 175 /* SyntaxKind.MethodSignature */ ||
         body === undefined ||
         nodeIsMissing(body) ||
-        body.kind !== 242 /* SyntaxKind.Block */ ||
+        body.kind !== 243 /* SyntaxKind.Block */ ||
         !functionHasImplicitReturn(c, func))
         return;
     const hasExplicitReturn = (func.flags & 512 /* NodeFlags.HasExplicitReturn */) !== 0;
     const errorNode = getType(func) ?? getFullSignatureTypeNode(func) ?? func;
     if (t !== undefined && (t.flags & 262144 /* TypeFlags.Never */) !== 0)
-        c.error(errorNode, 692 /* Diagnostics.A_function_returning_never_cannot_have_a_reachable_end_point */);
+        c.error(errorNode, 699 /* Diagnostics.A_function_returning_never_cannot_have_a_reachable_end_point */);
     else if (t !== undefined && !hasExplicitReturn)
-        c.error(errorNode, 531 /* Diagnostics.A_function_whose_declared_type_is_neither_undefined_void_nor_any_must_return_a_value */);
+        c.error(errorNode, 538 /* Diagnostics.A_function_whose_declared_type_is_neither_undefined_void_nor_any_must_return_a_value */);
     else if (t !== undefined && c.strictNullChecks && !isTypeAssignableTo(c, c.undefinedType, t))
-        c.error(errorNode, 540 /* Diagnostics.Function_lacks_ending_return_statement_and_return_type_does_not_include_undefined */);
+        c.error(errorNode, 547 /* Diagnostics.Function_lacks_ending_return_statement_and_return_type_does_not_include_undefined */);
     else if (c.compilerOptions.noImplicitReturns === true) {
         if (t === undefined) {
             // Without an annotation, only functions that return values other than void or any are checked.
@@ -327,7 +331,7 @@ function checkAllCodePathsInNonVoidFunctionReturnOrThrow(c, func, returnType) {
             if (isUnwrappedReturnTypeUndefinedVoidOrAny(c, func, inferredReturnType))
                 return;
         }
-        c.error(errorNode, 1701 /* Diagnostics.Not_all_code_paths_return_a_value */);
+        c.error(errorNode, 1720 /* Diagnostics.Not_all_code_paths_return_a_value */);
     }
 }
 export function isUnwrappedReturnTypeUndefinedVoidOrAny(c, func, returnType) {
@@ -346,7 +350,7 @@ export function checkReturnExpression(c, container, unwrappedReturnType, node, e
     const functionFlags = getFunctionFlags(container);
     if (expr !== undefined) {
         const unwrappedExpr = skipParentheses(expr);
-        if (unwrappedExpr.kind === 228 /* SyntaxKind.ConditionalExpression */) {
+        if (unwrappedExpr.kind === 229 /* SyntaxKind.ConditionalExpression */) {
             const conditional = unwrappedExpr;
             const whenTrue = conditional.whenTrue;
             const whenFalse = conditional.whenFalse;
@@ -355,7 +359,7 @@ export function checkReturnExpression(c, container, unwrappedReturnType, node, e
             return;
         }
     }
-    const inReturnStatement = node.kind === 254 /* SyntaxKind.ReturnStatement */;
+    const inReturnStatement = node.kind === 255 /* SyntaxKind.ReturnStatement */;
     const unwrappedExprType = (functionFlags & 2 /* FunctionFlags.Async */) !== 0
         ? checkAwaitedType(c, exprType, false, node, 43 /* Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member */)
         : exprType;
@@ -369,13 +373,16 @@ export function checkAwaitExpression(c, node) {
     const operandType = checkExpression(c, getExpression(node));
     const awaitedType = checkAwaitedType(c, operandType, true, node, 256 /* Diagnostics.Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member */);
     if (awaitedType === operandType && !isErrorType(c, awaitedType) && (operandType.flags & 3 /* TypeFlags.AnyOrUnknown */) === 0)
-        c.addSuggestion(createDiagnosticForNode(node, 1884 /* Diagnostics.X_await_has_no_effect_on_the_type_of_this_expression */, []));
+        c.addSuggestion(createDiagnosticForNode(node, 1966 /* Diagnostics.X_await_has_no_effect_on_the_type_of_this_expression */, []));
     return awaitedType;
 }
 // ---- Generators
 export function checkYieldExpression(c, node) {
     checkGrammarYieldOfExpression(c, node);
     const yieldExpr = node;
+    // The operand is checked also outside a generator.
+    const operand = yieldExpr.expression;
+    const yieldExpressionType = operand !== undefined ? checkExpression(c, operand) : c.undefinedWideningType;
     const func = getContainingFunctionLike(node);
     if (func === undefined)
         return c.anyType;
@@ -394,8 +401,6 @@ export function checkYieldExpression(c, node) {
     const iterationTypes = returnType !== undefined ? getIterationTypesOfGeneratorFunctionReturnType(c, returnType, isAsync) : undefined;
     const signatureYieldType = iterationTypes?.yieldType ?? c.anyType;
     const signatureNextType = iterationTypes?.nextType ?? c.anyType;
-    const operand = yieldExpr.expression;
-    const yieldExpressionType = operand !== undefined ? checkExpression(c, operand) : c.undefinedWideningType;
     const yieldedType = getYieldedTypeOfYieldExpression(c, yieldExpr, yieldExpressionType, signatureNextType, isAsync);
     if (returnType !== undefined && yieldedType !== undefined)
         checkTypeAssignableToAndOptionallyElaborate(c, yieldedType, signatureYieldType, operand ?? node, operand);
@@ -409,7 +414,7 @@ export function checkYieldExpression(c, node) {
     if (c.noImplicitAny && !expressionResultIsUnused(node)) {
         const contextualType = getContextualType(c, node);
         if (contextualType === undefined || (contextualType.flags & 1 /* TypeFlags.Any */) !== 0)
-            c.error(node, 1728 /* Diagnostics.X_yield_expression_implicitly_results_in_an_any_type_because_its_containing_generator_lacks_a_return_type_annotation */);
+            c.error(node, 1747 /* Diagnostics.X_yield_expression_implicitly_results_in_an_any_type_because_its_containing_generator_lacks_a_return_type_annotation */);
     }
     return c.anyType;
 }
@@ -433,16 +438,16 @@ function expressionResultIsUnused(nodeIn) {
     let node = nodeIn;
     for (;;) {
         const parent = node.parent;
-        if (parent.kind === 218 /* SyntaxKind.ParenthesizedExpression */) {
+        if (parent.kind === 219 /* SyntaxKind.ParenthesizedExpression */) {
             node = parent;
             continue;
         }
-        if (parent.kind === 245 /* SyntaxKind.ExpressionStatement */ ||
-            parent.kind === 223 /* SyntaxKind.VoidExpression */ ||
-            (parent.kind === 249 /* SyntaxKind.ForStatement */ &&
+        if (parent.kind === 246 /* SyntaxKind.ExpressionStatement */ ||
+            parent.kind === 224 /* SyntaxKind.VoidExpression */ ||
+            (parent.kind === 250 /* SyntaxKind.ForStatement */ &&
                 (parent.initializer === node || parent.incrementor === node)))
             return true;
-        if (parent.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+        if (parent.kind === 228 /* SyntaxKind.BinaryExpression */ &&
             parent.operatorToken.kind === 27 /* SyntaxKind.CommaToken */) {
             // The left side of a comma is unused; the right side is when the comma is.
             if (node === parent.left)
@@ -463,43 +468,43 @@ function getContainingFunctionLike(node) {
 /** Whether checking `node` depends on its contextual type. */
 export function isContextSensitive(c, node) {
     switch (node.kind) {
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 220 /* SyntaxKind.ArrowFunction */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 263 /* SyntaxKind.FunctionDeclaration */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 221 /* SyntaxKind.ArrowFunction */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
             return isContextSensitiveFunctionLikeDeclaration(c, node);
-        case 211 /* SyntaxKind.ObjectLiteralExpression */:
+        case 212 /* SyntaxKind.ObjectLiteralExpression */:
             for (const p of getProperties(node).nodes)
                 if (isContextSensitive(c, p))
                     return true;
             return false;
-        case 210 /* SyntaxKind.ArrayLiteralExpression */:
+        case 211 /* SyntaxKind.ArrayLiteralExpression */:
             for (const e of getElements(node).nodes)
                 if (isContextSensitive(c, e))
                     return true;
             return false;
-        case 228 /* SyntaxKind.ConditionalExpression */: {
+        case 229 /* SyntaxKind.ConditionalExpression */: {
             const cond = node;
             return isContextSensitive(c, cond.whenTrue) || isContextSensitive(c, cond.whenFalse);
         }
-        case 227 /* SyntaxKind.BinaryExpression */: {
+        case 228 /* SyntaxKind.BinaryExpression */: {
             const binary = node;
             const op = binary.operatorToken.kind;
             return ((op === 56 /* SyntaxKind.BarBarToken */ || op === 60 /* SyntaxKind.QuestionQuestionToken */) &&
                 (isContextSensitive(c, binary.left) || isContextSensitive(c, binary.right)));
         }
-        case 303 /* SyntaxKind.PropertyAssignment */:
+        case 304 /* SyntaxKind.PropertyAssignment */:
             return isContextSensitive(c, getInitializer(node));
-        case 218 /* SyntaxKind.ParenthesizedExpression */:
+        case 219 /* SyntaxKind.ParenthesizedExpression */:
             return isContextSensitive(c, getExpression(node));
-        case 293 /* SyntaxKind.JsxAttributes */:
+        case 294 /* SyntaxKind.JsxAttributes */:
             return isJsxAttributesContextSensitive(c, node);
-        case 292 /* SyntaxKind.JsxAttribute */: {
+        case 293 /* SyntaxKind.JsxAttribute */: {
             // Without an initializer an attribute is `true`.
             const initializer = getInitializer(node);
             return initializer !== undefined && isContextSensitive(c, initializer);
         }
-        case 295 /* SyntaxKind.JsxExpression */: {
+        case 296 /* SyntaxKind.JsxExpression */: {
             const expression = getExpression(node);
             return expression !== undefined && isContextSensitive(c, expression);
         }
@@ -518,16 +523,16 @@ function isContextSensitiveFunctionLikeDeclaration(c, node) {
  */
 export function getTypePredicateFromBody(c, fn) {
     switch (fn.kind) {
-        case 177 /* SyntaxKind.Constructor */:
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
+        case 178 /* SyntaxKind.Constructor */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
             return undefined;
     }
     if (getFunctionFlags(fn) !== 0 /* FunctionFlags.Normal */)
         return undefined;
     const body = getBody(fn);
     let singleReturn = undefined;
-    if (body !== undefined && body.kind !== 242 /* SyntaxKind.Block */)
+    if (body !== undefined && body.kind !== 243 /* SyntaxKind.Block */)
         singleReturn = body;
     else {
         if (body === undefined)
@@ -569,7 +574,7 @@ function checkIfExpressionRefinesAnyParameter(c, fn, exprIn) {
 }
 function checkIfExpressionRefinesParameter(c, fn, expr, name, initType) {
     let antecedent = getFlowNode(expr);
-    if (antecedent === undefined && expr.parent.kind === 254 /* SyntaxKind.ReturnStatement */)
+    if (antecedent === undefined && expr.parent.kind === 255 /* SyntaxKind.ReturnStatement */)
         antecedent = getFlowNode(expr.parent);
     if (antecedent === undefined)
         antecedent = new FlowNode(2 /* FlowFlags.Start */, undefined, undefined);
@@ -588,7 +593,7 @@ function hasContextSensitiveReturnExpression(c, node) {
     const body = getBody(node);
     if (body === undefined)
         return false;
-    if (body.kind !== 242 /* SyntaxKind.Block */)
+    if (body.kind !== 243 /* SyntaxKind.Block */)
         return isContextSensitive(c, body);
     const collector = new ReturnCollector();
     collector.visitStatements(body);
@@ -616,7 +621,7 @@ class YieldFinder extends NodeVisitor {
         this.c = c;
     }
     visitNode(node) {
-        if (node.kind === 230 /* SyntaxKind.YieldExpression */) {
+        if (node.kind === 231 /* SyntaxKind.YieldExpression */) {
             const expression = getExpression(node);
             if (expression !== undefined && isContextSensitive(this.c, expression)) {
                 this.found = true;
@@ -630,15 +635,15 @@ class YieldFinder extends NodeVisitor {
 }
 function isFunctionLikeOrClass(node) {
     switch (node.kind) {
-        case 263 /* SyntaxKind.FunctionDeclaration */:
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 220 /* SyntaxKind.ArrowFunction */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
-        case 177 /* SyntaxKind.Constructor */:
-        case 264 /* SyntaxKind.ClassDeclaration */:
-        case 232 /* SyntaxKind.ClassExpression */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 221 /* SyntaxKind.ArrowFunction */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
+        case 178 /* SyntaxKind.Constructor */:
+        case 265 /* SyntaxKind.ClassDeclaration */:
+        case 233 /* SyntaxKind.ClassExpression */:
             return true;
     }
     return false;
@@ -663,7 +668,7 @@ export function getReturnTypeFromBodyEx(c, func, checkMode) {
     let yieldType;
     let nextType;
     let fallbackReturnType = c.voidType;
-    if (body.kind !== 242 /* SyntaxKind.Block */) {
+    if (body.kind !== 243 /* SyntaxKind.Block */) {
         returnType = checkExpressionCachedEx(c, body, checkMode);
         if (isConstContext(c, body))
             returnType = getRegularTypeOfLiteralType(c, returnType);
@@ -793,7 +798,7 @@ function checkAndAggregateReturnExpressionTypes(c, func, checkMode) {
         }
         expr = skipParentheses(expr);
         // `return await` unwraps in async functions, and bare calls of the function itself don't contribute.
-        if (isAsync && expr.kind === 224 /* SyntaxKind.AwaitExpression */)
+        if (isAsync && expr.kind === 225 /* SyntaxKind.AwaitExpression */)
             expr = skipParentheses(getExpression(expr));
         if (isRecursiveCall(c, func, expr)) {
             hasReturnOfTypeNever = true;
@@ -820,7 +825,7 @@ function checkAndAggregateReturnExpressionTypes(c, func, checkMode) {
     return aggregatedTypes;
 }
 function isRecursiveCall(c, func, expr) {
-    if (expr.kind !== 214 /* SyntaxKind.CallExpression */)
+    if (expr.kind !== 215 /* SyntaxKind.CallExpression */)
         return false;
     const callee = getExpression(expr);
     if (callee.kind !== 79 /* SyntaxKind.Identifier */)
@@ -835,11 +840,11 @@ function isRecursiveCall(c, func, expr) {
 }
 function mayReturnNever(func) {
     switch (func.kind) {
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 220 /* SyntaxKind.ArrowFunction */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 221 /* SyntaxKind.ArrowFunction */:
             return true;
-        case 175 /* SyntaxKind.MethodDeclaration */:
-            return func.parent.kind === 211 /* SyntaxKind.ObjectLiteralExpression */;
+        case 176 /* SyntaxKind.MethodDeclaration */:
+            return func.parent.kind === 212 /* SyntaxKind.ObjectLiteralExpression */;
     }
     return false;
 }
@@ -876,23 +881,23 @@ class YieldCollector extends NodeVisitor {
     yields = [];
     visit(node) {
         switch (node.kind) {
-            case 230 /* SyntaxKind.YieldExpression */: {
+            case 231 /* SyntaxKind.YieldExpression */: {
                 this.yields.push(node);
                 const operand = node.expression;
                 if (operand !== undefined)
                     this.visit(operand);
                 return;
             }
-            case 267 /* SyntaxKind.EnumDeclaration */:
-            case 265 /* SyntaxKind.InterfaceDeclaration */:
-            case 268 /* SyntaxKind.ModuleDeclaration */:
-            case 266 /* SyntaxKind.TypeAliasDeclaration */:
+            case 268 /* SyntaxKind.EnumDeclaration */:
+            case 266 /* SyntaxKind.InterfaceDeclaration */:
+            case 269 /* SyntaxKind.ModuleDeclaration */:
+            case 267 /* SyntaxKind.TypeAliasDeclaration */:
                 return;
         }
         if (isFunctionLike(node)) {
             // Nested functions are skipped, but not their computed names.
             const name = getName(node);
-            if (name !== undefined && name.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+            if (name !== undefined && name.kind === 169 /* SyntaxKind.ComputedPropertyName */)
                 this.visit(getExpression(name));
             return;
         }
@@ -913,22 +918,22 @@ export class ReturnCollector {
     }
     visit(node) {
         switch (node.kind) {
-            case 254 /* SyntaxKind.ReturnStatement */:
+            case 255 /* SyntaxKind.ReturnStatement */:
                 this.returns.push(node);
                 return;
-            case 263 /* SyntaxKind.FunctionDeclaration */:
-            case 219 /* SyntaxKind.FunctionExpression */:
-            case 220 /* SyntaxKind.ArrowFunction */:
-            case 264 /* SyntaxKind.ClassDeclaration */:
-            case 232 /* SyntaxKind.ClassExpression */:
-            case 175 /* SyntaxKind.MethodDeclaration */:
-            case 178 /* SyntaxKind.GetAccessor */:
-            case 179 /* SyntaxKind.SetAccessor */:
-            case 177 /* SyntaxKind.Constructor */:
-            case 265 /* SyntaxKind.InterfaceDeclaration */:
-            case 266 /* SyntaxKind.TypeAliasDeclaration */:
-            case 267 /* SyntaxKind.EnumDeclaration */:
-            case 268 /* SyntaxKind.ModuleDeclaration */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
+            case 220 /* SyntaxKind.FunctionExpression */:
+            case 221 /* SyntaxKind.ArrowFunction */:
+            case 265 /* SyntaxKind.ClassDeclaration */:
+            case 233 /* SyntaxKind.ClassExpression */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
+            case 178 /* SyntaxKind.Constructor */:
+            case 266 /* SyntaxKind.InterfaceDeclaration */:
+            case 267 /* SyntaxKind.TypeAliasDeclaration */:
+            case 268 /* SyntaxKind.EnumDeclaration */:
+            case 269 /* SyntaxKind.ModuleDeclaration */:
                 return;
         }
         if (isStatementContainer(node))
@@ -937,21 +942,21 @@ export class ReturnCollector {
 }
 function isStatementContainer(node) {
     switch (node.kind) {
-        case 242 /* SyntaxKind.Block */:
-        case 246 /* SyntaxKind.IfStatement */:
-        case 247 /* SyntaxKind.DoStatement */:
-        case 248 /* SyntaxKind.WhileStatement */:
-        case 249 /* SyntaxKind.ForStatement */:
-        case 250 /* SyntaxKind.ForInStatement */:
-        case 251 /* SyntaxKind.ForOfStatement */:
-        case 255 /* SyntaxKind.WithStatement */:
-        case 256 /* SyntaxKind.SwitchStatement */:
-        case 270 /* SyntaxKind.CaseBlock */:
-        case 297 /* SyntaxKind.CaseClause */:
-        case 298 /* SyntaxKind.DefaultClause */:
-        case 257 /* SyntaxKind.LabeledStatement */:
-        case 259 /* SyntaxKind.TryStatement */:
-        case 300 /* SyntaxKind.CatchClause */:
+        case 243 /* SyntaxKind.Block */:
+        case 247 /* SyntaxKind.IfStatement */:
+        case 248 /* SyntaxKind.DoStatement */:
+        case 249 /* SyntaxKind.WhileStatement */:
+        case 250 /* SyntaxKind.ForStatement */:
+        case 251 /* SyntaxKind.ForInStatement */:
+        case 252 /* SyntaxKind.ForOfStatement */:
+        case 256 /* SyntaxKind.WithStatement */:
+        case 257 /* SyntaxKind.SwitchStatement */:
+        case 271 /* SyntaxKind.CaseBlock */:
+        case 298 /* SyntaxKind.CaseClause */:
+        case 299 /* SyntaxKind.DefaultClause */:
+        case 258 /* SyntaxKind.LabeledStatement */:
+        case 260 /* SyntaxKind.TryStatement */:
+        case 301 /* SyntaxKind.CatchClause */:
             return true;
     }
     return false;
@@ -974,11 +979,12 @@ function assignParameterType(c, declaration) {
     const id = getSymbolId(symbol);
     if (c.symbolTypes.get(id) !== undefined)
         return;
-    const t = getTypeOfSymbol(c, symbol);
+    // Without a context, the parameter's own type, reporting its implicit any errors.
+    const t = getWidenedTypeForVariableLikeDeclaration(c, declaration, true);
     c.symbolTypes.set(id, addOptionality(c, t, false, getInitializer(declaration) === undefined && isOptionalDeclaration(declaration)));
     const name = getName(declaration);
     if (name !== undefined &&
-        (name.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 208 /* SyntaxKind.ArrayBindingPattern */)) {
+        (name.kind === 208 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 209 /* SyntaxKind.ArrayBindingPattern */)) {
         // Without a better inference than `unknown`, a binding pattern implies the type.
         if (c.symbolTypes.get(id) === c.unknownType)
             c.symbolTypes.set(id, getTypeFromBindingPattern(c, name, false, false));
@@ -988,7 +994,7 @@ function assignParameterType(c, declaration) {
 /** Pushes a contextually assigned parameter type into the binding elements of its pattern. */
 function assignBindingElementTypes(c, pattern, parentType) {
     for (const element of getElements(pattern).nodes) {
-        if (element.kind !== 209 /* SyntaxKind.BindingElement */)
+        if (element.kind !== 210 /* SyntaxKind.BindingElement */)
             continue;
         const name = getName(element);
         if (name === undefined)

package/dist/api/compiler/checker-generated-code.d.ts

@@ -1,15 +1,6 @@
 import { type Node } from './ast.js';
 import type { Checker } from './checker.js';
 import { type Diagnostic, type DiagnosticMessage } from './diagnostics.js';
-/** A collision check that waits until the file is checked, when the flags it reads are complete. */
-export declare class DeferredCollisionCheck {
-    readonly node: Node;
-    /** `Reflect` rather than `WeakMap` and `WeakSet`. */
-    readonly reflect: boolean;
-    constructor(node: Node, 
-    /** `Reflect` rather than `WeakMap` and `WeakSet`. */
-    reflect: boolean);
-}
 /** An error that is not reported under noEmit, since it is about the emitted code. */
 export declare function errorSkippedOnNoEmit(c: Checker, node: Node, message: DiagnosticMessage, ...args: string[]): Diagnostic;
 /** Checks the name of a declaration against the names the emitted code reserves. */
@@ -21,5 +12,3 @@ export declare function checkCollisionsForDeclarationName(c: Checker, node: Node
 export declare function markPrivateIdentifierScope(c: Checker, node: Node): void;
 /** `super.x` in a static initializer before ES2022 is emitted with `Reflect`: marks the block scopes around it. */
 export declare function markSuperPropertyInStaticInitializer(c: Checker, node: Node): void;
-/** Reports the `WeakMap`, `WeakSet` and `Reflect` collisions found while checking the file. */
-export declare function produceDeferredCollisionChecks(c: Checker): void;