Repository navigation
Empty Object type hides other types when mixing them with statements or expressions #49952
Closed as not planned
Description
Bug Report
🔎 Search Terms
- object hides string, inferred return type
🕗 Version & Regression Information
- This is the behaviour in every version I tried. The documentation does not say what should happen when {} is combined with other types during control flow inference.
⏯ Playground Link
Playground link with relevant code
💻 Code
Definitions:
// ok: "bob"
const bob: "bob" = "bob"
// ok: {}
const empty: {} = {}
// ok: {} | "bob"
type BO = "bob" | {}
// ok: {} | "bob"
type TBO = typeof bob | typeof empty
// ok: "bob"
type XTBO = Extract<TBO, string>Using Array:
// bad: {}[], should be: ({} | "bob")[]
const array = [bob, empty]
// bad: {}, should be: {} | "bob"
type A = typeof array[number]
// bad: never, should be: "bob"
type XA = Extract<typeof array[number], string>
// bad: {}[], should be: (Date | {})[]
// Bad, because you can still recover Date: (a0[index] instanceof Date) implies that it really is a Date
const a0 = [new Date(), empty]
// ok: ({} | Date)[]
type A0 = (Date | {})[]
// bad: {}[], should be: ({} | 42)[], or ({} | number)[]
const a1 = [42, empty]
// ok: ({} | 42)[]
type A1 = ({} | 42)[]
// ok: {}[]
// Ok, because ("typescript" in a2[index]) does not imply that (a2[index].typescript === "rocks")
const a2 = [{ typescript: "rocks" }, empty]
// ok: ({} | { typescript: "rocks" })[]
type A2 = ({ typescript: "rocks" } | {})[]Using if:
function ifAction(names: boolean) {
if (names) {
return bob
} else {
return {} as const
}
}
// bad: {}, should be: {} | "bob"
type I = ReturnType<typeof ifAction>
// bad: never, should be: "bob"
type XI = Extract<ReturnType<typeof ifAction>, string>Using switch-case + call to function (same result when directly return the constants)
export type Action = Names | Label
export type Names = "Names"
export type Label = "Label"
function action(action: Action) {
switch (action) {
case "Names":
return actionNames(action)
case "Label":
return actionLabel(action)
}
}
function actionNames(action: Names) {
return bob
}
function actionLabel(action: Label) {
return empty
}
// ok: "bob"
type N = ReturnType<typeof actionNames>
// ok: {}
type L = ReturnType<typeof actionLabel>
// bad: {}, should be: {} | "bob"
type R = ReturnType<typeof action>
// bad: never, should be: "bob"
type XS = Extract<ReturnType<typeof action>, string>Actual/Expected behavior
It should not hide the string-type, see comments in code
Activity
MartinJohns commentedon Jul 19, 2022
This is the expected subtype reduction behavior. Note that
{}does not mean "empty object type". It means any type exceptnullandundefined.pyBlob commentedon Jul 20, 2022
Right, as everything except
nullandundefinedis an object in javascript, this actually makes sense.What doesn't make so much sense, is that typescript does not always do the reduction, e.g. when explicitly taking the union of both types like in the
TBOtype above.As a second thought, the same reasoning should apply
{ toString(): string }, which it does most of the time. Inconsistencies only get worse/change when adding generics into the mix (see type-hints / .d.ts outputs):Playground Link
RyanCavanaugh commentedon Jul 20, 2022
Subtype reduction happens "sometimes" where "sometimes" is largely determined by performance constraints. It's never wrong to subtype-reduce so any observed behavior is from an equally-valid set of behaviors.
pyBlob commentedon Jul 20, 2022
I agree. I tried expressions
[a, b]and observed the inferred types:github-actions commentedon Jun 8, 2023
This issue has been marked as 'Not a Defect' and has seen no recent activity. It has been automatically closed for house-keeping purposes.