Prefer the initializer type over contextual never parameter type

Author: Andarist

src/compiler/checker.ts

@@ -36062,9 +36062,13 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         const len = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0);
         for (let i = 0; i < len; i++) {
             const parameter = signature.parameters[i];
-            if (!getEffectiveTypeAnnotationNode(parameter.valueDeclaration as ParameterDeclaration)) {
-                const contextualParameterType = tryGetTypeAtPosition(context, i);
-                assignParameterType(parameter, contextualParameterType);
+            const declaration = parameter.valueDeclaration as ParameterDeclaration;
+            if (!getEffectiveTypeAnnotationNode(declaration)) {
+                let type = tryGetTypeAtPosition(context, i);
+                if (type && type.flags & TypeFlags.Never && declaration.initializer) {
+                    type = widenTypeInferredFromInitializer(declaration, checkDeclarationInitializer(declaration, CheckMode.Normal));
+                }
+                assignParameterType(parameter, type);
             }
         }
         if (signatureHasRestParameter(signature)) {

tests/baselines/reference/contextuallyTypedNeverParameterWithInitializer.symbols

@@ -0,0 +1,43 @@
+//// [tests/cases/compiler/contextuallyTypedNeverParameterWithInitializer.ts] ////
+
+=== contextuallyTypedNeverParameterWithInitializer.ts ===
+declare function test1<
+>test1 : Symbol(test1, Decl(contextuallyTypedNeverParameterWithInitializer.ts, 0, 0))
+
+  TContext,
+>TContext : Symbol(TContext, Decl(contextuallyTypedNeverParameterWithInitializer.ts, 0, 23))
+
+  TMethods extends Record<string, (ctx: TContext, ...args: never[]) => unknown>,
+>TMethods : Symbol(TMethods, Decl(contextuallyTypedNeverParameterWithInitializer.ts, 1, 11))
+>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --))
+>ctx : Symbol(ctx, Decl(contextuallyTypedNeverParameterWithInitializer.ts, 2, 35))
+>TContext : Symbol(TContext, Decl(contextuallyTypedNeverParameterWithInitializer.ts, 0, 23))
+>args : Symbol(args, Decl(contextuallyTypedNeverParameterWithInitializer.ts, 2, 49))
+
+>(context: TContext, methods: TMethods): void;
+>context : Symbol(context, Decl(contextuallyTypedNeverParameterWithInitializer.ts, 3, 2))
+>TContext : Symbol(TContext, Decl(contextuallyTypedNeverParameterWithInitializer.ts, 0, 23))
+>methods : Symbol(methods, Decl(contextuallyTypedNeverParameterWithInitializer.ts, 3, 20))
+>TMethods : Symbol(TMethods, Decl(contextuallyTypedNeverParameterWithInitializer.ts, 1, 11))
+
+test1(
+>test1 : Symbol(test1, Decl(contextuallyTypedNeverParameterWithInitializer.ts, 0, 0))
+  {
+    count: 0,
+>count : Symbol(count, Decl(contextuallyTypedNeverParameterWithInitializer.ts, 6, 3))
+
+  },
+  {
+    checkLimit: (ctx, max = 500) => {},
+>checkLimit : Symbol(checkLimit, Decl(contextuallyTypedNeverParameterWithInitializer.ts, 9, 3))
+>ctx : Symbol(ctx, Decl(contextuallyTypedNeverParameterWithInitializer.ts, 10, 17))
+>max : Symbol(max, Decl(contextuallyTypedNeverParameterWithInitializer.ts, 10, 21))
+
+    hasAccess: (ctx, user: { name: string }) => {},
+>hasAccess : Symbol(hasAccess, Decl(contextuallyTypedNeverParameterWithInitializer.ts, 10, 39))
+>ctx : Symbol(ctx, Decl(contextuallyTypedNeverParameterWithInitializer.ts, 11, 16))
+>user : Symbol(user, Decl(contextuallyTypedNeverParameterWithInitializer.ts, 11, 20))
+>name : Symbol(name, Decl(contextuallyTypedNeverParameterWithInitializer.ts, 11, 28))
+
+  },
+);

tests/baselines/reference/contextuallyTypedNeverParameterWithInitializer.types

@@ -0,0 +1,45 @@
+//// [tests/cases/compiler/contextuallyTypedNeverParameterWithInitializer.ts] ////
+
+=== contextuallyTypedNeverParameterWithInitializer.ts ===
+declare function test1<
+>test1 : <TContext, TMethods extends Record<string, (ctx: TContext, ...args: never[]) => unknown>>(context: TContext, methods: TMethods) => void
+
+  TContext,
+  TMethods extends Record<string, (ctx: TContext, ...args: never[]) => unknown>,
+>ctx : TContext
+>args : never[]
+
+>(context: TContext, methods: TMethods): void;
+>context : TContext
+>methods : TMethods
+
+test1(
+>test1(  {    count: 0,  },  {    checkLimit: (ctx, max = 500) => {},    hasAccess: (ctx, user: { name: string }) => {},  },) : void
+>test1 : <TContext, TMethods extends Record<string, (ctx: TContext, ...args: never[]) => unknown>>(context: TContext, methods: TMethods) => void
+  {
+>{    count: 0,  } : { count: number; }
+
+    count: 0,
+>count : number
+>0 : 0
+
+  },
+  {
+>{    checkLimit: (ctx, max = 500) => {},    hasAccess: (ctx, user: { name: string }) => {},  } : { checkLimit: (ctx: { count: number; }, max?: number) => void; hasAccess: (ctx: { count: number; }, user: {    name: string;}) => void; }
+
+    checkLimit: (ctx, max = 500) => {},
+>checkLimit : (ctx: { count: number; }, max?: number) => void
+>(ctx, max = 500) => {} : (ctx: { count: number; }, max?: number) => void
+>ctx : { count: number; }
+>max : number
+>500 : 500
+
+    hasAccess: (ctx, user: { name: string }) => {},
+>hasAccess : (ctx: { count: number; }, user: {    name: string;}) => void
+>(ctx, user: { name: string }) => {} : (ctx: { count: number; }, user: {    name: string;}) => void
+>ctx : { count: number; }
+>user : { name: string; }
+>name : string
+
+  },
+);

tests/cases/compiler/contextuallyTypedNeverParameterWithInitializer.ts

@@ -0,0 +1,17 @@
+// @strict: true
+// @noEmit: true
+
+declare function test1<
+  TContext,
+  TMethods extends Record<string, (ctx: TContext, ...args: never[]) => unknown>,
+>(context: TContext, methods: TMethods): void;
+
+test1(
+  {
+    count: 0,
+  },
+  {
+    checkLimit: (ctx, max = 500) => {},
+    hasAccess: (ctx, user: { name: string }) => {},
+  },
+);