3.5.1 regression when using this with an index signature of a generic union type #31731

Activity

1. ahejlsberg commented on Jun 3, 2019

   

   Anders Hejlsberg (ahejlsberg)

   on Jun 3, 2019

   Member

   More actions

   This looks like an effect of #30769 which is a known breaking change. It used to be that (A | B)['value'] and A['value'] | B['value'] would behave the same on the target side of the assignable type relation, but (A | B)['value'] is now subject to stricter rules.
2. Anders Hejlsberg (ahejlsberg)

   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 Jun 3, 2019
3. justingrant commented on Jun 3, 2019

   

   Justin Grant (justingrant)

   on Jun 3, 2019

   ContributorAuthor

   More actions

   Anders Hejlsberg (@ahejlsberg) - is there a good heuristic to understand the new "stricter rules" for (A | B)['value']? I read #30769 pretty carefully but I'm having trouble translating that spec into how it applies to this case. Do the new rules effectively treat it like (A & B)['value'] because only the intersection of A and B are now valid in this context? Or is the problem that using this makes it a recursive type and the compiler can't validate the type as OK before it hits a recursion limit and gives up?
4. ahejlsberg commented on Jun 4, 2019

   

   Anders Hejlsberg (ahejlsberg)

   on Jun 4, 2019

   Member

   More actions

   Justin Grant (@justingrant) Yes, the reason for the difference is that (A | B)['value'] now simplifies to A['value'] & B['value'] in a target position, and that is a more restrictive type.

   I did a bit of debugging to see what exactly is going on in the example.

   When the base type of the Union interface is written as R<A['value'] | B['value']> we end up with a circularity as we're measuring the variance of R<A> and Union<A, B>. We therefore default both of those types to have co-variant type parameters. That in turn means that R<A> is related to R<unknown>.

   When the base type is written as R<(A | B)['value']>, we'd previously simplify to the type above, but we now simplify to R<A['value'] & B['value']>. This type is restrictive enough that we don't observe a circularity, and we therefore measure R<A> and Union<A, B> to have invariant type parameters. That in turn means R<A> and Union<A, B> are only compatible with identical instantiations of themselves.

   👍React with 👍1Reacted by Justin Grant
5. justingrant commented on Jun 4, 2019

   

   Justin Grant (justingrant)

   on Jun 4, 2019

   ContributorAuthor

   More actions

   Makes sense. Thanks so much Anders Hejlsberg (@ahejlsberg) for the investigation and clear explanation of what's going on.
6. Justin Grant (justingrant)

   closed this as completedon Jun 4, 2019
7. ahejlsberg commented on Jun 4, 2019

   

   Anders Hejlsberg (ahejlsberg)

   on Jun 4, 2019

   Member

   More actions

   Justin Grant (@justingrant) You're welcome. BTW, as I was looking into this I noticed the very large sets of overloaded Union and Intersection types in the runtypes library. I think you can simplify those dramatically using some of our newer features like variadic functions (#24897). Here's a sketch of what I have in mind (mostly just the types, implementations left as an exercise for the reader):

   export type Runtype<T = unknown> = {
       T: T;  // Witness
       guard(value: unknown): value is T;
   }
   
   export type Record<T extends { [key: string]: Runtype }> = { [P in keyof T]: T[P]['T'] }
   
   export declare const Record: <T extends { [key: string]: Runtype }>(def: T) => Runtype<Record<T>>;
   
   export type Union<T extends Runtype[]> = T[number]['T'];
   
   export declare const Union: <T extends Runtype[]>(...types: T) => Runtype<Union<T>>;
   
   type UnionToIntersection<U> = (U extends U ? (x: U) => void : never) extends (x: infer I) => void ? I : never
   
   export type Intersect<T extends Runtype[]> = UnionToIntersection<T[number]['T']>;
   
   export declare const Intersect: <T extends Runtype[]>(...types: T) => Runtype<Intersect<T>>;
   
   export declare const String: Runtype<string>;
   export declare const Number: Runtype<number>;
   export declare const Literal: <T extends string | number | boolean>(value: T) => Runtype<T>;
   
   const Boolean = Union(Literal(true), Literal(false));
   
   // { s: string, b: boolean } & { n: number } | string
   const MyType = Union(Intersect(Record({ s: String, b: Boolean }), Record({ n: Number })), String);
   
   function foo(x: unknown) {
       if (MyType.guard(x)) {
           if (typeof x === "string") {
               return x;
           }
           else {
               if (x.b) {
                   return "true";
               }
               if (x.n > 10) {
                   return "" + x.n;
               }
               return x.s;
           }
       }
       return "Error";
   }

   👍React with 👍1Reacted by Tom Crockett
8. microsoft

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