Parser API: Expose a Method to Determine Whether a Numeric Literal is of Certain Flag

Search Terms

Parser API numericLiteralFlags numeric literal flag

Suggestion

Currently the parser API apparently does not expose numericLiteralFlags for determining whether the original source is written using features such as binary or octal literal.

I have to do this to determine whether the original source was written using ECMAScript 2015 numeric literal:

    if (TypeScript.isNumericLiteral(node)) {
        let bitflag = node['numericLiteralFlags'];
        if (bitflag) {
            if (bitflag & (1 << 8)) {
                // internal flag: Octal
                // https://github.com/Microsoft/TypeScript/blob/a4a1bed88bdcb160eff032790f05629f9fa955b4/src/compiler/types.ts#L1659
                return true;
            }
            if (bitflag & (1 << 7)) {
                // internal flag: Binary
                // https://github.com/Microsoft/TypeScript/blob/a4a1bed88bdcb160eff032790f05629f9fa955b4/src/compiler/types.ts#L1658
                return true;
            }
        }
    }

AFAIK this is the only way to check it since node.text evaluates to the string representation of the base 10 number...

Use Cases

I need this 'internal' API to write a parser for helping determine whether a JS file is compatible with syntax of certain ECMAScript version. For example: Can this script run in ES5 environments?

node_modules may contain packages not distributed in ES5, which can cause minification error when being minified with minifier not capable of handling ES5, or worse, ninja runtime error. (I want to parse packages / libraries with TypeScript API, then transpile them only when necessary for fast build. Rather than transpiling everything)

Examples

Simple proposed API:

isES2015OctalNumericLiteral(node)
isES2015BinaryNumericLiteral(node)

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. new expression-level syntax)

Start with the parser API entry point TypeScript.isNumericLiteral and the numericLiteralFlags definition referenced in src/compiler/types.ts. Trace how numeric literals are represented, then determine the public API shape for identifying binary and octal literals and add coverage for the proposed behavior; done means consumers no longer need the internal flag.