The separator is retained when targeting esnext: Playground

It keeps the separator when targeting ESNext. I'm not sure which ECMAScript version it's officially added, figuring this out always seems close to impossible to me.

edit: Too slow, the Cerberus was faster once again.

I'm not sure which ECMAScript version it's officially added, figuring this out always seems close to impossible to me.

Good to know I'm not the only one.

This StackOverflow post and this v8 documentation claim it's part of ES2021, so it would be a bug in TypeScript.

Wow, that was fast 😆 Looks like indeed this is supported for transpilation with latest (though it might want to be part of 2021), and I'm still not sure if it's a thing or not if you got through the createSourceFile / createPrinter flow:

import ts from "typescript";

const printer = ts.createPrinter({});
const sourceFile = ts.createSourceFile(
  "index.ts",
  "1_0",
  ts.ScriptTarget.ESNext,
  true
);
const p = printer.printFile(sourceFile);
console.log(p); // 10

Printback is only guaranteed to be semantics-preserving, not format-preserving.

FWIW the ECMA-262 spec tries to do a better job about this these days.

You also can view the multipage version (https://tc39.es/ecma262/multipage/) instead of the ginormous single page spec. 😄

@DanielRosenwasser Hmm, so numeric separators are ES2021. Is it a bug then that TS doesn't preserve them in the output unless you target ESNext?

Ryan's right that we can't always guarantee preservation, but I kind of feel like it is a bug - we do keep 0b110101 and 0o1234567 preserved if we can.

I don't know what's causing us to lose it - I'm having a hard time finding that.

It's at the very least likely that the following code needs to be changed:

Basically, I'd rewrite this as

- if (numericLiteralFlags & TokenFlags.BinaryOrOctalSpecifier) node.transformFlags |= TransformFlags.ContainsES2015;
+ if (numericLiteralFlags & TokenFlags.NumericLiteralFlags) {
+     if (numericLiteralFlags & TokenFlags.BinaryOrOctalSpecifier) node.transformFlags |= node.transformFlags |= TransformFlags.ContainsES2015;
+     if (numericLiteralFlags & TokenFlags.ContainsSeparator) node.transformFlags |= node.transformFlags |= TransformFlags.ContainsES2021;
+ }

But first you'd need to find where that lossiness is happening.

Ryan's right that we can't always guarantee preservation

Yeah, I got that, it's the fact that it's preserved under ESNext that made me suspect "bug" - this suggests it can be preserved but it's deliberately dropping it for non-ESNext targets.

IOW if someone wants to change this they can, it's just upholding an invariant that we don't actually have.