Add `--inlineConsts` flag

[RyanCavanaugh]

New flag --inlineConsts

Input:

const x = 'hello';

console.log(x);

Output:

console.log('hello');

See also #6678 + #6804

TBD: It's not clear you would want longer strings to inline into their use sites. Discuss.

[weswigham]

Is this only expected to inline strings/numbers? Regex literals? Template strings?

[RyanCavanaugh]

Only "compile-time computable constants", i.e. all the things that are valid const enum initializers, concatenations of string literals, and true / false.

[Andael]

In the above example, the declaration of the const disappears. That could cause problems in a namespace.

Given a namespace:

// vec3.ts

namespace vec3 {
    export const SIZE = 3
    export function create(x, y, z) {...}
    }

And code that uses it, expecting the constant to be there:

// buffer-helpers.ts

interface VectorType {
    SIZE: number
    create: Function
    }

function read(buffer: Float32Array, type: VectorType) {
    // do something that uses type.SIZE
    }

read(someBuffer, vec3)

Output code, following the suggested rules:

// app.js

(function(vec3) {
    vec3.create = function(x, y, z) {...}
    })(vec3)

function read(buffer, type) {
    // do something that uses type.SIZE
    }

read(someBuffer, vec3)    // will fail in some unexpected manner due to missing vec3.SIZE

[RyanCavanaugh]

Hrm, good point. Maybe it's only safe to remove consts that are defined in the global scope?

[Andael]

TBD: It's not clear you would want longer strings to inline into their use sites. Discuss.

Is the goal to optimize by file size, load/parse speed, or execution speed?

[mhegazy]

constant folding usually targets execution speed. the file size will probably increase if you have that constant used in a few places.

[Andael]

Hrm, good point. Maybe it's only safe to remove consts that are defined in the global scope?

Ideally, it could still inline uses of a module-scope constant, even if it keeps the declaration there. Would that be sensible?

Only "compile-time computable constants"

What would be a suitable way to determine which functions are compile-time computable? Would it be enough to say any method on String/Array/Number/Boolean that doesn't have "locale" in the name?

[Naharie]

@RyanCavanaugh
@ander-nz

On #6805 (comment), and #6805 (comment) maybe we should add some new comment form like: /* (const) {ConstantName} ({ConstantValue}) */.

So:

// vec3.ts

namespace vec3 {
    export const SIZE = 3
    export function create(x, y, z) {...}
    }

Would be adjusted to be:

// vec3.ts

/* (const) vec3.SIZE (3) */

namespace vec3 {
    export const SIZE = 3
    export function create(x, y, z) {...}
    }

For completeness I included the sample client code

// buffer-helpers.ts

interface VectorType {
    SIZE: number
    create: Function
    }

function read(buffer: Float32Array, type: VectorType) {
    // do something that uses type.SIZE
    }

read(someBuffer, vec3)

The compiler would see the comment and emit some helper like this:

var __With = function(Target, Name, Value)
{
        Target[Name] = Value;
        return (Target);
};

Which would be used like:

(function(vec3) {
    vec3.create = function(x, y, z) {...}
    })(vec3)

function read(buffer, type) {
    // Other code
   while (SomeVar < type.SIZE)
   {
         /* Code */
    }
    // Other code
 }

read(someBuffer, __With (vec3, "SIZE", 3)) 

Could that work or am I just missing all the corner cases?

[dead-claudia]

@KingDavid12 Your generated code is semantically equivalent to the below:

vec3.create = function(x, y, z) {...}

function read(buffer, type) {
    // Other code
   while (SomeVar < type.SIZE)
   {
         /* Code */
    }
    // Other code
 }

read(someBuffer, (vec3.SIZE = 3, vec3))

There's 0 constant folding going on here, so you don't have the runtime benefit of minimal computation.

[dead-claudia]

@RyanCavanaugh @mhegazy

Should strings be excluded from the constant propagation after a certain limit? There's usually minimal perf difference in practice, and larger strings sometimes are faster when stored in a variable on the heap.

Not arguing numbers, etc., though. Those can still be folded as normally.