Limit of 25 members when using union of mapped type #40803

fluggo · 2020-09-28T04:21:23Z

TypeScript Version: 4.0.2

Search Terms: 25, limit, mappings, mapped, label:"Domain: Big Unions", keyof

Expected behavior: Unions of mapped types (or keyof said mapped type) should work through assignment

Actual behavior: Compiler raises error when one keyof parameter is assigned to another keyof parameter. Removing any of the 26 entries in the mapped type solves the issue.

Related Issues: #35493 is similar; this question on StackOverflow appears to deal with the same behavior

Code

// Commenting out any of these fields fixes the error
type AWSObjectPayloads = {
  'ec2/vpc': { a: number },
  'ec2/image': { b: number },
  'ec2/subnet': { c: number },
  'ec2/security-group': { d: number },
  'ec2/instance': { e: number },
  'ec2/prefix-list': { f: number },
  'ec2/network-interface': { g: number },
  'ec2/vpc-endpoint': { h: number },
  'ec2/nat-gateway': { i: number },
  'ec2/dhcp-options': { j: number },
  'ec2/elastic-ip': { k: number },
  'ec2/flow-log': { l: number },
  'ec2/internet-gateway': { m: number },
  'ec2/network-acl': { n: number },
  'ec2/peering-connection': { o: number },
  'ec2/route-table': { p: number },
  'ec2/vpn-gateway': { q: number },
  'elb/load-balancer': { r: number },
  'elb-v2/load-balancer': { s: number },
  'elb-v2/target-group': { t: number },
  'rds/subnet-group': { u: number },
  'rds/cluster': { v: number },
  'rds/instance': { w: number },
  'redshift/subnet-group': { x: number },
  'redshift/cluster': { y: number },
  'cloudtrail/trail': { z: number },
};

interface AWSObjectImpl<Name, Desc> {
  objectType: Name;
  desc: Desc;
}

type AWSObjectTypesByName = {
  [K in keyof AWSObjectPayloads]: AWSObjectImpl<K, AWSObjectPayloads[K]>
};

type AWSObjectTypeName = keyof AWSObjectTypesByName;
type AWSObject<T extends AWSObjectTypeName = AWSObjectTypeName> = AWSObjectTypesByName[T];

// Using this definition for AWSObject corrects the assignment error, but
// eliminates the type narrowing:
//
//   type AWSObject<T extends AWSObjectTypeName = AWSObjectTypeName> = AWSObjectImpl<T, AWSObjectPayloads[T]>;

function foo(test: AWSObjectTypeName) {
  const testA: AWSObject = {
    objectType: test,
    desc: null as any,
  };

  if(testA.objectType === 'ec2/vpc')
    console.log(testA.desc.a);
}

Output

"use strict";
// Using this definition for AWSObject corrects the assignment error, but
// eliminates the type narrowing:
//
//   type AWSObject<T extends AWSObjectTypeName = AWSObjectTypeName> = AWSObjectImpl<T, AWSObjectPayloads[T]>;
function foo(test) {
    const testA = {
        objectType: test,
        desc: null,
    };
    if (testA.objectType === 'ec2/vpc')
        console.log(testA.desc.a);
}

Compiler Options

{
  "compilerOptions": {
    "noImplicitAny": true,
    "strictNullChecks": true,
    "strictFunctionTypes": true,
    "strictPropertyInitialization": true,
    "strictBindCallApply": true,
    "noImplicitThis": true,
    "noImplicitReturns": true,
    "alwaysStrict": true,
    "esModuleInterop": true,
    "declaration": true,
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true,
    "moduleResolution": 2,
    "target": "ES2017",
    "jsx": "React",
    "module": "ESNext"
  }
}

Playground Link: Provided

RyanCavanaugh · 2020-09-28T20:52:41Z

When the source object doesn't have any it's pretty straightforward to demonstrate that this kind of initialization is rarely sound, but we try to make this particular kind of assignment work anyway by enumerating all possible values that the initializer could have, and seeing if that value would be assignable to AWSObject. There's a hardcoded limit here of 24 candidates (more typically hit when you have e.g. 2 x 3 x 3 possible values) for this process to avoid combinatorial explosions.

fluggo · 2020-09-28T21:24:54Z

I don't know what you mean by your first sentence. Was there a better way to achieve this same effect?

I can work around this error by casting the test parameter to "any" first, and that's no major loss, but if I'm running into a design limitation, I sure would like a way to do this correctly.

etlovett · 2021-01-27T20:18:57Z

Here's another example of this limit of 25 union entries causing a false type error: #42518 / Playground.

NoriSte · 2021-02-12T15:07:04Z

Here another example: Gist - Playground.

Thanks

RyanCavanaugh added the Design Limitation label Sep 28, 2020

etlovett mentioned this issue Jan 27, 2021

Unions of more than 25 values cannot be used to discriminate other unions #42518

Closed

IllusionMH mentioned this issue Mar 6, 2021

Wrong inference of cross product if component union types exceed (small) cardinality #43108

Closed

MartinJohns mentioned this issue Mar 17, 2021

Assign to union with over 25 items gives error #43283

Closed

MartinJohns mentioned this issue Mar 26, 2021

Hex String - Expression produces a union type that is too complex to represent. #43388

Closed

MartinJohns mentioned this issue Apr 21, 2021

Distribution of union into properties stop working on a big enough union type #43757

Open

Mar	APR	Feb
	22
2020	2021	2023

microsoft / TypeScript

Limit of 25 members when using union of mapped type #40803

Limit of 25 members when using union of mapped type #40803

fluggo commented Sep 28, 2020

RyanCavanaugh commented Sep 28, 2020

fluggo commented Sep 28, 2020

etlovett commented Jan 27, 2021

NoriSte commented Feb 12, 2021

microsoft / TypeScript

Limit of 25 members when using union of mapped type #40803

Limit of 25 members when using union of mapped type #40803

Comments

fluggo commented Sep 28, 2020

RyanCavanaugh commented Sep 28, 2020

fluggo commented Sep 28, 2020

etlovett commented Jan 27, 2021

NoriSte commented Feb 12, 2021