Support bigint literals in const enums

Search Terms

• “const enum member initializers can only contain literal values”
• “bigint enum”
• “ts(2474)”

Suggestion

A bigint literal is a literal, but it does not seem usable in const enums.

const enum Foo {
  Bar = 123n
}

Currently produces, on 3.9.0-beta:

const enum member initializers can only contain literal values and other computed enum values. ts(2474)

Use Cases

Bigint compile-time constants 🙂

Examples

const enum Foo {
  Bar = 123n
}

console.log(Foo.Bar);

Should compile to

console.log(123n);

And log 123n when run.

Checklist

My suggestion meets these guidelines:

• This wouldn’t be a breaking change in existing TypeScript/JavaScript code
• This wouldn’t change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn’t a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript’s Design Goals.

[connor4312]

The use case would be the similar to using normal numbers in enums–just for scenarios where we’re dealing with integers that don’t fit into float64’s. The place I ran into this is dealing with IPv6 addresses. For IPv4 addresses, I can have an enum of well-known masks like

const enum IPv4Masks {
  MulticastMask = 0x00_ff_ff_ff,
  // ...
}

But IPv6 addresses are 64-bit integers. So, because const enums don’t support bigints, I’m unable to similarly do

const enum IPv6Masks {
  MulticastMask= 0x00ff_ffff_ffff_ffff_ffff_ffff_ffff_ffffn, 
  // ...
}

You could also easily imagine large bitsets with >52 values.

const enum Permissions {
  Read = 1n << 0n,
  Write = 1n << 1n,
  // ...
  BeFancy = 1n << 58n,
}

I don’t think there should be an error message at all here, since bigint literals are just another type of literal; restricting their use in const enums seems arbitrary.

[yseymour]

You could also easily imagine large bitsets with >52 values.

Actually, >31 values, since bitwise operators in JS convert Number operands to signed 32-bit which makes the 32nd bit effectively unusable. Being able to use BigInts would be very helpful for interop with native code.