zoltan-mihalyi / optimize

JavaScript code optimizer

optimize

JavaScript code optimizer

usage

var optimize = require('optimize');
optimize('console.log(1+1);'); //"console.log(2);"

optimize's Issues

better Map implementation if available

handle extra scopes at foreach and function expression

The name "a" is in a scope which is different from the scope of the block.

(function a(){
  //a is accessible but can hide with local vars.
});

The same applies to this:

for (let a in x){
  //a is accessible but can hide with local vars.
}

Handle adding properties to global objects

remove unused assignments

replace with the result of the expression

handle return in inlined function calls

reduce duplicate declarations

var a=1;
var a=2;

expected result:

var a=1;
a=2;

fix iteration on replacing array

            for (let j = 0; j < sub.length; j++) {
                const lengthBefore = sub.length;
                let result:T = (sub[j] as SemanticNode).walk(before);
                j -= lengthBefore - sub.length;
                if (result) {
                    return result;
                }
            }

create specialized functions

inline function call parameter variable changed after creation

var x=1;
var f=(function(x){return function(){return x}})(x)
x=2;
f(); //1

replace new RegExp calls

new RegExp("abc") to /abc/

don't remove loop variable declarator

var i; is removed in the code below:

var i;
for (i in obj) {
}

handle duplicate fn declarations in removeUnused and reduceTailRecursion

requires #43 and #60

don't set value to initialValue

In IdentifierNode

handle unsafe functions better

This should be safe:

new Date(0).getTime()

handle clean id access

let assignment, global vars...

don't remove directives

In some cases (in angular optimization) we are removing directives.
Maybe it is a parser bug.

merge branches with local variables

keep formatting and comments after transformation

track object values

hasOwnProperty should be unsafe

"var declarations are undefined before assignment" causes infinite loop

"no global property read" assumption

handle native functions with changed semantic

toBoolean

we could reduce not operator in the same way as we do in conditional reduction

remove unused labels

assignment can be read

a+=1

handle native calls with side effect

[].constructor.prototype.push.call([].constructor.prototype,1);

inline function calls further optimization

functions with a single return statement

infinite loop in self-optimization

handle new operator

don't optimize more on block after rearranging scope

remove items from Object-to-ObjectValue map

Track functions without inlining

function params are not initialized

support es6 features

• generators
• classes
• symbol
• ...

test indexing by number performance

a[0] is replaced by a["0"] .
Maybe a[0] was faster? Maybe just for arrays?

named function expression call

property names are not substituted

    i = "radio";

    Expr.pseudos[ i ] = createInputPseudo( i );

don't inline function calls in the global scope

cache evaluator functions

target version option

target=es5:
More native function can be substituted
target=es6:
More native functions and other optimizations

handle with statement

don't keep removed branch function declarations

check why optimization slows down after a while

tested with angular.js

remove redundant assignments

a = fn();
return a;

to

return fn();

use tracking

variables with predictable values in inner scopes should be used

function fn() {
    function declaration(){
    }
    return () => {
        return [typeof arguments, typeof declaration];
    }
   declaration = function(){};
}

In the code above, the typeof expressions are predictable.
Use "effectiveValue" which is the all possible values of the variable. This should be used in try block tracking

remove assignments to same value

var a=1; a=1; to var a=1;

remove empty if-s

if else is not empty, create a negated version

readme with the features

handle duplicate variable/function declarations