v3.0.5

- fix `estree` conversion of getter/setter
- fix non-directive literal in `to_mozilla_ast()`
- revamp `test/mozilla-ast.js`
  - reuse `test/ufuzz.js` for code generation
  - use `acorn.parse()` for creating `estree`
- extend `test/ufuzz.js` for `acorn` workaround
  - catch variable redefinition
  - non-trivial literal as directive
  - adjust options for tolerance

Miscellaneous
- optional semi-colon when parsing directives

fixes #1914
closes #1915

README.md

@@ -5,9 +5,9 @@ UglifyJS 3
 UglifyJS is a JavaScript parser, minifier, compressor and beautifier toolkit.
 
 #### Note:
-- **`uglify-js@3.x` has a new API and CLI and is not backwards compatible with [`uglify-js@2.x`](https://github.com/mishoo/UglifyJS2/tree/v2.x)**.
+- **`uglify-js@3.x` has a simplified API and CLI that is not backwards compatible with [`uglify-js@2.x`](https://github.com/mishoo/UglifyJS2/tree/v2.x)**.
 - **Documentation for UglifyJS `2.x` releases can be found [here](https://github.com/mishoo/UglifyJS2/tree/v2.x)**.
-- Release versions of `uglify-js` only support ECMAScript 5 (ES5). 
+- `uglify-js` only supports ECMAScript 5 (ES5).
 - Those wishing to minify
 ES2015+ (ES6+) should use the `npm` package [**uglify-es**](https://github.com/mishoo/UglifyJS2/tree/harmony).
 
@@ -149,16 +149,21 @@ debugging your compressed JavaScript.  To get a source map, pass
 `--source-map --output output.js` (source map will be written out to
 `output.js.map`).
 
-Additionally you might need `--source-map root=<URL>` to pass the URL where
-the original files can be found.  Use `--source-map url=<URL>` to specify
-the URL where the source map can be found.
+Additional options:
+
+- `--source-map filename=<NAME>` to specify the name of the source map.
+
+- `--source-map root=<URL>` to pass the URL where the original files can be found.
+  Otherwise UglifyJS assumes HTTP `X-SourceMap` is being used and will omit the
+  `//# sourceMappingURL=` directive.
+
+- `--source-map url=<URL>` to specify the URL where the source map can be found.
 
 For example:
 
-    uglifyjs /home/doe/work/foo/src/js/file1.js \
-             /home/doe/work/foo/src/js/file2.js \
+    uglifyjs js/file1.js js/file2.js \
              -o foo.min.js -c -m \
-             --source-map base="/home/doe/work/foo/src",root="http://foo.com/src"
+             --source-map root="http://foo.com/src",url=foo.min.js.map
 
 The above will compress and mangle `file1.js` and `file2.js`, will drop the
 output in `foo.min.js` and the source map in `foo.min.js.map`.  The source
@@ -177,11 +182,9 @@ CoffeeScript → compiled JS, UglifyJS can generate a map from CoffeeScript →
 compressed JS by mapping every token in the compiled JS to its original
 location.
 
-To use this feature you need to pass `--in-source-map
-/path/to/input/source.map` or `--in-source-map inline` if the source map is
-included inline with the sources. Normally the input source map should also
-point to the file containing the generated JS, so if that's correct you can
-omit input files from the command line.
+To use this feature pass `--source-map content="/path/to/input/source.map"`
+or `--source-map content=inline` if the source map is included inline with
+the sources.
 
 ## Mangler options
 
@@ -399,13 +402,19 @@ to set `true`; it's effectively a shortcut for `foo=true`).
   compressor from discarding function names.  Useful for code relying on
   `Function.prototype.name`. See also: the `keep_fnames` [mangle option](#mangle).
 
-- `passes` -- default `1`. Number of times to run compress. Use an
-  integer argument larger than 1 to further reduce code size in some cases.
-  Note: raising the number of passes will increase uglify compress time.
+- `passes` -- default `1`. Number of times to run compress with a maximum of 3.
+  In some cases more than one pass leads to further compressed code.  Keep in
+  mind more passes will take more time.
 
 - `keep_infinity` -- default `false`. Pass `true` to prevent `Infinity` from
   being compressed into `1/0`, which may cause performance issues on Chrome.
 
+- `side_effects` -- default `false`. Pass `true` to potentially drop functions
+marked as "pure".  A function call is marked as "pure" if a comment annotation
+`/*@__PURE__*/` or `/*#__PURE__*/` immediately precedes the call. For example:
+`/*@__PURE__*/foo()`;
+
+
 ### The `unsafe` option
 
 It enables some transformations that *might* break code logic in certain
@@ -464,7 +473,7 @@ You can also use conditional compilation via the programmatic API. With the diff
 property name is `global_defs` and is a compressor property:
 
 ```js
-uglifyJS.minify([ "input.js"], {
+uglifyJS.minify(fs.readFileSync("input.js", "utf8"), {
     compress: {
         dead_code: true,
         global_defs: {
@@ -685,20 +694,23 @@ Other options:
 Examples:
 
 ```javascript
-  //tst.js
+// test.js
 var globalVar;
 function funcName(firstLongName, anotherLongName)
 {
     var myVariable = firstLongName +  anotherLongName;
 }
+```
+```javascript
+var code = fs.readFileSync("test.js", "utf8");
 
-  UglifyJS.minify("tst.js").code;
+UglifyJS.minify(code).code;
 // 'function funcName(a,n){}var globalVar;'
 
-  UglifyJS.minify("tst.js", { mangle: { reserved: ['firstLongName'] } }).code;
+UglifyJS.minify(code, { mangle: { reserved: ['firstLongName'] } }).code;
 // 'function funcName(firstLongName,a){}var globalVar;'
 
-  UglifyJS.minify("tst.js", { mangle: { toplevel: true } }).code;
+UglifyJS.minify(code, { mangle: { toplevel: true } }).code;
 // 'function n(n,a){}var a;'
 ```
 

lib/ast.js

@@ -495,10 +495,10 @@ var AST_Finally = DEFNODE("Finally", null, {
     $documentation: "A `finally` node; only makes sense as part of a `try` statement"
 }, AST_Block);
 
-/* -----[ VAR/CONST ]----- */
+/* -----[ VAR ]----- */
 
 var AST_Definitions = DEFNODE("Definitions", "definitions", {
-    $documentation: "Base class for `var` or `const` nodes (variable declarations/initializations)",
+    $documentation: "Base class for `var` nodes (variable declarations/initializations)",
     $propdoc: {
         definitions: "[AST_VarDef*] array of variable definitions"
     },
@@ -516,14 +516,10 @@ var AST_Var = DEFNODE("Var", null, {
     $documentation: "A `var` statement"
 }, AST_Definitions);
 
-var AST_Const = DEFNODE("Const", null, {
-    $documentation: "A `const` statement"
-}, AST_Definitions);
-
 var AST_VarDef = DEFNODE("VarDef", "name value", {
     $documentation: "A variable declaration; only appears in a AST_Definitions node",
     $propdoc: {
-        name: "[AST_SymbolVar|AST_SymbolConst] name of the variable",
+        name: "[AST_SymbolVar] name of the variable",
         value: "[AST_Node?] initializer, or null of there's no initializer"
     },
     _walk: function(visitor) {
@@ -689,8 +685,8 @@ var AST_Object = DEFNODE("Object", "properties", {
 var AST_ObjectProperty = DEFNODE("ObjectProperty", "key value", {
     $documentation: "Base class for literal object properties",
     $propdoc: {
-        key: "[string] the property name converted to a string for ObjectKeyVal.  For setters and getters this is an arbitrary AST_Node.",
-        value: "[AST_Node] property value.  For setters and getters this is an AST_Function."
+        key: "[string] the property name converted to a string for ObjectKeyVal.  For setters and getters this is an AST_SymbolAccessor.",
+        value: "[AST_Node] property value.  For setters and getters this is an AST_Accessor."
     },
     _walk: function(visitor) {
         return visitor._visit(this, function(){
@@ -728,17 +724,13 @@ var AST_SymbolAccessor = DEFNODE("SymbolAccessor", null, {
 }, AST_Symbol);
 
 var AST_SymbolDeclaration = DEFNODE("SymbolDeclaration", "init", {
-    $documentation: "A declaration symbol (symbol in var/const, function name or argument, symbol in catch)",
+    $documentation: "A declaration symbol (symbol in var, function name or argument, symbol in catch)",
 }, AST_Symbol);
 
 var AST_SymbolVar = DEFNODE("SymbolVar", null, {
     $documentation: "Symbol defining a variable",
 }, AST_SymbolDeclaration);
 
-var AST_SymbolConst = DEFNODE("SymbolConst", null, {
-    $documentation: "A constant declaration"
-}, AST_SymbolDeclaration);
-
 var AST_SymbolFunarg = DEFNODE("SymbolFunarg", null, {
     $documentation: "Symbol naming a function argument",
 }, AST_SymbolVar);

lib/compress.js

@@ -354,16 +354,27 @@ merge(Compressor.prototype, {
                         // So existing transformation rules can work on them.
                         node.argnames.forEach(function(arg, i) {
                             var d = arg.definition();
+                            if (!node.uses_arguments && d.fixed === undefined) {
                                 d.fixed = function() {
                                     return iife.args[i] || make_node(AST_Undefined, iife);
                                 };
                                 mark(d, true);
+                            } else {
+                                d.fixed = false;
+                            }
                         });
                     }
                     descend();
                     pop();
                     return true;
                 }
+                if (node instanceof AST_Accessor) {
+                    var save_ids = safe_ids;
+                    safe_ids = Object.create(null);
+                    descend();
+                    safe_ids = save_ids;
+                    return true;
+                }
                 if (node instanceof AST_Binary
                     && (node.operator == "&&" || node.operator == "||")) {
                     node.left.walk(tw);
@@ -475,8 +486,7 @@ merge(Compressor.prototype, {
             if (def.fixed === false) return false;
             if (def.fixed != null && (!value || def.references.length > 0)) return false;
             return !def.orig.some(function(sym) {
-                return sym instanceof AST_SymbolConst
-                    || sym instanceof AST_SymbolDefun
+                return sym instanceof AST_SymbolDefun
                     || sym instanceof AST_SymbolLambda;
             });
         }
@@ -491,7 +501,9 @@ merge(Compressor.prototype, {
 
         function reset_def(def) {
             def.escaped = false;
-            if (!def.global || def.orig[0] instanceof AST_SymbolConst || compressor.toplevel(def)) {
+            if (def.scope.uses_eval) {
+                def.fixed = false;
+            } else if (!def.global || compressor.toplevel(def)) {
                 def.fixed = undefined;
             } else {
                 def.fixed = false;
@@ -1215,12 +1227,12 @@ merge(Compressor.prototype, {
                 && !node.expression.has_side_effects(compressor);
     }
 
-    // may_eq_null()
-    // returns true if this node may evaluate to null or undefined
+    // may_throw_on_access()
+    // returns true if this node may be null, undefined or contain `AST_Accessor`
     (function(def) {
-        AST_Node.DEFMETHOD("may_eq_null", function(compressor) {
+        AST_Node.DEFMETHOD("may_throw_on_access", function(compressor) {
             var pure_getters = compressor.option("pure_getters");
-            return !pure_getters || this._eq_null(pure_getters);
+            return !pure_getters || this._throw_on_access(pure_getters);
         });
 
         function is_strict(pure_getters) {
@@ -1232,7 +1244,12 @@ merge(Compressor.prototype, {
         def(AST_Undefined, return_true);
         def(AST_Constant, return_false);
         def(AST_Array, return_false);
-        def(AST_Object, return_false);
+        def(AST_Object, function(pure_getters) {
+            if (!is_strict(pure_getters)) return false;
+            for (var i = this.properties.length; --i >=0;)
+                if (this.properties[i].value instanceof AST_Accessor) return true;
+            return false;
+        });
         def(AST_Function, return_false);
         def(AST_UnaryPostfix, return_false);
         def(AST_UnaryPrefix, function() {
@@ -1241,33 +1258,33 @@ merge(Compressor.prototype, {
         def(AST_Binary, function(pure_getters) {
             switch (this.operator) {
               case "&&":
-                return this.left._eq_null(pure_getters);
+                return this.left._throw_on_access(pure_getters);
               case "||":
-                return this.left._eq_null(pure_getters)
-                    && this.right._eq_null(pure_getters);
+                return this.left._throw_on_access(pure_getters)
+                    && this.right._throw_on_access(pure_getters);
               default:
                 return false;
             }
         })
         def(AST_Assign, function(pure_getters) {
             return this.operator == "="
-                && this.right._eq_null(pure_getters);
+                && this.right._throw_on_access(pure_getters);
         })
         def(AST_Conditional, function(pure_getters) {
-            return this.consequent._eq_null(pure_getters)
-                || this.alternative._eq_null(pure_getters);
+            return this.consequent._throw_on_access(pure_getters)
+                || this.alternative._throw_on_access(pure_getters);
         })
         def(AST_Sequence, function(pure_getters) {
-            return this.expressions[this.expressions.length - 1]._eq_null(pure_getters);
+            return this.expressions[this.expressions.length - 1]._throw_on_access(pure_getters);
         });
         def(AST_SymbolRef, function(pure_getters) {
             if (this.is_undefined) return true;
             if (!is_strict(pure_getters)) return false;
             var fixed = this.fixed_value();
-            return !fixed || fixed._eq_null(pure_getters);
+            return !fixed || fixed._throw_on_access(pure_getters);
         });
     })(function(node, func) {
-        node.DEFMETHOD("_eq_null", func);
+        node.DEFMETHOD("_throw_on_access", func);
     });
 
     /* -----[ boolean/negation helpers ]----- */
@@ -1808,11 +1825,11 @@ merge(Compressor.prototype, {
             return any(this.elements, compressor);
         });
         def(AST_Dot, function(compressor){
-            return this.expression.may_eq_null(compressor)
+            return this.expression.may_throw_on_access(compressor)
                 || this.expression.has_side_effects(compressor);
         });
         def(AST_Sub, function(compressor){
-            return this.expression.may_eq_null(compressor)
+            return this.expression.may_throw_on_access(compressor)
                 || this.expression.has_side_effects(compressor)
                 || this.property.has_side_effects(compressor);
         });
@@ -2365,6 +2382,7 @@ merge(Compressor.prototype, {
             var args = trim(this.args, compressor, first_in_statement);
             return args && make_sequence(this, args);
         });
+        def(AST_Accessor, return_null);
         def(AST_Function, return_null);
         def(AST_Binary, function(compressor, first_in_statement){
             var right = this.right.drop_side_effect_free(compressor);
@@ -2432,11 +2450,11 @@ merge(Compressor.prototype, {
             return values && make_sequence(this, values);
         });
         def(AST_Dot, function(compressor, first_in_statement){
-            if (this.expression.may_eq_null(compressor)) return this;
+            if (this.expression.may_throw_on_access(compressor)) return this;
             return this.expression.drop_side_effect_free(compressor, first_in_statement);
         });
         def(AST_Sub, function(compressor, first_in_statement){
-            if (this.expression.may_eq_null(compressor)) return this;
+            if (this.expression.may_throw_on_access(compressor)) return this;
             var expression = this.expression.drop_side_effect_free(compressor, first_in_statement);
             if (!expression) return this.property.drop_side_effect_free(compressor, first_in_statement);
             var property = this.property.drop_side_effect_free(compressor);

lib/mozilla-ast.js

@@ -111,23 +111,19 @@
         },
         Property: function(M) {
             var key = M.key;
-            var name = key.type == "Identifier" ? key.name : key.value;
             var args = {
                 start    : my_start_token(key),
                 end      : my_end_token(M.value),
-                key      : name,
+                key      : key.type == "Identifier" ? key.name : key.value,
                 value    : from_moz(M.value)
             };
-            switch (M.kind) {
-              case "init":
-                return new AST_ObjectKeyVal(args);
-              case "set":
-                args.value.name = from_moz(key);
-                return new AST_ObjectSetter(args);
-              case "get":
-                args.value.name = from_moz(key);
-                return new AST_ObjectGetter(args);
-            }
+            if (M.kind == "init") return new AST_ObjectKeyVal(args);
+            args.key = new AST_SymbolAccessor({
+                name: args.key
+            });
+            args.value = new AST_Accessor(args.value);
+            if (M.kind == "get") return new AST_ObjectGetter(args);
+            if (M.kind == "set") return new AST_ObjectSetter(args);
         },
         ArrayExpression: function(M) {
             return new AST_Array({
@@ -172,7 +168,7 @@
             });
         },
         VariableDeclaration: function(M) {
-            return new (M.kind === "const" ? AST_Const : AST_Var)({
+            return new AST_Var({
                 start       : my_start_token(M),
                 end         : my_end_token(M),
                 definitions : M.declarations.map(from_moz)
@@ -208,7 +204,7 @@
         Identifier: function(M) {
             var p = FROM_MOZ_STACK[FROM_MOZ_STACK.length - 2];
             return new (  p.type == "LabeledStatement" ? AST_Label
-                        : p.type == "VariableDeclarator" && p.id === M ? (p.kind == "const" ? AST_SymbolConst : AST_SymbolVar)
+                        : p.type == "VariableDeclarator" && p.id === M ? AST_SymbolVar
                         : p.type == "FunctionExpression" ? (p.id === M ? AST_SymbolLambda : AST_SymbolFunarg)
                         : p.type == "FunctionDeclaration" ? (p.id === M ? AST_SymbolDefun : AST_SymbolFunarg)
                         : p.type == "CatchClause" ? AST_SymbolCatch
@@ -260,10 +256,7 @@
     map("CallExpression", AST_Call, "callee>expression, arguments@args");
 
     def_to_moz(AST_Toplevel, function To_Moz_Program(M) {
-        return {
-            type: "Program",
-            body: M.body.map(to_moz)
-        };
+        return to_moz_scope("Program", M);
     });
 
     def_to_moz(AST_Defun, function To_Moz_FunctionDeclaration(M) {
@@ -271,7 +264,7 @@
             type: "FunctionDeclaration",
             id: to_moz(M.name),
             params: M.argnames.map(to_moz),
-            body: to_moz_block(M)
+            body: to_moz_scope("BlockStatement", M)
         }
     });
 
@@ -280,7 +273,7 @@
             type: "FunctionExpression",
             id: to_moz(M.name),
             params: M.argnames.map(to_moz),
-            body: to_moz_block(M)
+            body: to_moz_scope("BlockStatement", M)
         }
     });
 
@@ -331,7 +324,7 @@
     def_to_moz(AST_Definitions, function To_Moz_VariableDeclaration(M) {
         return {
             type: "VariableDeclaration",
-            kind: M instanceof AST_Const ? "const" : "var",
+            kind: "var",
             declarations: M.definitions.map(to_moz)
         };
     });
@@ -386,11 +379,10 @@
     });
 
     def_to_moz(AST_ObjectProperty, function To_Moz_Property(M) {
-        var key = (
-            is_identifier(M.key)
-            ? {type: "Identifier", name: M.key}
-            : {type: "Literal", value: M.key}
-        );
+        var key = {
+            type: "Literal",
+            value: M.key instanceof AST_SymbolAccessor ? M.key.name : M.key
+        };
         var kind;
         if (M instanceof AST_ObjectKeyVal) {
             kind = "init";
@@ -551,8 +543,8 @@
         moz_to_me = new Function("U2", "my_start_token", "my_end_token", "from_moz", "return(" + moz_to_me + ")")(
             exports, my_start_token, my_end_token, from_moz
         );
-        me_to_moz = new Function("to_moz", "to_moz_block", "return(" + me_to_moz + ")")(
-            to_moz, to_moz_block
+        me_to_moz = new Function("to_moz", "to_moz_block", "to_moz_scope", "return(" + me_to_moz + ")")(
+            to_moz, to_moz_block, to_moz_scope
         );
         MOZ_TO_ME[moztype] = moz_to_me;
         def_to_moz(mytype, me_to_moz);
@@ -610,4 +602,14 @@
         };
     };
 
+    function to_moz_scope(type, node) {
+        var body = node.body.map(to_moz);
+        if (node.body[0] instanceof AST_SimpleStatement && node.body[0].body instanceof AST_String) {
+            body.unshift(to_moz(new AST_EmptyStatement(node.body[0])));
+        }
+        return {
+            type: type,
+            body: body
+        };
+    };
 })();

lib/output.js

@@ -1033,9 +1033,6 @@ function OutputStream(options) {
     DEFPRINT(AST_Var, function(self, output){
         self._do_print(output, "var");
     });
-    DEFPRINT(AST_Const, function(self, output){
-        self._do_print(output, "const");
-    });
 
     function parenthesize_for_noin(node, output, noin) {
         if (!noin) node.print(output);

lib/parse.js

@@ -805,24 +805,20 @@ function parse($TEXT, options) {
         handle_regexp();
         switch (S.token.type) {
           case "string":
-            var dir = false;
-            if (S.in_directives === true) {
-                if ((is_token(peek(), "punc", ";") || peek().nlb) && S.token.raw.indexOf("\\") === -1) {
+            if (S.in_directives) {
+                tmp = peek();
+                if (S.token.raw.indexOf("\\") == -1
+                    && (tmp.nlb
+                        || is_token(tmp, "eof")
+                        || is_token(tmp, "punc", ";")
+                        || is_token(tmp, "punc", "}"))) {
                     S.input.add_directive(S.token.value);
                 } else {
                     S.in_directives = false;
                 }
             }
             var dir = S.in_directives, stat = simple_statement();
-            if (dir) {
-                return new AST_Directive({
-                    start : stat.body.start,
-                    end   : stat.body.end,
-                    quote : stat.body.quote,
-                    value : stat.body.value,
-                });
-            }
-            return stat;
+            return dir ? new AST_Directive(stat.body) : stat;
           case "num":
           case "regexp":
           case "operator":
@@ -916,9 +912,6 @@ function parse($TEXT, options) {
               case "var":
                 return tmp = var_(), semicolon(), tmp;
 
-              case "const":
-                return tmp = const_(), semicolon(), tmp;
-
               case "with":
                 if (S.input.has_directive("use strict")) {
                     croak("Strict mode may not include a with statement");
@@ -1153,16 +1146,13 @@ function parse($TEXT, options) {
         });
     };
 
-    function vardefs(no_in, in_const) {
+    function vardefs(no_in) {
         var a = [];
         for (;;) {
             a.push(new AST_VarDef({
                 start : S.token,
-                name  : as_symbol(in_const ? AST_SymbolConst : AST_SymbolVar),
-                value : is("operator", "=")
-                    ? (next(), expression(false, no_in))
-                    : in_const && S.input.has_directive("use strict")
-                        ? croak("Missing initializer in const declaration") : null,
+                name  : as_symbol(AST_SymbolVar),
+                value : is("operator", "=") ? (next(), expression(false, no_in)) : null,
                 end   : prev()
             }));
             if (!is("punc", ","))
@@ -1175,15 +1165,7 @@ function parse($TEXT, options) {
     var var_ = function(no_in) {
         return new AST_Var({
             start       : prev(),
-            definitions : vardefs(no_in, false),
-            end         : prev()
-        });
-    };
-
-    var const_ = function() {
-        return new AST_Const({
-            start       : prev(),
-            definitions : vardefs(false, true),
+            definitions : vardefs(no_in),
             end         : prev()
         });
     };
@@ -1324,10 +1306,15 @@ function parse($TEXT, options) {
             var type = start.type;
             var name = as_property_name();
             if (type == "name" && !is("punc", ":")) {
+                var key = new AST_SymbolAccessor({
+                    start: S.token,
+                    name: as_property_name(),
+                    end: prev()
+                });
                 if (name == "get") {
                     a.push(new AST_ObjectGetter({
                         start : start,
-                        key   : as_atom_node(),
+                        key   : key,
                         value : create_accessor(),
                         end   : prev()
                     }));
@@ -1336,7 +1323,7 @@ function parse($TEXT, options) {
                 if (name == "set") {
                     a.push(new AST_ObjectSetter({
                         start : start,
-                        key   : as_atom_node(),
+                        key   : key,
                         value : create_accessor(),
                         end   : prev()
                     }));

lib/scope.js

@@ -156,8 +156,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
             // later.
             (node.scope = defun.parent_scope).def_function(node);
         }
-        else if (node instanceof AST_SymbolVar
-            || node instanceof AST_SymbolConst) {
+        else if (node instanceof AST_SymbolVar) {
             defun.def_variable(node);
             if (defun !== scope) {
                 node.mark_enclosed(options);
@@ -268,7 +267,7 @@ AST_Scope.DEFMETHOD("init_scope_vars", function(parent_scope){
 AST_Lambda.DEFMETHOD("init_scope_vars", function(){
     AST_Scope.prototype.init_scope_vars.apply(this, arguments);
     this.uses_arguments = false;
-    this.def_variable(new AST_SymbolConst({
+    this.def_variable(new AST_SymbolFunarg({
         name: "arguments",
         start: this.start,
         end: this.end
@@ -361,11 +360,6 @@ AST_Symbol.DEFMETHOD("unmangleable", function(options){
     return this.definition().unmangleable(options);
 });
 
-// property accessors are not mangleable
-AST_SymbolAccessor.DEFMETHOD("unmangleable", function(){
-    return true;
-});
-
 // labels are always mangleable
 AST_Label.DEFMETHOD("unmangleable", function(){
     return false;
@@ -491,8 +485,6 @@ AST_Toplevel.DEFMETHOD("compute_char_frequency", function(options){
         }
         else if (node instanceof AST_Var)
             base54.consider("var");
-        else if (node instanceof AST_Const)
-            base54.consider("const");
         else if (node instanceof AST_Lambda)
             base54.consider("function");
         else if (node instanceof AST_For)

package.json

@@ -4,7 +4,7 @@
   "homepage": "http://lisperator.net/uglifyjs",
   "author": "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)",
   "license": "BSD-2-Clause",
-  "version": "3.0.3",
+  "version": "3.0.5",
   "engines": {
     "node": ">=0.8.0"
   },
@@ -33,20 +33,9 @@
     "source-map": "~0.5.1"
   },
   "devDependencies": {
-    "acorn": "~0.6.0",
-    "escodegen": "~1.3.3",
-    "esfuzz": "~0.3.1",
-    "estraverse": "~1.5.1",
+    "acorn": "~5.0.3",
     "mocha": "~2.3.4"
   },
-  "optionalDependencies": {
-    "uglify-to-browserify": "~1.0.0"
-  },
-  "browserify": {
-    "transform": [
-      "uglify-to-browserify"
-    ]
-  },
   "scripts": {
     "test": "node test/run-tests.js"
   },

test/compress/collapse_vars.js

@@ -583,8 +583,8 @@ collapse_vars_assignment: {
             return a = a;
         }
         function f1(c) {
-            const a = 3 / c;
-            const b = 1 - a;
+            var a = 3 / c;
+            var b = 1 - a;
             return b;
         }
         function f2(c) {
@@ -724,10 +724,10 @@ collapse_vars_misc1: {
             return t;
         }
         function f1(x) { var y = 5 - x; return y; }
-        function f2(x) { const z = foo(), y = z / (5 - x); return y; }
+        function f2(x) { var z = foo(), y = z / (5 - x); return y; }
         function f3(x) { var z = foo(), y = (5 - x) / z; return y; }
         function f4(x) { var z = foo(), y = (5 - u) / z; return y; }
-        function f5(x) { const z = foo(), y = (5 - window.x) / z; return y; }
+        function f5(x) { var z = foo(), y = (5 - window.x) / z; return y; }
         function f6() { var b = window.a * window.z; return b && zap(); }
         function f7() { var b = window.a * window.z; return b + b; }
         function f8() { var b = window.a * window.z; var c = b + 5; return b + c; }
@@ -744,7 +744,7 @@ collapse_vars_misc1: {
         function f2(x) { return foo() / (5 - x) }
         function f3(x) { return (5 - x) / foo() }
         function f4(x) { var z = foo(); return (5 - u) / z }
-        function f5(x) { const z = foo(); return (5 - window.x) / z }
+        function f5(x) { var z = foo(); return (5 - window.x) / z }
         function f6() { return window.a * window.z && zap() }
         function f7() { var b = window.a * window.z; return b + b }
         function f8() { var b = window.a * window.z; return b + (b + 5) }

test/compress/const.js

@@ -1,166 +0,0 @@
-issue_1191: {
-    options = {
-        evaluate      : true,
-        booleans      : true,
-        comparisons   : true,
-        dead_code     : true,
-        conditionals  : true,
-        side_effects  : true,
-        unused        : true,
-        hoist_funs    : true,
-        if_return     : true,
-        join_vars     : true,
-        sequences     : false,
-        collapse_vars : false,
-        reduce_vars   : true,
-    }
-    input: {
-        function foo(rot) {
-            const rotTol = 5;
-            if (rot < -rotTol || rot > rotTol)
-                bar();
-            baz();
-        }
-    }
-    expect: {
-        function foo(rot) {
-            (rot < -5 || rot > 5) && bar();
-            baz();
-        }
-    }
-}
-
-issue_1194: {
-    options = {
-        evaluate      : true,
-        booleans      : true,
-        comparisons   : true,
-        dead_code     : true,
-        conditionals  : true,
-        side_effects  : true,
-        unused        : true,
-        hoist_funs    : true,
-        if_return     : true,
-        join_vars     : true,
-        sequences     : false,
-        collapse_vars : false,
-        reduce_vars   : true,
-    }
-    input: {
-        function f1() {const a = "X"; return a + a;}
-        function f2() {const aa = "X"; return aa + aa;}
-        function f3() {const aaa = "X"; return aaa + aaa;}
-    }
-    expect: {
-        function f1(){return"XX"}
-        function f2(){return"XX"}
-        function f3(){return"XX"}
-    }
-}
-
-issue_1396: {
-    options = {
-        evaluate      : true,
-        booleans      : true,
-        comparisons   : true,
-        dead_code     : true,
-        conditionals  : true,
-        side_effects  : true,
-        unused        : true,
-        hoist_funs    : true,
-        if_return     : true,
-        join_vars     : true,
-        sequences     : false,
-        collapse_vars : false,
-        reduce_vars   : true,
-    }
-    input: {
-        function foo(a) {
-            const VALUE = 1;
-            console.log(2 | VALUE);
-            console.log(VALUE + 1);
-            console.log(VALUE);
-            console.log(a & VALUE);
-        }
-        function bar() {
-            const s = "01234567890123456789";
-            console.log(s + s + s + s + s);
-
-            const CONSTANT = "abc";
-            console.log(CONSTANT + CONSTANT + CONSTANT + CONSTANT + CONSTANT);
-        }
-    }
-    expect: {
-        function foo(a) {
-            console.log(3);
-            console.log(2);
-            console.log(1);
-            console.log(1 & a);
-        }
-        function bar() {
-            const s = "01234567890123456789";
-            console.log(s + s + s + s + s);
-
-            console.log("abcabcabcabcabc");
-        }
-    }
-}
-
-unused_regexp_literal: {
-    options = {
-        evaluate      : true,
-        booleans      : true,
-        comparisons   : true,
-        dead_code     : true,
-        conditionals  : true,
-        side_effects  : true,
-        unused        : true,
-        hoist_funs    : true,
-        if_return     : true,
-        join_vars     : true,
-        sequences     : false,
-        collapse_vars : false,
-    }
-    input: {
-        function f(){ var a = /b/; }
-    }
-    expect: {
-        function f(){}
-    }
-}
-
-regexp_literal_not_const: {
-    options = {
-        evaluate      : true,
-        booleans      : true,
-        comparisons   : true,
-        dead_code     : true,
-        conditionals  : true,
-        side_effects  : true,
-        unused        : true,
-        hoist_funs    : true,
-        if_return     : true,
-        join_vars     : true,
-        sequences     : false,
-        collapse_vars : false,
-        reduce_vars   : true,
-    }
-    input: {
-        (function(){
-            var result;
-            const s = 'acdabcdeabbb';
-            const REGEXP_LITERAL = /ab*/g;
-            while (result = REGEXP_LITERAL.exec(s)) {
-                console.log(result[0]);
-            }
-        })();
-    }
-    expect: {
-        (function() {
-            var result;
-            const REGEXP_LITERAL = /ab*/g;
-            while (result = REGEXP_LITERAL.exec("acdabcdeabbb")) console.log(result[0]);
-        })();
-    }
-    expect_stdout: true
-}

test/compress/dead-code.js

@@ -90,131 +90,6 @@ dead_code_constant_boolean_should_warn_more: {
     expect_stdout: true
 }
 
-dead_code_const_declaration: {
-    options = {
-        dead_code    : true,
-        loops        : true,
-        booleans     : true,
-        conditionals : true,
-        evaluate     : true,
-        reduce_vars  : true,
-    };
-    input: {
-        var unused;
-        const CONST_FOO = false;
-        if (CONST_FOO) {
-            console.log("unreachable");
-            var moo;
-            function bar() {}
-        }
-    }
-    expect: {
-        var unused;
-        const CONST_FOO = !1;
-        var moo;
-        function bar() {}
-    }
-    expect_stdout: true
-}
-
-dead_code_const_annotation: {
-    options = {
-        dead_code    : true,
-        loops        : true,
-        booleans     : true,
-        conditionals : true,
-        evaluate     : true,
-        reduce_vars  : true,
-        toplevel     : true,
-    };
-    input: {
-        var unused;
-        /** @const */ var CONST_FOO_ANN = false;
-        if (CONST_FOO_ANN) {
-            console.log("unreachable");
-            var moo;
-            function bar() {}
-        }
-    }
-    expect: {
-        var unused;
-        var CONST_FOO_ANN = !1;
-        var moo;
-        function bar() {}
-    }
-    expect_stdout: true
-}
-
-dead_code_const_annotation_regex: {
-    options = {
-        dead_code    : true,
-        loops        : true,
-        booleans     : true,
-        conditionals : true,
-        evaluate     : true
-    };
-    input: {
-        var unused;
-        // @constraint this shouldn't be a constant
-        var CONST_FOO_ANN = false;
-        if (CONST_FOO_ANN) {
-            console.log("reachable");
-        }
-    }
-    expect: {
-        var unused;
-        var CONST_FOO_ANN = !1;
-        CONST_FOO_ANN && console.log('reachable');
-    }
-    expect_stdout: true
-}
-
-dead_code_const_annotation_complex_scope: {
-    options = {
-        dead_code    : true,
-        loops        : true,
-        booleans     : true,
-        conditionals : true,
-        evaluate     : true,
-        reduce_vars  : true,
-        toplevel     : true,
-    };
-    input: {
-        var unused_var;
-        /** @const */ var test = 'test';
-        // @const
-        var CONST_FOO_ANN = false;
-        var unused_var_2;
-        if (CONST_FOO_ANN) {
-            console.log("unreachable");
-            var moo;
-            function bar() {}
-        }
-        if (test === 'test') {
-            var beef = 'good';
-            /** @const */ var meat = 'beef';
-            var pork = 'bad';
-            if (meat === 'pork') {
-                console.log('also unreachable');
-            } else if (pork === 'good') {
-                console.log('reached, not const');
-            }
-        }
-    }
-    expect: {
-        var unused_var;
-        var test = 'test';
-        var CONST_FOO_ANN = !1;
-        var unused_var_2;
-        var moo;
-        function bar() {}
-        var beef = 'good';
-        var meat = 'beef';
-        var pork = 'bad';
-    }
-    expect_stdout: true
-}
-
 try_catch_finally: {
     options = {
         conditionals: true,
@@ -256,3 +131,19 @@ try_catch_finally: {
         "1",
     ]
 }
+
+accessor: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        ({
+            get a() {},
+            set a(v){
+                this.b = 2;
+            },
+            b: 1
+        });
+    }
+    expect: {}
+}

test/compress/drop-unused.js

@@ -649,37 +649,6 @@ drop_value: {
     }
 }
 
-const_assign: {
-    options = {
-        evaluate: true,
-        reduce_vars: true,
-        unused: true,
-    }
-    input: {
-        function f() {
-            const b = 2;
-            return 1 + b;
-        }
-
-        function g() {
-            const b = 2;
-            b = 3;
-            return 1 + b;
-        }
-    }
-    expect: {
-        function f() {
-            return 3;
-        }
-
-        function g() {
-            const b = 2;
-            b = 3;
-            return 1 + b;
-        }
-    }
-}
-
 issue_1539: {
     options = {
         cascade: true,
@@ -816,10 +785,6 @@ issue_1709: {
                 var x = 1;
                 return x;
             }(),
-            function y() {
-                const y = 2;
-                return y;
-            }(),
             function z() {
                 function z() {}
                 return z;
@@ -832,10 +797,6 @@ issue_1709: {
                 var x = 1;
                 return x;
             }(),
-            function() {
-                const y = 2;
-                return y;
-            }(),
             function() {
                 function z() {}
                 return z;

test/compress/evaluate.js

@@ -645,16 +645,17 @@ call_args: {
     options = {
         evaluate: true,
         reduce_vars: true,
+        toplevel: true,
     }
     input: {
-        const a = 1;
+        var a = 1;
         console.log(a);
         +function(a) {
             return a;
         }(a);
     }
     expect: {
-        const a = 1;
+        var a = 1;
         console.log(1);
         +(1, 1);
     }
@@ -666,17 +667,17 @@ call_args_drop_param: {
         evaluate: true,
         keep_fargs: false,
         reduce_vars: true,
+        toplevel: true,
         unused: true,
     }
     input: {
-        const a = 1;
+        var a = 1;
         console.log(a);
         +function(a) {
             return a;
         }(a, b);
     }
     expect: {
-        const a = 1;
         console.log(1);
         +(b, 1);
     }

test/compress/global_defs.js

@@ -120,7 +120,7 @@ mixed: {
         properties: true,
     }
     input: {
-        const FOO = { BAR: 0 };
+        var FOO = { BAR: 0 };
         console.log(FOO.BAR);
         console.log(++CONFIG.DEBUG);
         console.log(++CONFIG.VALUE);
@@ -130,7 +130,7 @@ mixed: {
         console.log(CONFIG);
     }
     expect: {
-        const FOO = { BAR: 0 };
+        var FOO = { BAR: 0 };
         console.log("moo");
         console.log(++CONFIG.DEBUG);
         console.log(++CONFIG.VALUE);

test/compress/issue-1041.js

@@ -1,16 +1,3 @@
-const_declaration: {
-    options = {
-        evaluate: true
-    };
-
-    input: {
-        const goog = goog || {};
-    }
-    expect: {
-        const goog = goog || {};
-    }
-}
-
 const_pragma: {
     options = {
         evaluate: true,

test/compress/issue-1588.js

@@ -85,15 +85,3 @@ unsafe_undefined: {
     }
     expect_stdout: true
 }
-
-runtime_error: {
-    input: {
-        const a = 1;
-        console.log(a++);
-    }
-    expect: {
-        const a = 1;
-        console.log(a++);
-    }
-    expect_stdout: true
-}

test/compress/issue-208.js

@@ -38,7 +38,7 @@ mixed: {
         }
     }
     input: {
-        const ENV = 3;
+        var ENV = 3;
         var FOO = 4;
         f(ENV * 10);
         --FOO;
@@ -49,7 +49,7 @@ mixed: {
         x = DEBUG;
     }
     expect: {
-        const ENV = 3;
+        var ENV = 3;
         var FOO = 4;
         f(10);
         --FOO;
@@ -60,7 +60,7 @@ mixed: {
         x = 0;
     }
     expect_warnings: [
-        'WARN: global_defs ENV redefined [test/compress/issue-208.js:41,14]',
+        'WARN: global_defs ENV redefined [test/compress/issue-208.js:41,12]',
         'WARN: global_defs FOO redefined [test/compress/issue-208.js:42,12]',
         'WARN: global_defs FOO redefined [test/compress/issue-208.js:44,10]',
         'WARN: global_defs DEBUG redefined [test/compress/issue-208.js:45,8]',

test/compress/loops.js

@@ -146,50 +146,6 @@ parse_do_while_without_semicolon: {
     }
 }
 
-
-keep_collapse_const_in_own_block_scope: {
-    options = {
-        join_vars: true,
-        loops: true
-    }
-    input: {
-        var i=2;
-        const c=5;
-        while(i--)
-            console.log(i);
-        console.log(c);
-    }
-    expect: {
-        var i=2;
-        const c=5;
-        for(;i--;)
-            console.log(i);
-        console.log(c);
-    }
-    expect_stdout: true
-}
-
-keep_collapse_const_in_own_block_scope_2: {
-    options = {
-        join_vars: true,
-        loops: true
-    }
-    input: {
-        const c=5;
-        var i=2; // Moves to loop, while it did not in previous test
-        while(i--)
-            console.log(i);
-        console.log(c);
-    }
-    expect: {
-        const c=5;
-        for(var i=2;i--;)
-            console.log(i);
-        console.log(c);
-    }
-    expect_stdout: true
-}
-
 evaluate: {
     options = {
         loops: true,

test/compress/pure_getters.js

@@ -119,3 +119,62 @@ chained: {
         a.b.c;
     }
 }
+
+impure_getter_1: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        ({
+            get a() {
+                console.log(1);
+            },
+            b: 1
+        }).a;
+        ({
+            get a() {
+                console.log(1);
+            },
+            b: 1
+        }).b;
+    }
+    expect: {
+        ({
+            get a() {
+                console.log(1);
+            },
+            b: 1
+        }).a;
+        ({
+            get a() {
+                console.log(1);
+            },
+            b: 1
+        }).b;
+    }
+    expect_stdout: "1"
+}
+
+impure_getter_2: {
+    options = {
+        pure_getters: true,
+        side_effects: true,
+    }
+    input: {
+        // will produce incorrect output because getter is not pure
+        ({
+            get a() {
+                console.log(1);
+            },
+            b: 1
+        }).a;
+        ({
+            get a() {
+                console.log(1);
+            },
+            b: 1
+        }).b;
+    }
+    expect: {}
+}

test/compress/reduce_vars.js

@@ -41,20 +41,20 @@ reduce_vars: {
         var A = 1;
         (function() {
             console.log(-3);
-            console.log(-4);
+            console.log(A - 5);
         })();
         (function f1() {
             var a = 2;
-            console.log(-3);
+            console.log(a - 5);
             eval("console.log(a);");
         })();
         (function f2(eval) {
             var a = 2;
-            console.log(-3);
+            console.log(a - 5);
             eval("console.log(a);");
         })(eval);
         "yes";
-        console.log(2);
+        console.log(A + 1);
     }
     expect_stdout: true
 }
@@ -1749,7 +1749,10 @@ redefine_arguments_3: {
         console.log(function() {
             var arguments;
             return typeof arguments;
-        }(), "number", "undefined");
+        }(), "number", function(x) {
+            var arguments = x;
+            return typeof arguments;
+        }());
     }
     expect_stdout: "object number undefined"
 }
@@ -2187,10 +2190,11 @@ issue_1814_1: {
     options = {
         evaluate: true,
         reduce_vars: true,
+        toplevel: true,
         unused: true,
     }
     input: {
-        const a = 42;
+        var a = 42;
         !function() {
             var b = a;
             !function(a) {
@@ -2199,7 +2203,6 @@ issue_1814_1: {
         }();
     }
     expect: {
-        const a = 42;
         !function() {
             !function(a) {
                 console.log(a++, 42);
@@ -2213,10 +2216,11 @@ issue_1814_2: {
     options = {
         evaluate: true,
         reduce_vars: true,
+        toplevel: true,
         unused: true,
     }
     input: {
-        const a = "32";
+        var a = "32";
         !function() {
             var b = a + 1;
             !function(a) {
@@ -2225,7 +2229,6 @@ issue_1814_2: {
         }();
     }
     expect: {
-        const a = "32";
         !function() {
             !function(a) {
                 console.log(a++, "321");
@@ -2461,3 +2464,76 @@ issue_1865: {
     }
     expect_stdout: true
 }
+
+issue_1922_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(a) {
+            arguments[0] = 2;
+            return a;
+        }(1));
+    }
+    expect: {
+        console.log(function(a) {
+            arguments[0] = 2;
+            return a;
+        }(1));
+    }
+    expect_stdout: "2"
+}
+
+issue_1922_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            var a;
+            eval("a = 1");
+            return a;
+        }(1));
+    }
+    expect: {
+        console.log(function() {
+            var a;
+            eval("a = 1");
+            return a;
+        }(1));
+    }
+    expect_stdout: "1"
+}
+
+accessor: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 1;
+        console.log({
+            get a() {
+                a = 2;
+                return a;
+            },
+            b: 1
+        }.b, a);
+    }
+    expect: {
+        var a = 1;
+        console.log({
+            get a() {
+                a = 2;
+                return a;
+            },
+            b: 1
+        }.b, a);
+    }
+    expect_stdout: "1 1"
+}

test/input/invalid/const.js

@@ -1,8 +0,0 @@
-function f() {
-    const a;
-}
-
-function g() {
-    "use strict";
-    const a;
-}

test/mocha/accessorTokens-1492.js

@@ -16,7 +16,7 @@ describe("Accessor tokens", function() {
                 assert.equal(node.start.pos, 12);
                 assert.equal(node.end.endpos, 46);
 
-                assert(node.key instanceof UglifyJS.AST_SymbolRef);
+                assert(node.key instanceof UglifyJS.AST_SymbolAccessor);
                 assert.equal(node.key.start.pos, 16);
                 assert.equal(node.key.end.endpos, 22);
 

test/mocha/cli.js

@@ -379,21 +379,6 @@ describe("bin/uglifyjs", function () {
            done();
        });
     });
-    it("Should throw syntax error (const a)", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/const.js';
-
-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/const.js:7,11",
-               "    const a;",
-               "           ^",
-               "ERROR: Missing initializer in const declaration"
-           ].join("\n"));
-           done();
-       });
-    });
     it("Should throw syntax error (delete x)", function(done) {
        var command = uglifyjscmd + ' test/input/invalid/delete.js';
 

test/mocha/directives.js

@@ -351,18 +351,28 @@ describe("Directives", function() {
         var tests = [
             [
                 '"use strict";"use strict";"use strict";"use foo";"use strict";;"use sloppy";doSomething("foo");',
-                '"use strict";"use foo";doSomething("foo");'
+                '"use strict";"use foo";doSomething("foo");',
+                'function f(){ "use strict" }',
+                'function f(){ "use asm" }',
+                'function f(){ "use nondirective" }',
+                'function f(){ ;"use strict" }',
+                'function f(){ "use \n"; }',
             ],
             [
                  // Nothing gets optimised in the compressor because "use asm" is the first statement
                 '"use asm";"use\\x20strict";1+1;',
-                '"use asm";;"use strict";1+1;' // Yet, the parser noticed that "use strict" wasn't a directive
+                '"use asm";;"use strict";1+1;', // Yet, the parser noticed that "use strict" wasn't a directive
+                'function f(){"use strict"}',
+                'function f(){"use asm"}',
+                'function f(){"use nondirective"}',
+                'function f(){}',
+                'function f(){}',
             ]
         ];
 
         for (var i = 0; i < tests.length; i++) {
             assert.strictEqual(
-                uglify.minify(tests[i][0], {compress: {collapse_vars: true, side_effects: true}}).code,
+                uglify.minify(tests[i][0]).code,
                 tests[i][1],
                 tests[i][0]
             );

test/mocha/getter-setter.js

@@ -71,7 +71,7 @@ describe("Getters and setters", function() {
         var fail = function(data) {
             return function (e) {
                 return e instanceof UglifyJS.JS_Parse_Error &&
-                    e.message === "Invalid getter/setter name: " + data.operator;
+                    e.message === "Unexpected token: operator (" + data.operator + ")";
             };
         };
 

test/mozilla-ast.js

@@ -1,103 +1,73 @@
 // Testing UglifyJS <-> SpiderMonkey AST conversion
-// through generative testing.
+"use strict";
 
-var UglifyJS = require("./node"),
-    escodegen = require("escodegen"),
-    esfuzz = require("esfuzz"),
-    estraverse = require("estraverse"),
-    prefix = "\r    ";
-
-// Normalizes input AST for UglifyJS in order to get correct comparison.
-
-function normalizeInput(ast) {
-    return estraverse.replace(ast, {
-        enter: function(node, parent) {
-            switch (node.type) {
-                // Internally mark all the properties with semi-standard type "Property".
-                case "ObjectExpression":
-                    node.properties.forEach(function (property) {
-                        property.type = "Property";
-                    });
-                    break;
-
-                // Since UglifyJS doesn"t recognize different types of property keys,
-                // decision on SpiderMonkey node type is based on check whether key
-                // can be valid identifier or not - so we do in input AST.
-                case "Property":
-                    var key = node.key;
-                    if (key.type === "Literal" && typeof key.value === "string" && UglifyJS.is_identifier(key.value)) {
-                        node.key = {
-                            type: "Identifier",
-                            name: key.value
-                        };
-                    } else if (key.type === "Identifier" && !UglifyJS.is_identifier(key.name)) {
-                        node.key = {
-                            type: "Literal",
-                            value: key.name
-                        };
-                    }
-                    break;
-
-                // UglifyJS internally flattens all the expression sequences - either
-                // to one element (if sequence contains only one element) or flat list.
-                case "SequenceExpression":
-                    node.expressions = node.expressions.reduce(function flatten(list, expr) {
-                        return list.concat(expr.type === "SequenceExpression" ? expr.expressions.reduce(flatten, []) : [expr]);
-                    }, []);
-                    if (node.expressions.length === 1) {
-                        return node.expressions[0];
-                    }
-                    break;
-            }
-        }
-    });
-}
-
-module.exports = function(options) {
-    console.log("--- UglifyJS <-> Mozilla AST conversion");
-
-    for (var counter = 0; counter < options.iterations; counter++) {
-        process.stdout.write(prefix + counter + "/" + options.iterations);
-
-        var ast1 = normalizeInput(esfuzz.generate({
-            maxDepth: options.maxDepth
-        }));
-
-        var ast2 =
-            UglifyJS
-            .AST_Node
-            .from_mozilla_ast(ast1)
-            .to_mozilla_ast();
-
-        var astPair = [
-            {name: 'expected', value: ast1},
-            {name: 'actual', value: ast2}
-        ];
-
-        var jsPair = astPair.map(function(item) {
-            return {
-                name: item.name,
-                value: escodegen.generate(item.value)
-            }
-        });
-
-        if (jsPair[0].value !== jsPair[1].value) {
-            var fs = require("fs");
 var acorn = require("acorn");
+var ufuzz = require("./ufuzz");
+var UglifyJS = require("..");
 
-            fs.existsSync("tmp") || fs.mkdirSync("tmp");
-
-            jsPair.forEach(function (item) {
-                var fileName = "tmp/dump_" + item.name;
-                var ast = acorn.parse(item.value);
-                fs.writeFileSync(fileName + ".js", item.value);
-                fs.writeFileSync(fileName + ".json", JSON.stringify(ast, null, 2));
+function try_beautify(code) {
+    var beautified = UglifyJS.minify(code, {
+        compress: false,
+        mangle: false,
+        output: {
+            beautify: true,
+            bracketize: true
+        }
     });
-
-            process.stdout.write("\n");
-            throw new Error("Got different outputs, check out tmp/dump_*.{js,json} for codes and ASTs.");
+    if (beautified.error) {
+        console.log("// !!! beautify failed !!!");
+        console.log(beautified.error.stack);
+        console.log(code);
+    } else {
+        console.log("// (beautified)");
+        console.log(beautified.code);
     }
 }
 
-    process.stdout.write(prefix + "Probability of error is less than " + (100 / options.iterations) + "%, stopping.\n");
-};
+function test(original, estree, description) {
+    var transformed = UglifyJS.minify(UglifyJS.AST_Node.from_mozilla_ast(estree), {
+        compress: false,
+        mangle: false
+    });
+    if (transformed.error || original !== transformed.code) {
+        console.log("//=============================================================");
+        console.log("// !!!!!! Failed... round", round);
+        console.log("// original code");
+        try_beautify(original);
+        console.log();
+        console.log();
+        console.log("//-------------------------------------------------------------");
+        console.log("//", description);
+        if (transformed.error) {
+            console.log(transformed.error.stack);
+        } else {
+            try_beautify(transformed.code);
+        }
+        console.log("!!!!!! Failed... round", round);
+        process.exit(1);
+    }
+}
+
+var num_iterations = ufuzz.num_iterations;
+for (var round = 1; round <= num_iterations; round++) {
+    process.stdout.write(round + " of " + num_iterations + "\r");
+    var code = ufuzz.createTopLevelCode();
+    var uglified = UglifyJS.minify(code, {
+        compress: false,
+        mangle: false,
+        output: {
+            ast: true
+        }
+    });
+    test(uglified.code, uglified.ast.to_mozilla_ast(), "AST_Node.to_mozilla_ast()");
+    try {
+        test(uglified.code, acorn.parse(code), "acorn.parse()");
+    } catch (e) {
+        console.log("//=============================================================");
+        console.log("// acorn parser failed... round", round);
+        console.log(e);
+        console.log("// original code");
+        console.log(code);
+    }
+}
+console.log();

test/run-tests.js

@@ -23,12 +23,6 @@ mocha_tests();
 var run_sourcemaps_tests = require('./sourcemaps');
 run_sourcemaps_tests();
 
-var run_ast_conversion_tests = require("./mozilla-ast");
-
-run_ast_conversion_tests({
-    iterations: 1000
-});
-
 /* -----[ utils ]----- */
 
 function tmpl() {

test/sandbox.js

@@ -1,14 +1,16 @@
 var vm = require("vm");
 
-function safe_log(arg) {
+function safe_log(arg, level) {
     if (arg) switch (typeof arg) {
       case "function":
         return arg.toString();
       case "object":
         if (/Error$/.test(arg.name)) return arg.toString();
         arg.constructor.toString();
-        for (var key in arg) {
-            arg[key] = safe_log(arg[key]);
+        if (level--) for (var key in arg) {
+            if (!Object.getOwnPropertyDescriptor(arg, key).get) {
+                arg[key] = safe_log(arg[key], level);
+            }
         }
     }
     return arg;
@@ -48,7 +50,9 @@ exports.run_code = function(code) {
         ].join("\n"), {
             console: {
                 log: function() {
-                    return console.log.apply(console, [].map.call(arguments, safe_log));
+                    return console.log.apply(console, [].map.call(arguments, function(arg) {
+                        return safe_log(arg, 3);
+                    }));
                 }
             }
         }, { timeout: 5000 });

test/ufuzz.js

@@ -48,8 +48,9 @@ var STMT_COUNT_FROM_GLOBAL = true; // count statement depth from nearest functio
 var num_iterations = +process.argv[2] || 1/0;
 var verbose = false; // log every generated test
 var verbose_interval = false; // log every 100 generated tests
-var verbose_error = false;
 var use_strict = false;
+var catch_redef = require.main === module;
+var generate_directive = require.main === module;
 for (var i = 2; i < process.argv.length; ++i) {
     switch (process.argv[i]) {
       case '-v':
@@ -58,9 +59,6 @@ for (var i = 2; i < process.argv.length; ++i) {
       case '-V':
         verbose_interval = true;
         break;
-      case '-E':
-        verbose_error = true;
-        break;
       case '-t':
         MAX_GENERATED_TOPLEVELS_PER_RUN = +process.argv[++i];
         if (!MAX_GENERATED_TOPLEVELS_PER_RUN) throw new Error('Must generate at least one toplevel per run');
@@ -79,6 +77,12 @@ for (var i = 2; i < process.argv.length; ++i) {
         STMT_SECOND_LEVEL_OVERRIDE = STMT_ARG_TO_ID[name];
         if (!(STMT_SECOND_LEVEL_OVERRIDE >= 0)) throw new Error('Unknown statement name; use -? to get a list');
         break;
+      case '--no-catch-redef':
+        catch_redef = false;
+        break;
+      case '--no-directive':
+        generate_directive = false;
+        break;
       case '--use-strict':
         use_strict = true;
         break;
@@ -103,11 +107,12 @@ for (var i = 2; i < process.argv.length; ++i) {
         console.log('<number>: generate this many cases (if used must be first arg)');
         console.log('-v: print every generated test case');
         console.log('-V: print every 100th generated test case');
-        console.log('-E: print generated test case with runtime error');
         console.log('-t <int>: generate this many toplevels per run (more take longer)');
         console.log('-r <int>: maximum recursion depth for generator (higher takes longer)');
         console.log('-s1 <statement name>: force the first level statement to be this one (see list below)');
         console.log('-s2 <statement name>: force the second level statement to be this one (see list below)');
+        console.log('--no-catch-redef: do not redefine catch variables');
+        console.log('--no-directive: do not generate directives');
         console.log('--use-strict: generate "use strict"');
         console.log('--stmt-depth-from-func: reset statement depth counter at each function, counts from global otherwise');
         console.log('--only-stmt <statement names>: a comma delimited white list of statements that may be generated');
@@ -192,12 +197,33 @@ var ASSIGNMENTS = [
     '=',
     '=',
     '=',
+    '=',
+    '=',
+    '=',
+    '=',
+
+    '=',
+    '=',
+    '=',
+    '=',
+    '=',
+    '=',
+    '=',
+    '=',
+    '=',
+    '=',
 
-    '==',
-    '!=',
-    '===',
-    '!==',
     '+=',
+    '+=',
+    '+=',
+    '+=',
+    '+=',
+    '+=',
+    '+=',
+    '+=',
+    '+=',
+    '+=',
+
     '-=',
     '*=',
     '/=',
@@ -207,7 +233,8 @@ var ASSIGNMENTS = [
     '<<=',
     '>>=',
     '>>>=',
-    '%=' ];
+    '%=',
+];
 
 var UNARY_SAFE = [
     '+',
@@ -276,6 +303,7 @@ var TYPEOF_OUTCOMES = [
     'symbol',
     'crap' ];
 
+var unique_vars = [];
 var loops = 0;
 var funcs = 0;
 var labels = 10000;
@@ -290,6 +318,10 @@ function strictMode() {
 }
 
 function createTopLevelCode() {
+    VAR_NAMES.length = INITIAL_NAMES_LEN; // prune any previous names still in the list
+    unique_vars.length = 0;
+    loops = 0;
+    funcs = 0;
     return [
         strictMode(),
         'var a = 100, b = 10, c = 0;',
@@ -325,33 +357,36 @@ function createArgs() {
     return args.join(', ');
 }
 
+function filterDirective(s) {
+    if (!generate_directive && !s[1] && /\("/.test(s[2])) s[2] = ';' + s[2];
+    return s;
+}
+
 function createFunction(recurmax, inGlobal, noDecl, canThrow, stmtDepth) {
     if (--recurmax < 0) { return ';'; }
     if (!STMT_COUNT_FROM_GLOBAL) stmtDepth = 0;
     var func = funcs++;
     var namesLenBefore = VAR_NAMES.length;
-    var name = (inGlobal || rng(5) > 0) ? 'f' + func : createVarName(MANDATORY, noDecl);
-    if (name === 'a' || name === 'b' || name === 'c') name = 'f' + func; // quick hack to prevent assignment to func names of being called
-    var s = '';
+    var name;
+    if (inGlobal || rng(5) > 0) name = 'f' + func;
+    else {
+        unique_vars.push('a', 'b', 'c');
+        name = createVarName(MANDATORY, noDecl);
+        unique_vars.length -= 3;
+    }
+    var s = [
+        'function ' + name + '(' + createParams() + '){',
+        strictMode()
+    ];
     if (rng(5) === 0) {
         // functions with functions. lower the recursion to prevent a mess.
-        s = [
-            'function ' + name + '(' + createParams() + '){',
-            strictMode(),
-            createFunctions(rng(5) + 1, Math.ceil(recurmax * 0.7), NOT_GLOBAL, ANY_TYPE, canThrow, stmtDepth),
-            '}',
-            ''
-        ].join('\n');
+        s.push(createFunctions(rng(5) + 1, Math.ceil(recurmax * 0.7), NOT_GLOBAL, ANY_TYPE, canThrow, stmtDepth));
     } else {
         // functions with statements
-        s = [
-            'function ' + name + '(' + createParams() + '){',
-            strictMode(),
-            createStatements(3, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth),
-            '}',
-            ''
-        ].join('\n');
+        s.push(createStatements(3, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth));
     }
+    s.push('}', '');
+    s = filterDirective(s).join('\n');
 
     VAR_NAMES.length = namesLenBefore;
 
@@ -359,7 +394,6 @@ function createFunction(recurmax, inGlobal, noDecl, canThrow, stmtDepth) {
     // avoid "function statements" (decl inside statements)
     else if (inGlobal || rng(10) > 0) s += 'var ' + createVarName(MANDATORY) + ' = ' + name + '(' + createArgs() + ');';
 
-
     return s;
 }
 
@@ -406,7 +440,7 @@ function getLabel(label) {
     return label && " L" + label;
 }
 
-function createStatement(recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth) {
+function createStatement(recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth, target) {
     ++stmtDepth;
     var loop = ++loops;
     if (--recurmax < 0) {
@@ -414,10 +448,11 @@ function createStatement(recurmax, canThrow, canBreak, canContinue, cannotReturn
     }
 
     // allow to forcefully generate certain structures at first or second recursion level
-    var target = 0;
+    if (target === undefined) {
         if (stmtDepth === 1 && STMT_FIRST_LEVEL_OVERRIDE >= 0) target = STMT_FIRST_LEVEL_OVERRIDE;
         else if (stmtDepth === 2 && STMT_SECOND_LEVEL_OVERRIDE >= 0) target = STMT_SECOND_LEVEL_OVERRIDE;
         else target = STMTS_TO_USE[rng(STMTS_TO_USE.length)];
+    }
 
     switch (target) {
       case STMT_BLOCK:
@@ -460,20 +495,22 @@ function createStatement(recurmax, canThrow, canBreak, canContinue, cannotReturn
       case STMT_VAR:
         switch (rng(3)) {
           case 0:
+            unique_vars.push('c');
             var name = createVarName(MANDATORY);
-            if (name === 'c') name = 'a';
+            unique_vars.pop();
             return 'var ' + name + ';';
           case 1:
             // initializer can only have one expression
+            unique_vars.push('c');
             var name = createVarName(MANDATORY);
-            if (name === 'c') name = 'b';
+            unique_vars.pop();
             return 'var ' + name + ' = ' + createExpression(recurmax, NO_COMMA, stmtDepth, canThrow) + ';';
           default:
             // initializer can only have one expression
+            unique_vars.push('c');
             var n1 = createVarName(MANDATORY);
-            if (n1 === 'c') n1 = 'b';
             var n2 = createVarName(MANDATORY);
-            if (n2 === 'c') n2 = 'b';
+            unique_vars.pop();
             return 'var ' + n1 + ' = ' + createExpression(recurmax, NO_COMMA, stmtDepth, canThrow) + ', ' + n2 + ' = ' + createExpression(recurmax, NO_COMMA, stmtDepth, canThrow) + ';';
         }
       case STMT_RETURN_ETC:
@@ -514,8 +551,11 @@ function createStatement(recurmax, canThrow, canBreak, canContinue, cannotReturn
             var nameLenBefore = VAR_NAMES.length;
             var catchName = createVarName(MANDATORY);
             var freshCatchName = VAR_NAMES.length !== nameLenBefore;
+            if (!catch_redef) unique_vars.push(catchName);
             s += ' catch (' + catchName + ') { ' + createStatements(3, recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth) + ' }';
-            if (freshCatchName) VAR_NAMES.splice(nameLenBefore, 1); // remove catch name
+            // remove catch name
+            if (!catch_redef) unique_vars.pop();
+            if (freshCatchName) VAR_NAMES.splice(nameLenBefore, 1);
         }
         if (n !== 0) s += ' finally { ' + createStatements(3, recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth) + ' }';
         return s;
@@ -593,8 +633,9 @@ function _createExpression(recurmax, noComma, stmtDepth, canThrow) {
       case p++:
       case p++:
         var nameLenBefore = VAR_NAMES.length;
+        unique_vars.push('c');
         var name = createVarName(MAYBE); // note: this name is only accessible from _within_ the function. and immutable at that.
-        if (name == 'c') name = 'a';
+        unique_vars.pop();
         var s = [];
         switch (rng(5)) {
           case 0:
@@ -636,7 +677,7 @@ function _createExpression(recurmax, noComma, stmtDepth, canThrow) {
                 strictMode()
             );
             if (instantiate) for (var i = rng(4); --i >= 0;) {
-                if (rng(2)) s.push('this.' + getDotKey() + createAssignment() + _createBinaryExpr(recurmax, noComma, stmtDepth, canThrow) + ';');
+                if (rng(2)) s.push('this.' + getDotKey(true) + createAssignment() + _createBinaryExpr(recurmax, noComma, stmtDepth, canThrow) + ';');
                 else  s.push('this[' + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + ']' + createAssignment() + _createBinaryExpr(recurmax, noComma, stmtDepth, canThrow) + ';');
             }
             s.push(
@@ -646,7 +687,7 @@ function _createExpression(recurmax, noComma, stmtDepth, canThrow) {
             break;
         }
         VAR_NAMES.length = nameLenBefore;
-        return s.join('\n');
+        return filterDirective(s).join('\n');
       case p++:
       case p++:
         return createTypeofExpr(recurmax, stmtDepth, canThrow);
@@ -689,19 +730,19 @@ function _createExpression(recurmax, noComma, stmtDepth, canThrow) {
             ") || " + rng(10) + ").toString()[" +
             createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + "] ";
       case p++:
-        return createArrayLiteral(recurmax, COMMA_OK, stmtDepth, canThrow);
+        return createArrayLiteral(recurmax, stmtDepth, canThrow);
       case p++:
-        return createObjectLiteral(recurmax, COMMA_OK, stmtDepth, canThrow);
+        return createObjectLiteral(recurmax, stmtDepth, canThrow);
       case p++:
-        return createArrayLiteral(recurmax, COMMA_OK, stmtDepth, canThrow) + '[' +
+        return createArrayLiteral(recurmax, stmtDepth, canThrow) + '[' +
             createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + ']';
       case p++:
-        return createObjectLiteral(recurmax, COMMA_OK, stmtDepth, canThrow) + '[' +
+        return createObjectLiteral(recurmax, stmtDepth, canThrow) + '[' +
             createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + ']';
       case p++:
-        return createArrayLiteral(recurmax, COMMA_OK, stmtDepth, canThrow) + '.' + getDotKey();
+        return createArrayLiteral(recurmax, stmtDepth, canThrow) + '.' + getDotKey();
       case p++:
-        return createObjectLiteral(recurmax, COMMA_OK, stmtDepth, canThrow) + '.' + getDotKey();
+        return createObjectLiteral(recurmax, stmtDepth, canThrow) + '.' + getDotKey();
       case p++:
         var name = getVarName();
         return name + ' && ' + name + '[' + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + ']';
@@ -713,7 +754,7 @@ function _createExpression(recurmax, noComma, stmtDepth, canThrow) {
     return _createExpression(recurmax, noComma, stmtDepth, canThrow);
 }
 
-function createArrayLiteral(recurmax, noComma, stmtDepth, canThrow) {
+function createArrayLiteral(recurmax, stmtDepth, canThrow) {
     recurmax--;
     var arr = "[";
     for (var i = rng(6); --i >= 0;) {
@@ -746,18 +787,56 @@ var KEYS = [
     "3",
 ].concat(SAFE_KEYS);
 
-function getDotKey() {
-    return SAFE_KEYS[rng(SAFE_KEYS.length)];
+function getDotKey(assign) {
+    var key;
+    do {
+        key = SAFE_KEYS[rng(SAFE_KEYS.length)];
+    } while (assign && key == "length");
+    return key;
 }
 
-function createObjectLiteral(recurmax, noComma, stmtDepth, canThrow) {
-    recurmax--;
-    var obj = "({";
-    for (var i = rng(6); --i >= 0;) {
-        var key = KEYS[rng(KEYS.length)];
-        obj += key + ":(" + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + "), ";
+function createAccessor(recurmax, stmtDepth, canThrow) {
+    var namesLenBefore = VAR_NAMES.length;
+    var s;
+    var prop1 = getDotKey();
+    if (rng(2) == 0) {
+        s = [
+            'get ' + prop1 + '(){',
+            strictMode(),
+            createStatements(2, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth),
+            createStatement(recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth, STMT_RETURN_ETC),
+            '},'
+        ];
+    } else {
+        var prop2;
+        do {
+            prop2 = getDotKey();
+        } while (prop1 == prop2);
+        s = [
+            'set ' + prop1 + '(' + createVarName(MANDATORY) + '){',
+            strictMode(),
+            createStatements(2, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth),
+            'this.' + prop2 + createAssignment() + _createBinaryExpr(recurmax, COMMA_OK, stmtDepth, canThrow) + ';',
+            '},'
+        ];
     }
-    return obj + "})";
+    VAR_NAMES.length = namesLenBefore;
+    return filterDirective(s).join('\n');
+}
+
+function createObjectLiteral(recurmax, stmtDepth, canThrow) {
+    recurmax--;
+    var obj = ['({'];
+    for (var i = rng(6); --i >= 0;) {
+        if (rng(20) == 0) {
+            obj.push(createAccessor(recurmax, stmtDepth, canThrow));
+        } else {
+            var key = KEYS[rng(KEYS.length)];
+            obj.push(key + ':(' + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + '),');
+        }
+    }
+    obj.push('})');
+    return obj.join('\n');
 }
 
 function createNestedBinaryExpr(recurmax, noComma, stmtDepth, canThrow) {
@@ -787,7 +866,7 @@ function _createSimpleBinaryExpr(recurmax, noComma, stmtDepth, canThrow) {
         return canThrow && rng(10) == 0 ? expr : '(' + assignee + ' && ' + expr + ')';
       case 4:
         assignee = getVarName();
-        expr = '(' + assignee + '.' + getDotKey() + createAssignment()
+        expr = '(' + assignee + '.' + getDotKey(true) + createAssignment()
             + _createBinaryExpr(recurmax, noComma, stmtDepth, canThrow) + ')';
         return canThrow && rng(10) == 0 ? expr : '(' + assignee + ' && ' + expr + ')';
       default:
@@ -844,17 +923,24 @@ function getVarName() {
 
 function createVarName(maybe, dontStore) {
     if (!maybe || rng(2)) {
-        var name = VAR_NAMES[rng(VAR_NAMES.length)];
         var suffix = rng(3);
-        if (suffix) {
-            name += '_' + suffix;
-            if (!dontStore) VAR_NAMES.push(name);
-        }
+        var name;
+        do {
+            name = VAR_NAMES[rng(VAR_NAMES.length)];
+            if (suffix) name += '_' + suffix;
+        } while (unique_vars.indexOf(name) >= 0);
+        if (suffix && !dontStore) VAR_NAMES.push(name);
         return name;
     }
     return '';
 }
 
+if (require.main !== module) {
+    exports.createTopLevelCode = createTopLevelCode;
+    exports.num_iterations = num_iterations;
+    return;
+}
+
 function try_beautify(code, result) {
     var beautified = UglifyJS.minify(code, {
         compress: false,
@@ -973,10 +1059,6 @@ var uglify_code, uglify_result, ok;
 for (var round = 1; round <= num_iterations; round++) {
     process.stdout.write(round + " of " + num_iterations + "\r");
 
-    VAR_NAMES.length = INITIAL_NAMES_LEN; // prune any previous names still in the list
-    loops = 0;
-    funcs = 0;
-
     original_code = createTopLevelCode();
     original_result = sandbox.run_code(original_code);
     (typeof original_result != "string" ? fallback_options : minify_options).forEach(function(options) {
@@ -992,7 +1074,7 @@ for (var round = 1; round <= num_iterations; round++) {
             }
         }
         if (verbose || (verbose_interval && !(round % INTERVAL_COUNT)) || !ok) log(options);
-        else if (verbose_error && typeof original_result != "string") {
+        else if (typeof original_result != "string") {
             console.log("//=============================================================");
             console.log("// original code");
             try_beautify(original_code, original_result);