Activity

1. MartinJohns commented on Aug 31, 2021

   

   Martin Johns (MartinJohns)

   on Aug 31, 2021

   Last edited by MartinJohns

   Contributor

   More actions

   This is the correct behaviour. Your variable b is not typed SmallBox | LargeBox, it is typed LargeBox. TypeScript correctly sees that the value isLargeBox is always true, and as a result you end up with never in the else-branch.
   

   You see the behaviour you expect if you type b as SmallBox | LargeBox, e.g. using a type-assertion: const b = { ...} as SmallBox | LargeBox.

   You have the same behaviour in TypeScript 4.3.5 when you replace isLargeBox with b.isLargeBox(). TypeScript 4.3.5 did not have the feature to narrow indirectly via local variables: #44730 - You can opt out from this feature by adding an explicit boolean type annotation to your variable: const isLargeBox: boolean = b.isLargeBox();
2. MartinJohns commented on Aug 31, 2021

   

   Martin Johns (MartinJohns)

   on Aug 31, 2021

   Contributor

   More actions

   That b is narrowed to LargeBox despite your explicit type annotation SmallBox | LargeBox is intentional as well. Assigning a value to a variable narrows the variable to the assigned type. Otherwise code like this would not work:

   const value: number | undefined = 123;
   value.toString(); // If this were still typed `number | undefined` then we couldn't call the function.
   // But TypeScript can see that a number is always assigned and the value can't be `undefined`.
   
3. Andrew Branch (andrewbranch)

   added

   Working as IntendedThe behavior described is the intended behavior; this is not a bugThe behavior described is the intended behavior; this is not a bug

   on Aug 31, 2021
4. andrewbranch commented on Aug 31, 2021

   

   Andrew Branch (andrewbranch)

   on Aug 31, 2021

   Member

   More actions

   TypeScript correctly sees that the value isLargeBox is always true

   To clarify, it sees this not because of the return true in the object literal initializer; it sees this because of everything else Martin Johns (@MartinJohns) explained; that b is immediately narrowed to LargeBox and then it simply looks at this is LargeBox and says “yep, it sure is.”

   👍React with 👍1Reacted by Martin Johns
5. ilogico commented on Aug 31, 2021

   

   Gonçalo Fernandes (ilogico)

   on Aug 31, 2021

   More actions

   I don't think TypeScript sees isLargeBox always returns true.
   Instead, I think it sees sayHello() return number, making b a LargeBox, which means b has an impossible type in the else statement.

   You can validate this by checking that b.sayHello() returns number before any narrowing. But b.isLargeBox() is still described as returning an open value: this is LargeBox. TypeScript doesn't look into the function's implementation to see if it always return true or not.
6. pomack commented on Sep 1, 2021

   

   Aalok Shah (pomack)

   on Sep 1, 2021

   Author

   More actions

   Looks like I have the wrong minimal testcase. This is what I intended to do, let me know if I should open a different issue:

   interface Box {
       isSmallBox(): this is SmallBox;
       isLargeBox(): this is LargeBox;
       sayHello(): any;
   }
   
   interface SmallBox extends Box {
       sayTruth(): boolean;
   }
   
   interface LargeBox extends Box {
   }
   
   function hello(a: SmallBox|LargeBox, b: SmallBox|LargeBox) {
       const isLargeBox = a.isLargeBox() || b.isLargeBox();
       if(isLargeBox) {
           a.sayHello();
       } else {
           a.sayHello();
       }
   }
   
   function hello(a: Box, b: Box) {
       const isLargeBox = a.isLargeBox() || b.isLargeBox();
       if(isLargeBox) {
           a.sayHello();
       } else {
           a.sayHello();
       }
   }

   In both functions, the second a.sayHello() has a as never.
   As a workaround, i can have a type attribute that is different between these, but it wasn't an issue in 4.3 or below.
7. MartinJohns commented on Sep 1, 2021

   

   Martin Johns (MartinJohns)

   on Sep 1, 2021

   Last edited by MartinJohns

   Contributor

   More actions

   Andrew Branch (@andrewbranch) This updated example actually looks like a bug of the #44730 feature. a.isLargeBox() || b.isLargeBox() should not narrow a to LargeBox.

   Ignore that. The issue is that LargeBox and SmallBox are structurally equivalent. If you add properties to each making them distinguishable you get the behaviour you expect.

   Aalok Shah (@pomack) Everything that LargeBox says it provides is present in SmallBox as well. And because TypeScript is structurally typed this essentially means that every SmallBox is also a LargeBox. So if you check for LargeBox you end up with never in the else-branch, because every SmallBox is a LargeBox, and it's not a LargeBox, so it can't be a SmallBox either.

   This is why I personally prefer to be explicit using discriminated unions:

   interface SmallBox { boxType: 'small' }
   interface LargeBox { boxType: 'large' }
   type Box = SmallBox | LargeBox
   

   Here you have a dedicated property to explicitly distinguish the different types.

   👍React with 👍1Reacted by Andrew Branch
8. pomack commented on Sep 1, 2021

   

   Aalok Shah (pomack)

   on Sep 1, 2021

   Author

   More actions

   Thanks Martin Johns (@MartinJohns) Will add the explicit attribute.
9. Aalok Shah (pomack)

   closed this as completedon Sep 1, 2021
10. microsoft

    locked as resolved and limited conversation to collaborators on Oct 21, 2025