Merge pull request #15 from ThomasR/ES6

Use ES6 features

Author: michaelficarra

.travis.yml

@@ -1,7 +1,5 @@
 sudo: false
 language: node_js
 node_js:
+  - "5"
   - "4"
-  - "iojs-3"
-  - "iojs-2"
-  - "0.12"

lib/esshorten.js

@@ -22,82 +22,73 @@
   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
-/*global exports:true*/
-
-(function () {
+(() => {
     'use strict';
 
-    var escope,
-        estraverse,
-        esutils,
-        utility,
-        version,
-        assert,
-        Syntax;
+    let assert;
 
-    escope = require('escope');
-    estraverse = require('estraverse');
-    esutils = require('esutils');
-    utility = require('./utility');
-    version = require('../package.json').version;
+    const escope = require('escope');
+    const estraverse = require('estraverse');
+    const esutils = require('esutils');
+    const utility = require('./utility');
+    const version = require('../package.json').version;
 
-    Syntax = estraverse.Syntax;
+    const Syntax = estraverse.Syntax;
 
     assert = function assert(cond, message) {
         if (!cond) {
             throw new Error(message);
         }
     };
 
-    if (version.indexOf('-dev', version.length - 4) === -1) {
-        assert = function () { };
+    if (!version.endsWith('-dev')) {
+        assert = () => { };
     }
 
-    function NameGenerator(scope, options) {
-        this._scope = scope;
-        this._functionName = '';
-        if (!options.distinguishFunctionExpressionScope &&
-                this._scope.upper &&
-                this._scope.upper.functionExpressionScope) {
-            this._functionName = this._scope.upper.block.id.name;
+    class NameGenerator {
+        constructor(scope, options) {
+            this._scope = scope;
+            this._functionName = '';
+            if (!options.distinguishFunctionExpressionScope &&
+                    this._scope.upper &&
+                    this._scope.upper.functionExpressionScope) {
+                this._functionName = this._scope.upper.block.id.name;
+            }
         }
-    }
 
-    NameGenerator.prototype.passAsUnique = function passAsUnique(name) {
-        var i, iz;
-        if (this._functionName === name) {
-            return false;
-        }
-        if (esutils.keyword.isKeywordES5(name, true) || esutils.keyword.isRestrictedWord(name)) {
-            return false;
-        }
-        if (this._scope.taints.has(name)) {
-            return false;
-        }
-        for (i = 0, iz = this._scope.through.length; i < iz; ++i) {
-            if (this._scope.through[i].identifier.name === name) {
+        passAsUnique(name) {
+            if (this._functionName === name) {
                 return false;
             }
+            if (esutils.keyword.isKeywordES5(name, true) || esutils.keyword.isRestrictedWord(name)) {
+                return false;
+            }
+            if (this._scope.taints.has(name)) {
+                return false;
+            }
+            for (let through of this._scope.through) {
+                if (through.identifier.name === name) {
+                    return false;
+                }
+            }
+            return true;
         }
-        return true;
-    };
-
-    NameGenerator.prototype.generateName = function generateName(tip) {
-        do {
-            tip = utility.generateNextName(tip);
-        } while (!this.passAsUnique(tip));
-        return tip;
-    };
 
-    function run(scope, options) {
-        var i, iz, j, jz, variable, name, def, ref, generator;
+        generateName(tip) {
+            do {
+                tip = utility.generateNextName(tip);
+            } while (!this.passAsUnique(tip));
+            return tip;
+        }
+    }
 
-        generator = new NameGenerator(scope, options);
+    const run = (scope, options) => {
+        let generator = new NameGenerator(scope, options);
 
         if (scope.isStatic()) {
-            name = '9';
+            let name = '9';
 
-            scope.variables.sort(function (a, b) {
+            scope.variables.sort((a, b) => {
                 if (a.tainted) {
                     return 1;
                 }
@@ -107,8 +98,7 @@
                 return (b.identifiers.length + b.references.length) - (a.identifiers.length + a.references.length);
             });
 
-            for (i = 0, iz = scope.variables.length; i < iz; ++i) {
-                variable = scope.variables[i];
+            for (let variable of scope.variables) {
 
                 if (variable.tainted) {
                     continue;
@@ -124,117 +114,110 @@
 
                 name = generator.generateName(name);
 
-                for (j = 0, jz = variable.identifiers.length; j < jz; ++j) {
-                    def = variable.identifiers[j];
+                for (let def of variable.identifiers) {
                     // change definition's name
                     def.name = name;
                 }
 
-                for (j = 0, jz = variable.references.length; j < jz; ++j) {
-                    ref = variable.references[j];
+                for (let ref of variable.references) {
                     // change reference's name
                     ref.identifier.name = name;
                 }
             }
         }
-    }
+    };
 
-    function Label(node, upper) {
-        this.node = node;
-        this.upper = upper;
-        this.users = [];
-        this.names = new Map();
-        this.name = null;
-    }
+    class Label {
+        constructor(node, upper) {
+            this.node = node;
+            this.upper = upper;
+            this.users = [];
+            this.names = new Map();
+            this.name = null;
+        }
 
-    Label.prototype.mangle = function () {
-        var tip, current, i, iz;
-        tip = '9';
+        mangle() {
+            let tip = '9';
 
-        // merge already used names
-        for (current = this.upper; current; current = current.upper) {
-            if (current.name !== null) {
-                this.names.set(current.name, true);
+            // merge already used names
+            for (let current = this.upper; current; current = current.upper) {
+                if (current.name !== null) {
+                    this.names.set(current.name, true);
+                }
             }
-        }
 
-        do {
-            tip = utility.generateNextName(tip);
-        } while (this.names.has(tip));
+            do {
+                tip = utility.generateNextName(tip);
+            } while (this.names.has(tip));
 
-        this.name = tip;
+            this.name = tip;
 
-        for (current = this.upper; current; current = current.upper) {
-            current.names.set(tip, true);
-        }
+            for (let current = this.upper; current; current = current.upper) {
+                current.names.set(tip, true);
+            }
 
-        this.node.label.name = tip;
-        for (i = 0, iz = this.users.length; i < iz; ++i) {
-            this.users[i].label.name = tip;
+            this.node.label.name = tip;
+            this.users.forEach(user => user.label.name = tip);
         }
-    };
-
-    function LabelScope(upper) {
-        this.map = new Map();
-        this.upper = upper;
-        this.label = null;
-        this.labels = [];
     }
 
-    LabelScope.prototype.register = function register(node) {
-        var name;
 
-        assert(node.type === Syntax.LabeledStatement, 'node should be LabeledStatement');
+    class LabelScope {
+        constructor (upper) {
+            this.map = new Map();
+            this.upper = upper;
+            this.label = null;
+            this.labels = [];
+        }
 
-        this.label = new Label(node, this.label);
-        this.labels.push(this.label);
+        register(node) {
+            let name;
 
-        name = node.label.name;
-        assert(!this.map.has(name), 'duplicate label is found');
-        this.map.set(name, this.label);
-    };
+            assert(node.type === Syntax.LabeledStatement, 'node should be LabeledStatement');
 
-    LabelScope.prototype.unregister = function unregister(node) {
-        var name, ref;
-        if (node.type !== Syntax.LabeledStatement) {
-            return;
-        }
+            this.label = new Label(node, this.label);
+            this.labels.push(this.label);
 
-        name = node.label.name;
-        ref = this.map.get(name);
-        this.map['delete'](name);
+            name = node.label.name;
+            assert(!this.map.has(name), 'duplicate label is found');
+            this.map.set(name, this.label);
+        }
 
-        this.label = ref.upper;
-    };
+        unregister(node) {
+            let name, ref;
+            if (node.type !== Syntax.LabeledStatement) {
+                return;
+            }
 
-    LabelScope.prototype.resolve = function resolve(node) {
-        var name;
-        if (node.label) {
             name = node.label.name;
-            assert(this.map.has(name), 'unresolved label');
-            this.map.get(name).users.push(node);
-        }
-    };
+            ref = this.map.get(name);
+            this.map.delete(name);
 
-    LabelScope.prototype.close = function close() {
-        var i, iz, label;
-        this.labels.sort(function (lhs, rhs) {
-            return rhs.users.length - lhs.users.length;
-        });
+            this.label = ref.upper;
+        }
 
-        for (i = 0, iz = this.labels.length; i < iz; ++i) {
-            label = this.labels[i];
-            label.mangle();
+        resolve(node) {
+            if (node.label) {
+                let name = node.label.name;
+                assert(this.map.has(name), 'unresolved label');
+                this.map.get(name).users.push(node);
+            }
         }
 
-        return this.upper;
-    };
+        close() {
+            this.labels.sort((lhs, rhs) => rhs.users.length - lhs.users.length);
 
-    function mangleLabels(tree) {
-        var labelScope;
-        var FuncOrProgram = [Syntax.Program, Syntax.FunctionExpression, Syntax.FunctionDeclaration];
+            this.labels.forEach(label => label.mangle());
+
+            return this.upper;
+        }
+    }
+
+    const mangleLabels = tree => {
+        let labelScope;
+        const FuncOrProgram = [Syntax.Program, Syntax.FunctionExpression, Syntax.FunctionDeclaration];
         estraverse.traverse(tree, {
-            enter: function (node) {
+            enter: node => {
                 if (FuncOrProgram.indexOf(node.type) >= 0) {
                     labelScope = new LabelScope(labelScope);
                     return;
@@ -251,7 +234,7 @@
                     break;
                 }
             },
-            leave: function (node) {
+            leave: node => {
                 labelScope.unregister(node);
                 if (FuncOrProgram.indexOf(node.type) >= 0) {
                     labelScope = labelScope.close();
@@ -260,10 +243,10 @@
         });
 
         return tree;
-    }
+    };
 
-    function mangle(tree, options) {
-        var result, manager, i, iz;
+    const mangle = (tree, options) => {
+        let result, manager;
 
         if (options == null) {
             options = { destructive: true };
@@ -273,16 +256,16 @@
         manager = escope.analyze(result, { directive: true });
 
         // mangling names
-        for (i = 0, iz = manager.scopes.length; i < iz; ++i) {
-            run(manager.scopes[i], options);
-        }
+        manager.scopes.forEach(scope => run(scope, options));
 
         // mangling labels
         return mangleLabels(result);
-    }
+    };
 
-    exports.mangle = mangle;
-    exports.version = version;
-    exports.generateNextName = utility.generateNextName;
-}());
+    module.exports = {
+        mangle,
+        version,
+        generateNextName: utility.generateNextName
+    };
+})();
 /* vim: set sw=4 ts=4 et tw=80 : */