Uglify JS - compressing unused variables

Uglify has a "compression" option that can remove unused variables...

However, if I stored some functions in an object like this....

helpers = {
    doSomething: function () { ... },
    doSomethingElese: function () { ... }
}

... is there a way to remove helpers.doSomething() if it's never accessed?

Guess I want to give the compressor permission to change my object.

Any ideas if it's possible? Or any other tools that can help?

Solution

Using a static analyzer like Uglify2 or Esprima to accomplish this task is somewhat nontrivial, because there are lots of situations that will call a function that are difficult to determine. To show the complexity, there's this website:

http://sevinf.github.io/blog/2012/09/29/esprima-tutorial/

Which attempts to at least identify unused functions. However the code as provided on that website will not work against your example because it is looking for FunctionDeclarations and not FunctionExpressions. It is also looking for CallExpression's as Identifiers while ignoring CallExpression's that are MemberExpression's as your example uses. There's also a problem of scope there, it doesn't take into account functions in different scopes with the same name - perfectly legal Javascript, but you lose fidelity using that code as it'll miss some unused functions thinking they were called when they were not.

To handle the scope problem, you might be able to employ ESTR (https://github.com/clausreinke/estr), to help figure out the scope of the variables and from there the unused functions. Then you'll need to use something like escodegen to remove the unused functions.

As a starting point for you I've adapted the code on that website to work for your very specific situation provided, but be forwarned, it will have scope issue.

This is written for Node.js, so you'll need to get esprima with npm to use the example as provided, and of course execute it with node.

var fs = require('fs');
var esprima = require('esprima');

if (process.argv.length < 3) {
  console.log('Usage: node ' + process.argv[1] + ' <filename>');
  process.exit(1);
}


notifydeadcode = function(data){
    function traverse(node, func) {
        func(node);
        for (var key in node) {
            if (node.hasOwnProperty(key)) {
                var child = node[key];
                if (typeof child === 'object' && child !== null) {
                    if (Array.isArray(child)) {
                        child.forEach(function(node) {
                            traverse(node, func);
                        });
                    } else {
                        traverse(child, func);
                    }
                }
            }
        }
    }

    function analyzeCode(code) {
        var ast = esprima.parse(code);
        var functionsStats = {};
        var addStatsEntry = function(funcName) {
            if (!functionsStats[funcName]) {
                functionsStats[funcName] = {calls: 0, declarations:0};
            }
        };

        var pnode = null;
        traverse(ast, function(node) {
            if (node.type === 'FunctionExpression') {
                if(pnode.type == 'Identifier'){
                    var expr = pnode.name;
                    addStatsEntry(expr);
                    functionsStats[expr].declarations++;
                }
            } else if (node.type === 'FunctionDeclaration') {
                addStatsEntry(node.id.name);
                functionsStats[node.id.name].declarations++;
            } else if (node.type === 'CallExpression' && node.callee.type === 'Identifier') {
                addStatsEntry(node.callee.name);
                functionsStats[node.callee.name].calls++;
            }else if (node.type === 'CallExpression' && node.callee.type === 'MemberExpression'){
                var lexpr = node.callee.property.name;
                addStatsEntry(lexpr);
                functionsStats[lexpr].calls++;
            }
            pnode = node;
        });
        processResults(functionsStats);
    }

    function processResults(results) {
        //console.log(JSON.stringify(results));
        for (var name in results) {
            if (results.hasOwnProperty(name)) {
                var stats = results[name];
                if (stats.declarations === 0) {
                    console.log('Function', name, 'undeclared');
                } else if (stats.declarations > 1) {
                    console.log('Function', name, 'decalred multiple times');
                } else if (stats.calls === 0) {
                    console.log('Function', name, 'declared but not called');
                }
            }
        }
    }
    analyzeCode(data);
}

// Read the file and print its contents.
var filename = process.argv[2];
fs.readFile(filename, 'utf8', function(err, data) {
  if (err) throw err;
  console.log('OK: ' + filename);
  notifydeadcode(data);
});

So if you plop that in a file like deadfunc.js and then call it like so:

node deadfunc.js test.js

where test.js contains:

helpers = { 
    doSomething:function(){ },
    doSomethingElse:function(){ } 
};
helpers.doSomethingElse();

You will get the output:

OK: test.js
Function doSomething declared but not called

One last thing to note: attempting to find unused variables and functions might be a rabbit hole because you have situations like eval and Functions created from strings. You also have to think about apply and call etc, etc. Which is why, I assume, we don't have this capability in the static analyzers today.