Unable to infer parameters for generic constructor/functions with a distributive conditional type

Description

export {};

interface _Map {
  foo: { a: 123 }
}

type ModuleSubType = "bar" & { brand: true };

type Map = _Map & Record<ModuleSubType, { blah: string }>

type SubTypeGet<
  SubType extends string,
  Map extends Record<SubType, unknown>,
> = SubType extends unknown
? { type?: SubType } & Map[SubType]
: never;

// This is the most straightforward way I can figure out to come to this issue:
type TestParameters = Parameters<<T extends "foo" | ModuleSubType>(arg: SubTypeGet<T, Map>) => void>
//   ^? never

// I originally encountered it with a class like this:
declare class Test<T extends "foo" | ModuleSubType> {
  constructor(arg: SubTypeGet<T, Map>);
}

type TestConstructorParameters = ConstructorParameters<typeof Test>;
//   ^? never

Contributor guide

Tech stack

typescript

Domain

developer experiencetooling

Issue type

bug

DifficultyEstimated implementation difficulty for a new contributor, from 1 for very small changes to 5 for expert-level work.

4

Estimated timeA rough time range for an experienced contributor to investigate, implement, test, and prepare a pull request.

3-5 days

Activity statusHow available the issue appears right now: fresh, active, stale, blocked, or waiting on maintainer input.

fresh

ClarityHow clearly the issue explains the expected change, acceptance criteria, and next step.

clear

Prerequisites

TypeScript type systemdistributive conditional types

Newbie friendlinessA 1-100 score estimating how approachable this issue is for first-time contributors.

20

Research direction

Start by running the provided TypeScript playground link to reproduce the issue. The bug is that `Parameters` and `ConstructorParameters` return `never` when the function/constructor argument type involves a distributive conditional type over a union. Investigate how the TypeScript compiler resolves conditional types and how inference works for generic functions and constructors. Look at the source code in `src/compiler/checker.ts`, particularly the functions `getTypeOfCallSignature` and `inferFromCall`. Search for existing tests related to `Parameters` and `ConstructorParameters` with conditional types. Consider whether this is a known limitation or a true bug that requires changes to type inference logic.