narrowing is lost at creating literals

[zpdDG4gta8XKpMCd]

interface A { isIt: true; text: string; }
interface B { isIt: false; value: number; }
type C = A | B;
const isIt = Math.random() > 0.5;
const c : C = isIt ? { isIt, text: 'hey' } : { isIt, value: 123 }; /* <-- expected to work, actual:
Type '{ isIt: boolean; text: string; } | { isIt: boolean; value: number; }' is not assignable to type 'C'.
  Type '{ isIt: boolean; text: string; }' is not assignable to type 'C'.
    Type '{ isIt: boolean; text: string; }' is not assignable to type 'B'.
      Property 'value' is missing in type '{ isIt: boolean; text: string; }'.
*/

the following works tho:

const c : C = isIt ? { isIt: isIt, text: 'hey' } : { isIt: isIt, value: 123 };

[DanielRosenwasser]

It's extremely strange to me that quick info seems to narrow isIt to true in the true branch, but doesn't narrow at all in the false branch.

[jack-williams]

@DanielRosenwasser I believe you get the correct narrowing behavior with strictNullChecks enabled. What would be the expected behavior with strictNullChecks off?

[weswigham]

@ahejlsberg You left a comment inside isLiteralOfContextualType to the effect that this behavior is intended:

                    // If the contextual type is a union containing both of the 'true' and 'false' types we
                    // don't consider it a literal context for boolean literals.

is there a motivating example for this, or can the exception for booleans be removed?

[ahejlsberg]

@weswigham As I recall it had to do with destructuring an object literal that specifies the value true for a property and at the same time specifices false as the destructuring default. You could try to remove it and see what baseline effects it has.