Merge pull request #2161 from alexlamsl/harmony-v3.0.20

Merging from master for 3.0.20

.travis.yml

@@ -1,12 +1,14 @@
 language: node_js
-before_install: "npm install -g npm"
 node_js:
     - "0.10"
     - "0.12"
     - "4"
     - "6"
+    - "8"
 env:
     - UGLIFYJS_TEST_ALL=1
 matrix:
   fast_finish: true
 sudo: false
+cache:
+  directories: tmp

bin/uglifyjs

@@ -21,10 +21,20 @@ var options = {
     compress: false,
     mangle: false
 };
-program._name = info.name;
-program.version(info.version);
+program.version(info.name + " " + info.version);
 program.parseArgv = program.parse;
 program.parse = undefined;
+if (process.argv.indexOf("ast") >= 0) program.helpInformation = UglifyJS.describe_ast;
+else if (process.argv.indexOf("options") >= 0) program.helpInformation = function() {
+    var text = [];
+    var options = UglifyJS.default_options();
+    for (var option in options) {
+        text.push("--" + (option == "output" ? "beautify" : option == "sourceMap" ? "source-map" : option) + " options:");
+        text.push(format_object(options[option]));
+        text.push("");
+    }
+    return text.join("\n");
+};
 program.option("-p, --parse <options>", "Specify parser options.", parse_js("parse", true));
 program.option("-c, --compress [options]", "Enable compressor/specify compressor options.", parse_js("compress", true));
 program.option("-m, --mangle [options]", "Mangle names/specify mangler options.", parse_js("mangle", true));
@@ -34,12 +44,13 @@ program.option("-o, --output <file>", "Output file (default STDOUT).");
 program.option("--comments [filter]", "Preserve copyright comments in the output.");
 program.option("--config-file <file>", "Read minify() options from JSON file.");
 program.option("-d, --define <expr>[=value]", "Global definitions.", parse_js("define"));
+program.option("--ecma <version>", "Specifiy ECMAScript release: 5, 6, 7 or 8.");
 program.option("--ie8", "Support non-standard Internet Explorer 8.");
 program.option("--keep-fnames", "Do not mangle/drop function names. Useful for code relying on Function.prototype.name.");
 program.option("--name-cache <file>", "File to hold mangled name mappings.");
 program.option("--self", "Build UglifyJS as a library (implies --wrap UglifyJS)");
 program.option("--source-map [options]", "Enable source map/specify source map options.", parse_source_map());
-program.option("--stats", "Display operations run time on STDERR.")
+program.option("--timings", "Display operations run time on STDERR.")
 program.option("--toplevel", "Compress and/or mangle variables in toplevel scope.");
 program.option("--verbose", "Print diagnostic messages.");
 program.option("--warn", "Print warning messages.");
@@ -63,6 +74,10 @@ if (!program.output && program.sourceMap && program.sourceMap.url != "inline") {
         options[name] = program[name];
     }
 });
+if ("ecma" in program) {
+    if (program.ecma != (program.ecma | 0)) fatal("ERROR: ecma must be an integer");
+    options.ecma = program.ecma | 0;
+}
 if (program.beautify) {
     options.output = typeof program.beautify == "object" ? program.beautify : {};
     if (!("beautify" in options.output)) {
@@ -115,10 +130,10 @@ if (program.output == "ast") {
     };
 }
 if (program.parse) {
-    if (program.parse.acorn || program.parse.spidermonkey) {
-        if (program.sourceMap) fatal("ERROR: inline source map only works with built-in parser");
-    } else {
+    if (!program.parse.acorn && !program.parse.spidermonkey) {
         options.parse = program.parse;
+    } else if (program.sourceMap && program.sourceMap.content == "inline") {
+        fatal("ERROR: inline source map only works with built-in parser");
     }
 }
 var convert_path = function(name) {
@@ -140,7 +155,7 @@ if (program.verbose) {
 }
 if (program.self) {
     if (program.args.length) {
-        console.error("WARN: Ignoring input files since --self was passed");
+        print_error("WARN: Ignoring input files since --self was passed");
     }
     if (!options.wrap) options.wrap = "UglifyJS";
     simple_glob(UglifyJS.FILES).forEach(function(name) {
@@ -170,9 +185,9 @@ function convert_ast(fn) {
 
 function run() {
     UglifyJS.AST_Node.warn_function = function(msg) {
-        console.error("WARN:", msg);
+        print_error("WARN: " + msg);
     };
-    if (program.stats) program.stats = Date.now();
+    if (program.timings) options.timings = true;
     try {
         if (program.parse) {
             if (program.parse.acorn) {
@@ -199,7 +214,7 @@ function run() {
     if (result.error) {
         var ex = result.error;
         if (ex.name == "SyntaxError") {
-            console.error("Parse error at " + ex.filename + ":" + ex.line + "," + ex.col);
+            print_error("Parse error at " + ex.filename + ":" + ex.line + "," + ex.col);
             var col = ex.col;
             var lines = files[ex.filename].split(/\r?\n/);
             var line = lines[ex.line - 1];
@@ -208,21 +223,22 @@ function run() {
                 col = line.length;
             }
             if (line) {
-                if (col > 40) {
-                    line = line.slice(col - 40);
-                    col = 40;
+                var limit = 70;
+                if (col > limit) {
+                    line = line.slice(col - limit);
+                    col = limit;
                 }
-                console.error(line.slice(0, 80));
-                console.error(line.slice(0, col).replace(/\S/g, " ") + "^");
+                print_error(line.slice(0, 80));
+                print_error(line.slice(0, col).replace(/\S/g, " ") + "^");
             }
         }
         if (ex.defs) {
-            console.error("Supported options:");
-            console.error(ex.defs);
+            print_error("Supported options:");
+            print_error(format_object(ex.defs));
         }
         fatal(ex);
     } else if (program.output == "ast") {
-        console.log(JSON.stringify(result.ast, function(key, value) {
+        print(JSON.stringify(result.ast, function(key, value) {
             if (skip_key(key)) return;
             if (value instanceof UglifyJS.AST_Token) return;
             if (value instanceof UglifyJS.Dictionary) return;
@@ -238,7 +254,7 @@ function run() {
             return value;
         }, 2));
     } else if (program.output == "spidermonkey") {
-        console.log(JSON.stringify(UglifyJS.minify(result.code, {
+        print(JSON.stringify(UglifyJS.minify(result.code, {
             compress: false,
             mangle: false,
             output: {
@@ -252,19 +268,21 @@ function run() {
             fs.writeFileSync(program.output + ".map", result.map);
         }
     } else {
-        console.log(result.code);
+        print(result.code);
     }
     if (program.nameCache) {
         fs.writeFileSync(program.nameCache, JSON.stringify(cache, function(key, value) {
             return value instanceof UglifyJS.Dictionary ? value.toObject() : value;
         }));
     }
-    if (program.stats) console.error("Elapsed:", Date.now() - program.stats);
+    if (result.timings) for (var phase in result.timings) {
+        print_error("- " + phase + ": " + result.timings[phase].toFixed(3) + "s");
+    }
 }
 
 function fatal(message) {
     if (message instanceof Error) message = message.stack.replace(/^\S*?Error:/, "ERROR:")
-    console.error(message);
+    print_error(message);
     process.exit(1);
 }
 
@@ -349,7 +367,7 @@ function parse_js(flag, constants) {
                 }
             }));
         } catch(ex) {
-            fatal("Error parsing arguments for '" + flag + "': " + value);
+            options[value] = null;
         }
         return options;
     }
@@ -358,10 +376,10 @@ function parse_js(flag, constants) {
 function parse_source_map() {
     var parse = parse_js("sourceMap", true);
     return function(value, options) {
-        var hasContent = options && options.sourceMap && "content" in options.sourceMap;
+        var hasContent = options && "content" in options;
         var settings = parse(value, options);
         if (!hasContent && settings.content && settings.content != "inline") {
-            console.error("INFO: Using input source map:", settings.content);
+            print_error("INFO: Using input source map: " + settings.content);
             settings.content = read_file(settings.content, settings.content);
         }
         return settings;
@@ -383,3 +401,25 @@ function to_cache(key) {
 function skip_key(key) {
     return skip_keys.indexOf(key) >= 0;
 }
+
+function format_object(obj) {
+    var lines = [];
+    var padding = "";
+    Object.keys(obj).map(function(name) {
+        if (padding.length < name.length) padding = Array(name.length + 1).join(" ");
+        return [ name, JSON.stringify(obj[name]) ];
+    }).forEach(function(tokens) {
+        lines.push("  " + tokens[0] + padding.slice(tokens[0].length - 2) + tokens[1]);
+    });
+    return lines.join("\n");
+}
+
+function print_error(msg) {
+    process.stderr.write(msg);
+    process.stderr.write("\n");
+}
+
+function print(txt) {
+    process.stdout.write(txt);
+    process.stdout.write("\n");
+}

lib/ast.js

@@ -355,86 +355,14 @@ var AST_Expansion = DEFNODE("Expansion", "expression", {
     }
 });
 
-var AST_ArrowParametersOrSeq = DEFNODE("ArrowParametersOrSeq", "expressions", {
-    $documentation: "A set of arrow function parameters or a sequence expression. This is used because when the parser sees a \"(\" it could be the start of a seq, or the start of a parameter list of an arrow function.",
-    $propdoc: {
-        expressions: "[AST_Expression|AST_Destructuring|AST_Expansion*] array of expressions or argument names or destructurings."
-    },
-    as_params: function (croak) {
-        // We don't want anything which doesn't belong in a destructuring
-        var root = this;
-        return this.expressions.map(function to_fun_args(ex, _, __, default_seen_above) {
-            var insert_default = function(ex, default_value) {
-                if (default_value) {
-                    return new AST_DefaultAssign({
-                        start: ex.start,
-                        left: ex,
-                        operator: "=",
-                        right: default_value,
-                        end: default_value.end
-                    });
-                }
-                return ex;
-            }
-            if (ex instanceof AST_Object) {
-                return insert_default(new AST_Destructuring({
-                    start: ex.start,
-                    end: ex.end,
-                    is_array: false,
-                    names: ex.properties.map(to_fun_args)
-                }), default_seen_above);
-            } else if (ex instanceof AST_ObjectKeyVal) {
-                if (ex.key instanceof AST_SymbolRef) {
-                    ex.key = to_fun_args(ex.key, 0, [ex.key]);
-                }
-                ex.value = to_fun_args(ex.value, 0, [ex.key]);
-                return insert_default(ex, default_seen_above);
-            } else if (ex instanceof AST_Hole) {
-                return ex;
-            } else if (ex instanceof AST_Destructuring) {
-                ex.names = ex.names.map(to_fun_args);
-                return insert_default(ex, default_seen_above);
-            } else if (ex instanceof AST_SymbolRef) {
-                return insert_default(new AST_SymbolFunarg({
-                    name: ex.name,
-                    start: ex.start,
-                    end: ex.end
-                }), default_seen_above);
-            } else if (ex instanceof AST_Expansion) {
-                ex.expression = to_fun_args(ex.expression);
-                return insert_default(ex, default_seen_above);
-            } else if (ex instanceof AST_Array) {
-                return insert_default(new AST_Destructuring({
-                    start: ex.start,
-                    end: ex.end,
-                    is_array: true,
-                    names: ex.elements.map(to_fun_args)
-                }), default_seen_above);
-            } else if (ex instanceof AST_Assign) {
-                return insert_default(to_fun_args(ex.left, undefined, undefined, ex.right), default_seen_above);
-            } else if (ex instanceof AST_DefaultAssign) {
-                ex.left = to_fun_args(ex.left, 0, [ex.left]);
-                return ex;
-            } else {
-                croak("Invalid function parameter", ex.start.line, ex.start.col);
-            }
-        });
-    },
-    as_expr: function() {
-        var exprs = this.expressions;
-        return exprs.length == 1 ? exprs[0] : new AST_Sequence({
-            expressions: exprs
-        });
-    }
-});
-
-var AST_Lambda = DEFNODE("Lambda", "name argnames uses_arguments is_generator", {
+var AST_Lambda = DEFNODE("Lambda", "name argnames uses_arguments is_generator async", {
     $documentation: "Base class for functions",
     $propdoc: {
-        is_generator: "[boolean] is generatorFn or not",
         name: "[AST_SymbolDeclaration?] the name of this function",
         argnames: "[AST_SymbolFunarg|AST_Destructuring|AST_Expansion|AST_DefaultAssign*] array of function arguments, destructurings, or expanding arguments",
-        uses_arguments: "[boolean/S] tells whether this function accesses the arguments array"
+        uses_arguments: "[boolean/S] tells whether this function accesses the arguments array",
+        is_generator: "[boolean] is this a generator method",
+        async: "[boolean] is this method async",
     },
     args_as_names: function () {
         var out = [];
@@ -701,11 +629,11 @@ var AST_Const = DEFNODE("Const", null, {
     $documentation: "A `const` statement"
 }, AST_Definitions);
 
-var AST_NameImport = DEFNODE("NameImport", "foreign_name name", {
-    $documentation: "The part of the import statement that imports names from a module.",
+var AST_NameMapping = DEFNODE("NameMapping", "foreign_name name", {
+    $documentation: "The part of the export/import statement that declare names from a module.",
     $propdoc: {
-        foreign_name: "[AST_SymbolImportForeign] The name being imported (as specified in the module)",
-        name: "[AST_SymbolImport] The name as it becomes available to this module."
+        foreign_name: "[AST_SymbolExportForeign|AST_SymbolImportForeign] The name being exported/imported (as specified in the module)",
+        name: "[AST_SymbolExport|AST_SymbolImport] The name as it is visible to this module."
     },
     _walk: function (visitor) {
         return visitor._visit(this, function() {
@@ -719,7 +647,7 @@ var AST_Import = DEFNODE("Import", "imported_name imported_names module_name", {
     $documentation: "An `import` statement",
     $propdoc: {
         imported_name: "[AST_SymbolImport] The name of the variable holding the module's default export.",
-        imported_names: "[AST_NameImport*] The names of non-default imported variables",
+        imported_names: "[AST_NameMapping*] The names of non-default imported variables",
         module_name: "[AST_String] String literal describing where this module came from",
     },
     _walk: function(visitor) {
@@ -742,7 +670,7 @@ var AST_Export = DEFNODE("Export", "exported_definition exported_value is_defaul
     $propdoc: {
         exported_definition: "[AST_Defun|AST_Definitions|AST_DefClass?] An exported definition",
         exported_value: "[AST_Node?] An exported value",
-        exported_names: "[AST_NameImport*?] List of exported names",
+        exported_names: "[AST_NameMapping*?] List of exported names",
         module_name: "[AST_String?] Name of the file to load exports from",
         is_default: "[Boolean] Whether this is the default exported value of this module"
     },
@@ -754,6 +682,14 @@ var AST_Export = DEFNODE("Export", "exported_definition exported_value is_defaul
             if (this.exported_value) {
                 this.exported_value._walk(visitor);
             }
+            if (this.exported_names) {
+                this.exported_names.forEach(function(name_export) {
+                    name_export._walk(visitor);
+                });
+            }
+            if (this.module_name) {
+                this.module_name._walk(visitor);
+            }
         });
     }
 }, AST_Statement);
@@ -932,7 +868,7 @@ var AST_ObjectProperty = DEFNODE("ObjectProperty", "key value", {
     $documentation: "Base class for literal object properties",
     $propdoc: {
         key: "[string|AST_Node] the property name converted to a string for ObjectKeyVal. For setters, getters and computed property this is an arbitrary AST_Node",
-        value: "[AST_Node] property value. For setters and getters this is an AST_Function."
+        value: "[AST_Node] property value.  For setters and getters this is an AST_Accessor."
     },
     _walk: function(visitor) {
         return visitor._visit(this, function(){
@@ -966,11 +902,12 @@ var AST_ObjectGetter = DEFNODE("ObjectGetter", "quote static", {
     $documentation: "An object getter property",
 }, AST_ObjectProperty);
 
-var AST_ConciseMethod = DEFNODE("ConciseMethod", "quote static is_generator", {
+var AST_ConciseMethod = DEFNODE("ConciseMethod", "quote static is_generator async", {
     $propdoc: {
         quote: "[string|undefined] the original quote character, if any",
-        static: "[boolean] whether this method is static (classes only)",
-        is_generator: "[boolean] is generatorFn or not",
+        static: "[boolean] is this method static (classes only)",
+        is_generator: "[boolean] is this a generator method",
+        async: "[boolean] is this method async",
     },
     $documentation: "An ES6 concise method inside an object or class"
 }, AST_ObjectProperty);
@@ -1018,10 +955,6 @@ var AST_NewTarget = DEFNODE("NewTarget", null, {
     $documentation: "A reference to new.target"
 });
 
-var AST_SymbolAccessor = DEFNODE("SymbolAccessor", null, {
-    $documentation: "The name of a property accessor (setter/getter function)"
-}, AST_Symbol);
-
 var AST_SymbolDeclaration = DEFNODE("SymbolDeclaration", "init", {
     $documentation: "A declaration symbol (symbol in var/const, function name or argument, symbol in catch)",
 }, AST_Symbol);
@@ -1071,7 +1004,7 @@ var AST_SymbolCatch = DEFNODE("SymbolCatch", null, {
 }, AST_SymbolBlockDeclaration);
 
 var AST_SymbolImport = DEFNODE("SymbolImport", null, {
-    $documentation: "Symbol refering to an imported name",
+    $documentation: "Symbol referring to an imported name",
 }, AST_SymbolBlockDeclaration);
 
 var AST_SymbolImportForeign = DEFNODE("SymbolImportForeign", null, {
@@ -1093,6 +1026,14 @@ var AST_SymbolRef = DEFNODE("SymbolRef", null, {
     $documentation: "Reference to some symbol (not definition/declaration)",
 }, AST_Symbol);
 
+var AST_SymbolExport = DEFNODE("SymbolExport", null, {
+    $documentation: "Symbol referring to a name to export",
+}, AST_SymbolRef);
+
+var AST_SymbolExportForeign = DEFNODE("SymbolExportForeign", null, {
+    $documentation: "A symbol exported from this module, but it is used in the other module, and its real name is irrelevant for this module's purposes",
+}, AST_Symbol);
+
 var AST_LabelRef = DEFNODE("LabelRef", null, {
     $documentation: "Reference to a label symbol",
 }, AST_Symbol);
@@ -1178,7 +1119,17 @@ var AST_True = DEFNODE("True", null, {
     value: true
 }, AST_Boolean);
 
-/* -----[ Yield ]----- */
+var AST_Await = DEFNODE("Await", "expression", {
+    $documentation: "An `await` statement",
+    $propdoc: {
+        expression: "[AST_Node] the mandatory expression being awaited",
+    },
+    _walk: function(visitor) {
+        return visitor._visit(this, function(){
+            this.expression._walk(visitor);
+        });
+    }
+});
 
 var AST_Yield = DEFNODE("Yield", "expression is_star", {
     $documentation: "A `yield` statement",

lib/minify.js

@@ -30,21 +30,24 @@ function set_shorthand(name, options, keys) {
 function minify(files, options) {
     var warn_function = AST_Node.warn_function;
     try {
-        if (typeof files == "string") {
-            files = [ files ];
-        }
         options = defaults(options, {
             compress: {},
+            ecma: undefined,
             ie8: false,
             keep_fnames: false,
             mangle: {},
             output: {},
             parse: {},
             sourceMap: false,
+            timings: false,
             toplevel: false,
             warnings: false,
             wrap: false,
         }, true);
+        var timings = options.timings && {
+            start: Date.now()
+        };
+        set_shorthand("ecma", options, [ "parse", "compress", "output" ]);
         set_shorthand("ie8", options, [ "compress", "mangle", "output" ]);
         set_shorthand("keep_fnames", options, [ "compress", "mangle" ]);
         set_shorthand("toplevel", options, [ "compress", "mangle" ]);
@@ -54,6 +57,7 @@ function minify(files, options) {
                 cache: null,
                 eval: false,
                 ie8: false,
+                keep_classnames: false,
                 keep_fnames: false,
                 properties: false,
                 reserved: [],
@@ -76,13 +80,17 @@ function minify(files, options) {
                 warnings.push(warning);
             };
         }
+        if (timings) timings.parse = Date.now();
         var toplevel;
         if (files instanceof AST_Toplevel) {
             toplevel = files;
         } else {
+            if (typeof files == "string") {
+                files = [ files ];
+            }
             options.parse = options.parse || {};
             options.parse.toplevel = null;
-            for (var name in files) {
+            for (var name in files) if (HOP(files, name)) {
                 options.parse.filename = name;
                 options.parse.toplevel = parse(files[name], options.parse);
                 if (options.sourceMap && options.sourceMap.content == "inline") {
@@ -96,19 +104,23 @@ function minify(files, options) {
         if (options.wrap) {
             toplevel = toplevel.wrap_commonjs(options.wrap);
         }
-        if (options.compress) {
-            toplevel.figure_out_scope(options.mangle);
-            toplevel = new Compressor(options.compress).compress(toplevel);
-        }
+        if (timings) timings.scope1 = Date.now();
+        if (options.compress) toplevel.figure_out_scope(options.mangle);
+        if (timings) timings.compress = Date.now();
+        if (options.compress) toplevel = new Compressor(options.compress).compress(toplevel);
+        if (timings) timings.scope2 = Date.now();
+        if (options.mangle) toplevel.figure_out_scope(options.mangle);
+        if (timings) timings.mangle = Date.now();
         if (options.mangle) {
-            toplevel.figure_out_scope(options.mangle);
             base54.reset();
             toplevel.compute_char_frequency(options.mangle);
             toplevel.mangle_names(options.mangle);
-            if (options.mangle.properties) {
+        }
+        if (timings) timings.properties = Date.now();
+        if (options.mangle && options.mangle.properties) {
             toplevel = mangle_properties(toplevel, options.mangle.properties);
         }
-        }
+        if (timings) timings.output = Date.now();
         var result = {};
         if (options.output.ast) {
             result.ast = toplevel;
@@ -124,7 +136,9 @@ function minify(files, options) {
                     root: options.sourceMap.root
                 });
                 if (options.sourceMap.includeSources) {
-                    for (var name in files) {
+                    if (files instanceof AST_Toplevel) {
+                        throw new Error("original source content unavailable");
+                    } else for (var name in files) if (HOP(files, name)) {
                         options.output.source_map.get().setSourceContent(name, files[name]);
                     }
                 }
@@ -143,6 +157,18 @@ function minify(files, options) {
                 }
             }
         }
+        if (timings) {
+            timings.end = Date.now();
+            result.timings = {
+                parse: 1e-3 * (timings.scope1 - timings.parse),
+                scope: 1e-3 * (timings.compress - timings.scope1 + timings.mangle - timings.scope2),
+                compress: 1e-3 * (timings.scope2 - timings.compress),
+                mangle: 1e-3 * (timings.properties - timings.mangle),
+                properties: 1e-3 * (timings.output - timings.properties),
+                output: 1e-3 * (timings.end - timings.output),
+                total: 1e-3 * (timings.end - timings.start)
+            }
+        }
         if (warnings.length) {
             result.warnings = warnings;
         }

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_SymbolMethod({
+                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({
@@ -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)
         }
     });
 
@@ -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_SymbolMethod ? 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

@@ -73,8 +73,7 @@ function OutputStream(options) {
         shebang          : true,
         shorthand        : undefined,
         source_map       : null,
-        space_colon      : true,
-        unescape_regexps : false,
+        webkit           : false,
         width            : 80,
         wrap_iife        : false,
     }, true);
@@ -214,12 +213,43 @@ function OutputStream(options) {
     var might_need_semicolon = false;
     var might_add_newline = 0;
     var last = "";
+    var mapping_token, mapping_name, mappings = options.source_map && [];
+
+    var do_add_mapping = mappings ? function() {
+        mappings.forEach(function(mapping) {
+            try {
+                options.source_map.add(
+                    mapping.token.file,
+                    mapping.line, mapping.col,
+                    mapping.token.line, mapping.token.col,
+                    !mapping.name && mapping.token.type == "name" ? mapping.token.value : mapping.name
+                );
+            } catch(ex) {
+                AST_Node.warn("Couldn't figure out mapping for {file}:{line},{col} → {cline},{ccol} [{name}]", {
+                    file: mapping.token.file,
+                    line: mapping.token.line,
+                    col: mapping.token.col,
+                    cline: mapping.line,
+                    ccol: mapping.col,
+                    name: mapping.name || ""
+                })
+            }
+        });
+        mappings = [];
+    } : noop;
 
     var ensure_line_len = options.max_line_len ? function() {
         if (current_col > options.max_line_len) {
             if (might_add_newline) {
                 var left = OUTPUT.slice(0, might_add_newline);
                 var right = OUTPUT.slice(might_add_newline);
+                if (mappings) {
+                    var delta = right.length - current_col;
+                    mappings.forEach(function(mapping) {
+                        mapping.line++;
+                        mapping.col += delta;
+                    });
+                }
                 OUTPUT = left + "\n" + right;
                 current_line++;
                 current_pos++;
@@ -229,7 +259,10 @@ function OutputStream(options) {
                 AST_Node.warn("Output exceeds {max_line_len} characters", options);
             }
         }
+        if (might_add_newline) {
             might_add_newline = 0;
+            do_add_mapping();
+        }
     } : noop;
 
     var requireSemicolonChars = makePredicate("( [ + * / - , .");
@@ -289,6 +322,18 @@ function OutputStream(options) {
             }
             might_need_space = false;
         }
+
+        if (mapping_token) {
+            mappings.push({
+                token: mapping_token,
+                name: mapping_name,
+                line: current_line,
+                col: current_col
+            });
+            mapping_token = false;
+            if (!might_add_newline) do_add_mapping();
+        }
+
         OUTPUT += str;
         current_pos += str.length;
         var a = str.split(/\r?\n/), n = a.length - 1;
@@ -384,27 +429,12 @@ function OutputStream(options) {
 
     function colon() {
         print(":");
-        if (options.space_colon) space();
+        space();
     };
 
-    var add_mapping = options.source_map ? function(token, name) {
-        try {
-            if (token) options.source_map.add(
-                token.file || "?",
-                current_line, current_col,
-                token.line, token.col,
-                (!name && token.type == "name") ? token.value : name
-            );
-        } catch(ex) {
-            AST_Node.warn("Couldn't figure out mapping for {file}:{line},{col} → {cline},{ccol} [{name}]", {
-                file: token.file,
-                line: token.line,
-                col: token.col,
-                cline: current_line,
-                ccol: current_col,
-                name: name || ""
-            })
-        }
+    var add_mapping = mappings ? function(token, name) {
+        mapping_token = token;
+        mapping_name = name;
     } : noop;
 
     function get() {
@@ -503,6 +533,7 @@ function OutputStream(options) {
             use_asm = prev_use_asm;
         }
     });
+    AST_Node.DEFMETHOD("_print", AST_Node.prototype.print);
 
     AST_Node.DEFMETHOD("print_to_string", function(options){
         var s = OutputStream(options);
@@ -600,6 +631,13 @@ function OutputStream(options) {
             return true;
         }
 
+        if (output.option('webkit')) {
+            var p = output.parent();
+            if (p instanceof AST_PropAccess && p.expression === this) {
+                return true;
+            }
+        }
+
         if (output.option('wrap_iife')) {
             var p = output.parent();
             return p instanceof AST_Call && p.expression === this;
@@ -613,6 +651,10 @@ function OutputStream(options) {
         return p instanceof AST_PropAccess && p.expression === this;
     });
 
+    PARENS(AST_ClassExpression, function(output){
+        return output.parent() instanceof AST_SimpleStatement;
+    });
+
     // same goes for an object literal, because otherwise it would be
     // interpreted as a block of code.
     PARENS(AST_Object, function(output){
@@ -644,7 +686,6 @@ function OutputStream(options) {
                                                                * ==> 20 (side effect, set a := 10 and b := 20) */
             || p instanceof AST_Arrow                         // x => (x, x)
             || p instanceof AST_DefaultAssign                 // x => (x = (0, function(){}))
-            || (p instanceof AST_Class && p.extends === this) // class D extends (calls++, C) {}
         ;
     });
 
@@ -777,17 +818,15 @@ function OutputStream(options) {
 
     DEFPRINT(AST_Destructuring, function (self, output) {
         output.print(self.is_array ? "[" : "{");
-        var first = true;
         var len = self.names.length;
         self.names.forEach(function (name, i) {
-            if (first) first = false; else { output.comma(); output.space(); }
+            if (i > 0) output.comma();
             name.print(output);
             // If the final element is a hole, we need to make sure it
             // doesn't look like a trailing comma, by inserting an actual
             // trailing comma.
-            if (i === len - 1 && name instanceof AST_Hole)
-              output.comma();
-        })
+            if (i == len - 1 && name instanceof AST_Hole) output.comma();
+        });
         output.print(self.is_array ? "]" : "}");
     });
 
@@ -940,8 +979,12 @@ function OutputStream(options) {
     AST_Lambda.DEFMETHOD("_do_print", function(output, nokeyword){
         var self = this;
         if (!nokeyword) {
+            if (self.async) {
+                output.print("async");
+                output.space();
+            }
             output.print("function");
-            if (this.is_generator) {
+            if (self.is_generator) {
                 output.star();
             }
             if (self.name) {
@@ -996,6 +1039,10 @@ function OutputStream(options) {
         var needs_parens = parent instanceof AST_Binary ||
             parent instanceof AST_Unary ||
             (parent instanceof AST_Call && self === parent.expression);
+        if (self.async) {
+            output.print("async");
+            output.space();
+        }
         if (needs_parens) { output.print("(") }
         if (self.argnames.length === 1 && self.argnames[0] instanceof AST_Symbol) {
             self.argnames[0].print(output);
@@ -1011,9 +1058,9 @@ function OutputStream(options) {
         output.print('=>');
         output.space();
         if (self.body instanceof AST_Node) {
-            this.body.print(output);
+            self.body.print(output);
         } else {
-            print_bracketed(this.body, output);
+            print_bracketed(self.body, output);
         }
         if (needs_parens) { output.print(")") }
     });
@@ -1045,6 +1092,22 @@ function OutputStream(options) {
         }
     });
 
+    DEFPRINT(AST_Await, function(self, output){
+        output.print("await");
+        output.space();
+        var e = self.expression;
+        var parens = !(
+               e instanceof AST_Call
+            || e instanceof AST_SymbolRef
+            || e instanceof AST_PropAccess
+            || e instanceof AST_Unary
+            || e instanceof AST_Constant
+        );
+        if (parens) output.print("(");
+        self.expression.print(output);
+        if (parens) output.print(")");
+    });
+
     /* -----[ loop control ]----- */
     AST_LoopControl.DEFMETHOD("_do_print", function(output, kind){
         output.print(kind);
@@ -1222,7 +1285,6 @@ function OutputStream(options) {
                     name_import.print(output);
                     if (i < self.imported_names.length - 1) {
                         output.print(",");
-                        output.space();
                     }
                 });
                 output.space();
@@ -1238,17 +1300,26 @@ function OutputStream(options) {
         output.semicolon();
     });
 
-    DEFPRINT(AST_NameImport, function(self, output) {
+    DEFPRINT(AST_NameMapping, function(self, output) {
+        var is_import = output.parent() instanceof AST_Import;
         var definition = self.name.definition();
         var names_are_different =
             (definition && definition.mangled_name || self.name.name) !==
             self.foreign_name.name;
         if (names_are_different) {
+            if (is_import) {
                 output.print(self.foreign_name.name);
+            } else {
+                self.name.print(output);
+            }
             output.space();
             output.print("as");
             output.space();
+            if (is_import) {
                 self.name.print(output);
+            } else {
+                output.print(self.foreign_name.name);
+            }
         } else {
             self.name.print(output);
         }
@@ -1262,24 +1333,20 @@ function OutputStream(options) {
             output.space();
         }
         if (self.exported_names) {
-            output.space();
-
             if (self.exported_names.length === 1 && self.exported_names[0].name.name === "*") {
                 self.exported_names[0].print(output);
             } else {
                 output.print("{");
-                self.exported_names.forEach(function (name_import, i) {
+                self.exported_names.forEach(function(name_export, i) {
                     output.space();
-                    name_import.print(output);
+                    name_export.print(output);
                     if (i < self.exported_names.length - 1) {
                         output.print(",");
-                        output.space();
                     }
                 });
                 output.space();
                 output.print("}");
             }
-            output.space();
         }
         else if (self.exported_value) {
             self.exported_value.print(output);
@@ -1474,11 +1541,25 @@ function OutputStream(options) {
             output.space();
         }
         if (self.extends) {
+            var parens = (
+                   !(self.extends instanceof AST_SymbolRef)
+                && !(self.extends instanceof AST_PropAccess)
+                && !(self.extends instanceof AST_ClassExpression)
+                && !(self.extends instanceof AST_Function)
+            );
             output.print("extends");
+            if (parens) {
+                output.print("(");
+            } else {
                 output.space();
+            }
             self.extends.print(output);
+            if (parens) {
+                output.print(")");
+            } else {
                 output.space();
             }
+        }
         if (self.properties.length > 0) output.with_block(function(){
             self.properties.forEach(function(prop, i){
                 if (i) {
@@ -1494,7 +1575,8 @@ function OutputStream(options) {
     DEFPRINT(AST_NewTarget, function(self, output) {
         output.print("new.target");
     });
-    AST_ObjectProperty.DEFMETHOD("print_property_name", function(key, quote, output) {
+
+    function print_property_name(key, quote, output) {
         if (output.option("quote_keys")) {
             output.print_string(key + "");
         } else if ((typeof key == "number"
@@ -1511,7 +1593,8 @@ function OutputStream(options) {
         } else {
             output.print_string(key, quote);
         }
-    });
+    }
+
     DEFPRINT(AST_ObjectKeyVal, function(self, output){
         function get_name(self) {
             var def = self.definition();
@@ -1524,7 +1607,7 @@ function OutputStream(options) {
             is_identifier_string(self.key) &&
             get_name(self.value) === self.key
         ) {
-            self.print_property_name(self.key, self.quote, output);
+            print_property_name(self.key, self.quote, output);
 
         } else if (allowShortHand &&
             self.value instanceof AST_DefaultAssign &&
@@ -1532,12 +1615,14 @@ function OutputStream(options) {
             is_identifier_string(self.key) &&
             get_name(self.value.left) === self.key
         ) {
-            self.print_property_name(self.key, self.quote, output);
+            print_property_name(self.key, self.quote, output);
+            output.space();
             output.print("=");
+            output.space();
             self.value.right.print(output);
         } else {
             if (!(self.key instanceof AST_Node)) {
-                self.print_property_name(self.key, self.quote, output);
+                print_property_name(self.key, self.quote, output);
             } else {
                 output.with_square(function() {
                     self.key.print(output);
@@ -1547,15 +1632,18 @@ function OutputStream(options) {
             self.value.print(output);
         }
     });
-    AST_ObjectProperty.DEFMETHOD("_print_getter_setter", function(type, self, output) {
+    AST_ObjectProperty.DEFMETHOD("_print_getter_setter", function(type, output) {
+        var self = this;
         if (self.static) {
             output.print("static");
             output.space();
         }
+        if (type) {
             output.print(type);
             output.space();
+        }
         if (self.key instanceof AST_SymbolMethod) {
-            self.print_property_name(self.key.name, self.quote, output);
+            print_property_name(self.key.name, self.quote, output);
         } else {
             output.with_square(function() {
                 self.key.print(output);
@@ -1564,27 +1652,13 @@ function OutputStream(options) {
         self.value._do_print(output, true);
     });
     DEFPRINT(AST_ObjectSetter, function(self, output){
-        self._print_getter_setter("set", self, output);
+        self._print_getter_setter("set", output);
     });
     DEFPRINT(AST_ObjectGetter, function(self, output){
-        self._print_getter_setter("get", self, output);
+        self._print_getter_setter("get", output);
     });
     DEFPRINT(AST_ConciseMethod, function(self, output){
-        if (self.static) {
-            output.print("static");
-            output.space();
-        }
-        if (self.is_generator) {
-            output.print("*");
-        }
-        if (self.key instanceof AST_SymbolMethod) {
-            self.print_property_name(self.key.name, self.quote, output);
-        } else {
-            output.with_square(function() {
-                self.key.print(output);
-            });
-        }
-        self.value._do_print(output, true);
+        self._print_getter_setter(self.is_generator && "*" || self.async && "async", output);
     });
     AST_Symbol.DEFMETHOD("_do_print", function(output){
         var def = this.definition();
@@ -1617,45 +1691,14 @@ function OutputStream(options) {
         }
     });
 
-    function regexp_safe_literal(code) {
-        return [
-            0x5c   , // \
-            0x2f   , // /
-            0x2e   , // .
-            0x2b   , // +
-            0x2a   , // *
-            0x3f   , // ?
-            0x28   , // (
-            0x29   , // )
-            0x5b   , // [
-            0x5d   , // ]
-            0x7b   , // {
-            0x7d   , // }
-            0x24   , // $
-            0x5e   , // ^
-            0x3a   , // :
-            0x7c   , // |
-            0x21   , // !
-            0x0a   , // \n
-            0x0d   , // \r
-            0x00   , // \0
-            0xfeff , // Unicode BOM
-            0x2028 , // unicode "line separator"
-            0x2029 , // unicode "paragraph separator"
-        ].indexOf(code) < 0;
-    };
-
     DEFPRINT(AST_RegExp, function(self, output){
-        var str = self.getValue().toString();
+        var regexp = self.getValue();
+        var str = regexp.toString();
+        if (regexp.raw_source) {
+            str = "/" + regexp.raw_source + str.slice(str.lastIndexOf("/"));
+        }
         if (output.option("ascii_only")) {
             str = output.to_ascii(str);
-        } else if (output.option("unescape_regexps")) {
-            str = str.split("\\\\").map(function(str){
-                return str.replace(/\\u[0-9a-fA-F]{4}|\\x[0-9a-fA-F]{2}/g, function(s){
-                    var code = parseInt(s.substr(2), 16);
-                    return regexp_safe_literal(code) ? String.fromCharCode(code) : s;
-                });
-            }).join("\\\\");
         }
         output.print(str);
         var p = output.parent();

lib/parse.js

@@ -47,7 +47,7 @@
 var KEYWORDS = 'break case catch class const continue debugger default delete do else export extends finally for function if in instanceof new return switch throw try typeof var let void while with import';
 var KEYWORDS_ATOM = 'false null true';
 var RESERVED_WORDS = 'enum implements interface package private protected public static super this ' + KEYWORDS_ATOM + " " + KEYWORDS;
-var KEYWORDS_BEFORE_EXPRESSION = 'return new delete throw else case yield';
+var KEYWORDS_BEFORE_EXPRESSION = 'return new delete throw else case yield await';
 
 KEYWORDS = makePredicate(KEYWORDS);
 RESERVED_WORDS = makePredicate(RESERVED_WORDS);
@@ -122,8 +122,6 @@ var PUNC_BEFORE_EXPRESSION = makePredicate(characters("[{(,;:"));
 
 var PUNC_CHARS = makePredicate(characters("[]{}(),;:"));
 
-var REGEXP_MODIFIERS = makePredicate(characters("gmsiy"));
-
 /* -----[ Tokenizer ]----- */
 
 // surrogate safe regexps adapted from https://github.com/mathiasbynens/unicode-8.0.0/tree/89b412d8a71ecca9ed593d9e9fa073ab64acfebe/Binary_Property
@@ -345,7 +343,11 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
                            (type == "keyword" && KEYWORDS_BEFORE_EXPRESSION(value)) ||
                            (type == "punc" && PUNC_BEFORE_EXPRESSION(value))) ||
                            (type == "arrow");
-        prev_was_dot = (type == "punc" && value == ".");
+        if (type == "punc" && value == ".") {
+            prev_was_dot = true;
+        } else if (!is_comment) {
+            prev_was_dot = false;
+        }
         var ret = {
             type    : type,
             value   : value,
@@ -607,29 +609,31 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
         return name;
     });
 
-    var read_regexp = with_eof_error("Unterminated regular expression", function(regexp){
+    var read_regexp = with_eof_error("Unterminated regular expression", function(source) {
         var prev_backslash = false, ch, in_class = false;
         while ((ch = next(true))) if (NEWLINE_CHARS(ch)) {
             parse_error("Unexpected line terminator");
         } else if (prev_backslash) {
-            regexp += "\\" + ch;
+            source += "\\" + ch;
             prev_backslash = false;
         } else if (ch == "[") {
             in_class = true;
-            regexp += ch;
+            source += ch;
         } else if (ch == "]" && in_class) {
             in_class = false;
-            regexp += ch;
+            source += ch;
         } else if (ch == "/" && !in_class) {
             break;
         } else if (ch == "\\") {
             prev_backslash = true;
         } else {
-            regexp += ch;
+            source += ch;
         }
         var mods = read_name();
         try {
-          return token("regexp", new RegExp(regexp, mods));
+            var regexp = new RegExp(source, mods);
+            regexp.raw_source = source;
+            return token("regexp", regexp);
         } catch(e) {
             parse_error(e.message);
         }
@@ -844,9 +848,7 @@ var PRECEDENCE = (function(a, ret){
     {}
 );
 
-var STATEMENTS_WITH_LABELS = array_to_hash([ "for", "do", "while", "switch" ]);
-
-var ATOMIC_START_TOKEN = array_to_hash([ "atom", "num", "string", "regexp", "name" ]);
+var ATOMIC_START_TOKEN = makePredicate([ "atom", "num", "string", "regexp", "name" ]);
 
 /* -----[ Parser ]----- */
 
@@ -854,13 +856,14 @@ function parse($TEXT, options) {
 
     options = defaults(options, {
         bare_returns   : false,
+        ecma           : 8,
         expression     : false,
         filename       : null,
         html5_comments : true,
         shebang        : true,
         strict         : false,
         toplevel       : null,
-    });
+    }, true);
 
     var S = {
         input         : (typeof $TEXT == "string"
@@ -871,6 +874,7 @@ function parse($TEXT, options) {
         prev          : null,
         peeked        : null,
         in_function   : 0,
+        in_async      : -1,
         in_generator  : -1,
         in_directives : true,
         in_loop       : 0,
@@ -941,6 +945,10 @@ function parse($TEXT, options) {
         return S.in_generator === S.in_function;
     }
 
+    function is_in_async() {
+        return S.in_async === S.in_function;
+    }
+
     function semicolon(optional) {
         if (is("punc", ";")) next();
         else if (!optional && !can_insert_semicolon()) unexpected();
@@ -972,28 +980,23 @@ function parse($TEXT, options) {
     };
 
     var statement = embed_tokens(function() {
-        var tmp;
         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) {
+                var token = peek();
+                if (S.token.raw.indexOf("\\") == -1
+                    && (token.nlb
+                        || is_token(token, "eof")
+                        || is_token(token, "punc", ";")
+                        || is_token(token, "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 "template_head":
           case "num":
           case "regexp":
@@ -1002,6 +1005,11 @@ function parse($TEXT, options) {
             return simple_statement();
 
           case "name":
+            if (S.token.value == "async" && is_token(peek(), "keyword", "function")) {
+                next();
+                next();
+                return function_(AST_Defun, false, true);
+            }
             return is_token(peek(), "punc", ":")
                 ? labeled_statement()
                 : simple_statement();
@@ -1026,90 +1034,126 @@ function parse($TEXT, options) {
             }
 
           case "keyword":
-            switch (tmp = S.token.value, next(), tmp) {
+            switch (S.token.value) {
               case "break":
+                next();
                 return break_cont(AST_Break);
 
               case "continue":
+                next();
                 return break_cont(AST_Continue);
 
               case "debugger":
+                next();
                 semicolon();
                 return new AST_Debugger();
 
               case "do":
+                next();
+                var body = in_loop(statement);
+                expect_token("keyword", "while");
+                var condition = parenthesised();
+                semicolon(true);
                 return new AST_Do({
-                    body      : in_loop(statement),
-                    condition : (expect_token("keyword", "while"), tmp = parenthesised(), semicolon(true), tmp)
+                    body      : body,
+                    condition : condition
                 });
 
               case "while":
+                next();
                 return new AST_While({
                     condition : parenthesised(),
                     body      : in_loop(statement)
                 });
 
               case "for":
+                next();
                 return for_();
 
               case "class":
+                next();
                 return class_(AST_DefClass);
 
               case "function":
+                next();
                 return function_(AST_Defun);
 
               case "if":
+                next();
                 return if_();
 
               case "return":
                 if (S.in_function == 0 && !options.bare_returns)
                     croak("'return' outside of function");
+                next();
+                var value = null;
+                if (is("punc", ";")) {
+                    next();
+                } else if (!can_insert_semicolon()) {
+                    value = expression(true);
+                    semicolon();
+                }
                 return new AST_Return({
-                    value: ( is("punc", ";")
-                             ? (next(), null)
-                             : can_insert_semicolon()
-                             ? null
-                             : (tmp = expression(true), semicolon(), tmp) )
+                    value: value
                 });
 
               case "switch":
+                next();
                 return new AST_Switch({
                     expression : parenthesised(),
                     body       : in_loop(switch_body_)
                 });
 
               case "throw":
+                next();
                 if (S.token.nlb)
                     croak("Illegal newline after 'throw'");
+                var value = expression(true);
+                semicolon();
                 return new AST_Throw({
-                    value: (tmp = expression(true), semicolon(), tmp)
+                    value: value
                 });
 
               case "try":
+                next();
                 return try_();
 
               case "var":
-                return tmp = var_(), semicolon(), tmp;
+                next();
+                var node = var_();
+                semicolon();
+                return node;
 
               case "let":
-                return tmp = let_(), semicolon(), tmp;
+                next();
+                var node = let_();
+                semicolon();
+                return node;
 
               case "const":
-                return tmp = const_(), semicolon(), tmp;
+                next();
+                var node = const_();
+                semicolon();
+                return node;
 
               case "with":
                 if (S.input.has_directive("use strict")) {
                     croak("Strict mode may not include a with statement");
                 }
+                next();
                 return new AST_With({
                     expression : parenthesised(),
                     body       : statement()
                 });
 
               case "import":
-                return tmp = import_(), semicolon(), tmp;
+                next();
+                var node = import_();
+                semicolon();
+                return node;
 
               case "export":
+                next();
                 return export_();
             }
         }
@@ -1122,6 +1166,9 @@ function parse($TEXT, options) {
             // Ecma-262, 12.1.1 Static Semantics: Early Errors
             token_error(S.prev, "Yield cannot be used as label inside generators");
         }
+        if (label.name === "await" && is_in_async()) {
+            token_error(S.prev, "await cannot be used as label inside async function");
+        }
         if (find_if(function(l){ return l.name == label.name }, S.labels)) {
             // ECMA-262, 12.12: An ECMAScript program is considered
             // syntactically incorrect if it contains a
@@ -1183,9 +1230,12 @@ function parse($TEXT, options) {
             var is_in = is("operator", "in");
             var is_of = is("name", "of");
             if (is_in || is_of) {
-                if ((init instanceof AST_Definitions) &&
-                        init.definitions.length > 1)
-                    croak("Only one variable declaration allowed in for..in loop");
+                if (init instanceof AST_Definitions) {
+                    if (init.definitions.length > 1)
+                        croak("Only one variable declaration allowed in for..in loop", init.start.line, init.start.col, init.start.pos);
+                } else if (!(is_assignable(init) || (init = to_destructuring(init)) instanceof AST_Destructuring)) {
+                    croak("Invalid left-hand side in for..in loop", init.start.line, init.start.col, init.start.pos);
+                }
                 next();
                 if (is_in) {
                     return for_in(init);
@@ -1235,33 +1285,26 @@ function parse($TEXT, options) {
         });
     };
 
-    var arrow_function = function(args) {
+    var arrow_function = function(start, argnames, is_async) {
         if (S.token.nlb) {
             croak("Unexpected newline before arrow (=>)");
         }
 
         expect_token("arrow", "=>");
 
-        var argnames;
-        if (typeof args.length === 'number') {
-            argnames = args;
-        } else {
-            argnames = args.as_params(croak);
-        }
-
-        var body = is("punc", "{") ?
-            _function_body(true) :
-            _function_body(false);
+        var body = _function_body(is("punc", "{"), false, is_async);
 
         return new AST_Arrow({
-            start    : args.start,
+            start    : start,
             end      : body.end,
+            async    : is_async,
             argnames : argnames,
             body     : body
         });
     };
 
-    var function_ = function(ctor, is_generator_property) {
+    var function_ = function(ctor, is_generator_property, is_async) {
+        if (is_generator_property && is_async) croak("generators cannot be async");
         var start = S.token
 
         var in_statement = ctor === AST_Defun;
@@ -1275,11 +1318,12 @@ function parse($TEXT, options) {
             unexpected();
 
         var args = parameters();
-        var body = _function_body(true, is_generator || is_generator_property, name, args);
+        var body = _function_body(true, is_generator || is_generator_property, is_async, name, args);
         return new ctor({
             start : args.start,
             end   : body.end,
             is_generator: is_generator,
+            async : is_async,
             name  : name,
             argnames: args,
             body  : body
@@ -1346,22 +1390,20 @@ function parse($TEXT, options) {
 
     function parameters() {
         var start = S.token;
-        var first = true;
         var params = [];
         var used_parameters = track_used_binding_identifiers(true, S.input.has_directive("use strict"));
 
         expect("(");
 
         while (!is("punc", ")")) {
-            if (first) {
-                first = false;
-            } else {
-                expect(",");
-            }
-
             var param = parameter(used_parameters);
             params.push(param);
 
+            if (!is("punc", ")")) {
+                expect(",");
+                if (is("punc", ")") && options.ecma < 8) unexpected();
+            }
+
             if (param instanceof AST_Expansion) {
                 break;
             }
@@ -1577,44 +1619,54 @@ function parse($TEXT, options) {
         }
     }
 
-    function params_or_seq_() {
-        var start = S.token
-        expect("(");
-        var first = true;
+    function params_or_seq_(allow_arrows, maybe_sequence) {
+        var spread_token;
+        var invalid_sequence;
+        var trailing_comma;
         var a = [];
+        expect("(");
         while (!is("punc", ")")) {
-            if (first) first = false; else expect(",");
+            if (spread_token) unexpected(spread_token);
             if (is("expand", "...")) {
-                var spread_token = S.token;
+                spread_token = S.token;
+                if (maybe_sequence) invalid_sequence = S.token;
                 next();
                 a.push(new AST_Expansion({
                     start: prev(),
-                    expression: expression(false),
+                    expression: expression(),
                     end: S.token,
                 }));
-                if (!is("punc", ")")) {
-                    unexpected(spread_token);
-                }
             } else {
-                a.push(expression(false));
+                a.push(expression());
+            }
+            if (!is("punc", ")")) {
+                expect(",");
+                if (is("punc", ")")) {
+                    if (options.ecma < 8) unexpected();
+                    trailing_comma = prev();
+                    if (maybe_sequence) invalid_sequence = trailing_comma;
                 }
             }
-        var end = S.token
-        next();
-        return new AST_ArrowParametersOrSeq({
-            start: start,
-            end: end,
-            expressions: a
-        });
+        }
+        expect(")");
+        if (allow_arrows && is("arrow", "=>")) {
+            if (spread_token && trailing_comma) unexpected(trailing_comma);
+        } else if (invalid_sequence) {
+            unexpected(invalid_sequence);
+        }
+        return a;
     }
 
-    function _function_body(block, generator, name, args) {
+    function _function_body(block, generator, is_async, name, args) {
         var loop = S.in_loop;
         var labels = S.labels;
         var current_generator = S.in_generator;
+        var current_async = S.in_async;
         ++S.in_function;
         if (generator)
             S.in_generator = S.in_function;
+        if (is_async)
+            S.in_async = S.in_function;
         if (block)
             S.in_directives = true;
         S.in_loop = 0;
@@ -1634,9 +1686,22 @@ function parse($TEXT, options) {
         S.in_loop = loop;
         S.labels = labels;
         S.in_generator = current_generator;
+        S.in_async = current_async;
         return a;
     }
 
+    function _await_expression() {
+        // Previous token must be "await" and not be interpreted as an identifier
+        if (!is_in_async()) {
+            croak("Unexpected await expression outside async function",
+                S.prev.line, S.prev.col, S.prev.pos);
+        }
+        // the await expression is parsed as a unary expression in Babel
+        return new AST_Await({
+            expression : maybe_unary(true),
+        });
+    }
+
     function _yield_expression() {
         // Previous token must be keyword yield and not be interpret as an identifier
         if (!is_in_generator()) {
@@ -1645,7 +1710,6 @@ function parse($TEXT, options) {
         }
         var star = false;
         var has_expression = true;
-        var tmp;
 
         // Attempt to get expression or star (and then the mandatory expression)
         // behind yield on the same line.
@@ -1836,7 +1900,7 @@ function parse($TEXT, options) {
         var newexp = expr_atom(false), args;
         if (is("punc", "(")) {
             next();
-            args = expr_list(")");
+            args = expr_list(")", options.ecma >= 8);
         } else {
             args = [];
         }
@@ -1852,7 +1916,6 @@ function parse($TEXT, options) {
         var tok = S.token, ret;
         switch (tok.type) {
           case "name":
-          case "keyword":
             ret = _make_symbol(AST_SymbolRef);
             break;
           case "num":
@@ -1882,50 +1945,115 @@ function parse($TEXT, options) {
                 break;
             }
             break;
-          case "operator":
-            if (!is_identifier_string(tok.value)) {
-                croak("Invalid getter/setter name: " + tok.value,
-                    tok.line, tok.col, tok.pos);
-            }
-            ret = _make_symbol(AST_SymbolRef);
-            break;
         }
         next();
         return ret;
     };
 
-    var expr_atom = function(allow_calls) {
+    function to_fun_args(ex, _, __, default_seen_above) {
+        var insert_default = function(ex, default_value) {
+            if (default_value) {
+                return new AST_DefaultAssign({
+                    start: ex.start,
+                    left: ex,
+                    operator: "=",
+                    right: default_value,
+                    end: default_value.end
+                });
+            }
+            return ex;
+        }
+        if (ex instanceof AST_Object) {
+            return insert_default(new AST_Destructuring({
+                start: ex.start,
+                end: ex.end,
+                is_array: false,
+                names: ex.properties.map(to_fun_args)
+            }), default_seen_above);
+        } else if (ex instanceof AST_ObjectKeyVal) {
+            if (ex.key instanceof AST_SymbolRef) {
+                ex.key = to_fun_args(ex.key, 0, [ex.key]);
+            }
+            ex.value = to_fun_args(ex.value, 0, [ex.key]);
+            return insert_default(ex, default_seen_above);
+        } else if (ex instanceof AST_Hole) {
+            return ex;
+        } else if (ex instanceof AST_Destructuring) {
+            ex.names = ex.names.map(to_fun_args);
+            return insert_default(ex, default_seen_above);
+        } else if (ex instanceof AST_SymbolRef) {
+            return insert_default(new AST_SymbolFunarg({
+                name: ex.name,
+                start: ex.start,
+                end: ex.end
+            }), default_seen_above);
+        } else if (ex instanceof AST_Expansion) {
+            ex.expression = to_fun_args(ex.expression);
+            return insert_default(ex, default_seen_above);
+        } else if (ex instanceof AST_Array) {
+            return insert_default(new AST_Destructuring({
+                start: ex.start,
+                end: ex.end,
+                is_array: true,
+                names: ex.elements.map(to_fun_args)
+            }), default_seen_above);
+        } else if (ex instanceof AST_Assign) {
+            return insert_default(to_fun_args(ex.left, undefined, undefined, ex.right), default_seen_above);
+        } else if (ex instanceof AST_DefaultAssign) {
+            ex.left = to_fun_args(ex.left, 0, [ex.left]);
+            return ex;
+        } else {
+            croak("Invalid function parameter", ex.start.line, ex.start.col);
+        }
+    }
+
+    var expr_atom = function(allow_calls, allow_arrows) {
         if (is("operator", "new")) {
             return new_(allow_calls);
         }
         var start = S.token;
+        var async = is("name", "async") && as_atom_node();
         if (is("punc")) {
-            switch (start.value) {
+            switch (S.token.value) {
               case "(":
-                var ex = params_or_seq_();
-                if (is("arrow", "=>")) {
-                    ex.start = start;
-                    ex.end = S.token;
-                    return arrow_function(ex);
+                if (async && !allow_calls) break;
+                var exprs = params_or_seq_(allow_arrows, !async);
+                if (allow_arrows && is("arrow", "=>")) {
+                    return arrow_function(start, exprs.map(to_fun_args), !!async);
                 }
-                ex = ex.as_expr(croak);
+                var ex = async ? new AST_Call({
+                    expression: async,
+                    args: exprs
+                }) : exprs.length == 1 ? exprs[0] : new AST_Sequence({
+                    expressions: exprs
+                });
                 ex.start = start;
                 ex.end = S.token;
                 return subscripts(ex, allow_calls);
               case "[":
                 return subscripts(array_(), allow_calls);
               case "{":
-                return subscripts(object_or_object_destructuring_(), allow_calls);
+                return subscripts(object_or_destructuring_(), allow_calls);
             }
-            unexpected();
+            if (!async) unexpected();
+        }
+        if (allow_arrows && is("name") && is_token(peek(), "arrow")) {
+            var param = new AST_SymbolFunarg({
+                name: S.token.value,
+                start: start,
+                end: start,
+            });
+            next();
+            return arrow_function(start, [param], !!async);
         }
         if (is("keyword", "function")) {
             next();
-            var func = function_(AST_Function);
+            var func = function_(AST_Function, false, !!async);
             func.start = start;
             func.end = prev();
             return subscripts(func, allow_calls);
         }
+        if (async) return subscripts(async, allow_calls);
         if (is("keyword", "class")) {
             next();
             var cls = class_(AST_ClassExpression);
@@ -1936,7 +2064,7 @@ function parse($TEXT, options) {
         if (is("template_head")) {
             return subscripts(template_string(), allow_calls);
         }
-        if (ATOMIC_START_TOKEN[S.token.type]) {
+        if (ATOMIC_START_TOKEN(S.token.type)) {
             return subscripts(as_atom_node(), allow_calls);
         }
         unexpected();
@@ -2000,11 +2128,11 @@ function parse($TEXT, options) {
         });
     });
 
-    var create_accessor = embed_tokens(function(is_generator) {
-        return function_(AST_Accessor, is_generator);
+    var create_accessor = embed_tokens(function(is_generator, is_async) {
+        return function_(AST_Accessor, is_generator, is_async);
     });
 
-    var object_or_object_destructuring_ = embed_tokens(function() {
+    var object_or_destructuring_ = embed_tokens(function object_or_destructuring_() {
         var start = S.token, first = true, a = [];
         expect("{");
         while (!is("punc", "}")) {
@@ -2117,6 +2245,7 @@ function parse($TEXT, options) {
             }
             return name;
         }
+        var is_async = false;
         var is_static = false;
         var is_generator = false;
         var property_token = start;
@@ -2125,6 +2254,11 @@ function parse($TEXT, options) {
             property_token = S.token;
             name = as_property_name();
         }
+        if (name === "async" && !is("punc", "(") && !is("punc", ",") && !is("punc", "}")) {
+            is_async = true;
+            property_token = S.token;
+            name = as_property_name();
+        }
         if (name === null) {
             is_generator = true;
             property_token = S.token;
@@ -2139,10 +2273,11 @@ function parse($TEXT, options) {
                 start       : start,
                 static      : is_static,
                 is_generator: is_generator,
+                async       : is_async,
                 key         : name,
                 quote       : name instanceof AST_SymbolMethod ?
                               property_token.quote : undefined,
-                value       : create_accessor(is_generator),
+                value       : create_accessor(is_generator, is_async),
                 end         : prev()
             });
             return node;
@@ -2190,7 +2325,7 @@ function parse($TEXT, options) {
             next();
         }
 
-        imported_names = import_names(true);
+        imported_names = map_names(true);
 
         if (imported_names || imported_name) {
             expect_token("name", "from");
@@ -2214,26 +2349,40 @@ function parse($TEXT, options) {
         });
     }
 
-    function import_name() {
+    function map_name(is_import) {
+        function make_symbol(type) {
+            return new type({
+                name: as_property_name(),
+                start: prev(),
+                end: prev()
+            });
+        }
+
+        var foreign_type = is_import ? AST_SymbolImportForeign : AST_SymbolExportForeign;
+        var type = is_import ? AST_SymbolImport : AST_SymbolExport;
         var start = S.token;
         var foreign_name;
         var name;
 
-        if (peek().value === "as" && peek().type === "name") {
-            foreign_name = as_symbol(AST_SymbolImportForeign);
+        if (is_import) {
+            foreign_name = make_symbol(foreign_type);
+        } else {
+            name = make_symbol(type);
+        }
+        if (is("name", "as")) {
             next();  // The "as" word
+            if (is_import) {
+                name = make_symbol(type);
+            } else {
+                foreign_name = make_symbol(foreign_type);
             }
-        name = as_symbol(AST_SymbolImport);
-
-        if (foreign_name === undefined) {
-            foreign_name = new AST_SymbolImportForeign({
-                name: name.name,
-                start: name.start,
-                end: name.end,
-            });
+        } else if (is_import) {
+            name = new type(foreign_name);
+        } else {
+            foreign_name = new foreign_type(name);
         }
 
-        return new AST_NameImport({
+        return new AST_NameMapping({
             start: start,
             foreign_name: foreign_name,
             name: name,
@@ -2241,26 +2390,26 @@ function parse($TEXT, options) {
         })
     }
 
-    function import_nameAsterisk(name) {
+    function map_nameAsterisk(is_import, name) {
+        var foreign_type = is_import ? AST_SymbolImportForeign : AST_SymbolExportForeign;
+        var type = is_import ? AST_SymbolImport : AST_SymbolExport;
         var start = S.token;
         var foreign_name;
-
-
         var end = prev();
 
-        name = name || new AST_SymbolImport({
+        name = name || new type({
             name: '*',
             start: start,
             end: end,
         });
 
-        foreign_name = new AST_SymbolImportForeign({
+        foreign_name = new foreign_type({
             name: '*',
             start: start,
             end: end,
         });
 
-        return new AST_NameImport({
+        return new AST_NameMapping({
             start: start,
             foreign_name: foreign_name,
             name: name,
@@ -2268,13 +2417,13 @@ function parse($TEXT, options) {
         })
     }
 
-    function import_names(allow_as) {
+    function map_names(is_import) {
         var names;
         if (is("punc", "{")) {
             next();
             names = [];
             while (!is("punc", "}")) {
-                names.push(import_name());
+                names.push(map_name(is_import));
                 if (is("punc", ",")) {
                     next();
                 }
@@ -2283,11 +2432,11 @@ function parse($TEXT, options) {
         } else if (is("operator", "*")) {
             var name;
             next();
-            if (allow_as && is("name", "as")) {
+            if (is_import && is("name", "as")) {
                 next();  // The "as" word
                 name = as_symbol(AST_SymbolImportForeign);
             }
-            names = [import_nameAsterisk(name)];
+            names = [map_nameAsterisk(is_import, name)];
         }
         return names;
     }
@@ -2295,18 +2444,12 @@ function parse($TEXT, options) {
     function export_() {
         var start = S.token;
         var is_default;
-        var exported_value;
-        var exported_definition;
         var exported_names;
 
         if (is("keyword", "default")) {
             is_default = true;
             next();
-        }
-
-        exported_names = import_names(false);
-
-        if (exported_names) {
+        } else if (exported_names = map_names(false)) {
             if (is("name", "from")) {
                 next();
 
@@ -2338,15 +2481,23 @@ function parse($TEXT, options) {
             }
         }
 
-        var is_definition =
-            is("keyword", "var") || is("keyword", "let") || is("keyword", "const") ||
-            is("keyword", "class") || is("keyword", "function");
-
-        if (is_definition) {
-            exported_definition = statement();
-        } else {
-            exported_value = expression();
+        var node;
+        var exported_value;
+        var exported_definition;
+        if (is("punc", "{")
+            || is_default
+                && (is("keyword", "class") || is("keyword", "function"))
+                && is_token(peek(), "punc")) {
+            exported_value = expression(false);
             semicolon();
+        } else if ((node = statement()) instanceof AST_Definitions && is_default) {
+            unexpected(node.start);
+        } else if (node instanceof AST_Definitions || node instanceof AST_Defun || node instanceof AST_DefClass) {
+            exported_definition = node;
+        } else if (node instanceof AST_SimpleStatement) {
+            exported_value = node.body;
+        } else {
+            unexpected(node.start);
         }
 
         return new AST_Export({
@@ -2377,7 +2528,8 @@ function parse($TEXT, options) {
                 unexpected(tmp);
             }
           case "name":
-            if (tmp.value === "yield" && S.input.has_directive("use strict") && !is_in_generator()) {
+            if (tmp.value == "yield" && !is_token(peek(), "punc", ":")
+                && S.input.has_directive("use strict") && !is_in_generator()) {
                 token_error(tmp, "Unexpected yield identifier inside strict mode");
             }
           case "string":
@@ -2471,11 +2623,9 @@ function parse($TEXT, options) {
         return expr;
     };
 
-    var call_args = embed_tokens(function call_args() {
-        var first = true;
+    var call_args = embed_tokens(function _call_args() {
         var args = [];
         while (!is("punc", ")")) {
-            if (first) first = false; else expect(",");
             if (is("expand", "...")) {
                 next();
                 args.push(new AST_Expansion({
@@ -2485,13 +2635,25 @@ function parse($TEXT, options) {
             } else {
                 args.push(expression(false));
             }
+            if (!is("punc", ")")) {
+                expect(",");
+                if (is("punc", ")") && options.ecma < 8) unexpected();
+            }
         }
         next();
         return args;
     });
 
-    var maybe_unary = function(allow_calls) {
+    var maybe_unary = function(allow_calls, allow_arrows) {
         var start = S.token;
+        if (start.type == "name" && start.value == "await") {
+            if (is_in_async()) {
+                next();
+                return _await_expression();
+            } else if (S.input.has_directive("use strict")) {
+                token_error(S.token, "Unexpected await identifier inside strict mode")
+            }
+        }
         if (is("operator") && UNARY_PREFIX(start.value)) {
             next();
             handle_regexp();
@@ -2500,8 +2662,9 @@ function parse($TEXT, options) {
             ex.end = prev();
             return ex;
         }
-        var val = expr_atom(allow_calls);
+        var val = expr_atom(allow_calls, allow_arrows);
         while (is("operator") && UNARY_POSTFIX(S.token.value) && !S.token.nlb) {
+            if (val instanceof AST_Arrow) unexpected();
             val = make_unary(AST_UnaryPostfix, S.token, val);
             val.start = start;
             val.end = S.token;
@@ -2549,7 +2712,7 @@ function parse($TEXT, options) {
     };
 
     function expr_ops(no_in) {
-        return expr_op(maybe_unary(true), 0, no_in);
+        return expr_op(maybe_unary(true, true), 0, no_in);
     };
 
     var maybe_conditional = function(no_in) {
@@ -2630,22 +2793,6 @@ function parse($TEXT, options) {
             }
         }
 
-        if (start.type == "punc" && start.value == "(" && peek().value == ")") {
-            next();
-            next();
-            return arrow_function([]);
-        }
-
-        if (is("name") && is_token(peek(), "arrow")) {
-            var param = new AST_SymbolFunarg({
-                name: start.value,
-                start: start,
-                end: start,
-            });
-            next();
-            return arrow_function([param])
-        }
-
         var left = maybe_conditional(no_in);
         var val = S.token.value;
 
@@ -2674,16 +2821,7 @@ function parse($TEXT, options) {
             next();
             commas = true;
         }
-        if (exprs.length == 1) {
-            var expr = exprs[0];
-            if (!(expr instanceof AST_SymbolRef) || !is("arrow", "=>")) return expr;
-            return arrow_function(new AST_ArrowParametersOrSeq({
-                start: expr.start,
-                end: expr.end,
-                expressions: [expr]
-            }));
-        }
-        return new AST_Sequence({
+        return exprs.length == 1 ? exprs[0] : new AST_Sequence({
             start       : start,
             expressions : exprs,
             end         : peek()

lib/propmangle.js

@@ -96,7 +96,8 @@ function mangle_properties(ast, options) {
         reserved: null,
     });
 
-    var reserved = options.reserved || [];
+    var reserved = options.reserved;
+    if (!Array.isArray(reserved)) reserved = [];
     if (!options.builtins) find_builtins(reserved);
 
     var cache = options.cache;

lib/scope.js

@@ -51,7 +51,6 @@ function SymbolDef(scope, index, orig) {
     this.global = false;
     this.export = false;
     this.mangled_name = null;
-    this.object_destructuring_arg = false;
     this.undeclared = false;
     this.index = index;
     this.id = SymbolDef.next_id++;
@@ -65,7 +64,6 @@ SymbolDef.prototype = {
 
         return (this.global && !options.toplevel)
             || this.export
-            || this.object_destructuring_arg
             || this.undeclared
             || (!options.eval && (this.scope.uses_eval || this.scope.uses_with))
             || (options.keep_fnames
@@ -87,7 +85,7 @@ SymbolDef.prototype = {
             if (options.ie8 && sym instanceof AST_SymbolLambda)
                 s = s.parent_scope;
             var def;
-            if (this.defun && (def = this.defun.variables.get(this.name))) {
+            if (def = this.redefined()) {
                 this.mangled_name = def.mangled_name || def.name;
             } else
                 this.mangled_name = s.next_mangled(options, this);
@@ -95,6 +93,9 @@ SymbolDef.prototype = {
                 cache.set(this.name, this.mangled_name);
             }
         }
+    },
+    redefined: function() {
+        return this.defun && this.defun.variables.get(this.name);
     }
 };
 
@@ -111,8 +112,6 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
     var labels = new Dictionary();
     var defun = null;
     var in_destructuring = null;
-    var in_export = false;
-    var in_block = 0;
     var for_scopes = [];
     var tw = new TreeWalker(function(node, descend){
         if (node.is_block_scope()) {
@@ -133,7 +132,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
             scope = save_scope;
             return true;
         }
-        if (node instanceof AST_Destructuring && node.is_array === false) {
+        if (node instanceof AST_Destructuring) {
             in_destructuring = node;  // These don't nest
             descend();
             in_destructuring = null;
@@ -152,22 +151,6 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
             labels = save_labels;
             return true;        // don't descend again in TreeWalker
         }
-        if (node instanceof AST_Export) {
-            in_export = true;
-            descend();
-            in_export = false;
-            return true;
-        }
-        if (node instanceof AST_BlockStatement
-            || node instanceof AST_Switch
-            || node instanceof AST_Try
-            || node instanceof AST_Catch
-            || node instanceof AST_Finally) {
-            in_block++;
-            descend();
-            in_block--;
-            return true;
-        }
         if (node instanceof AST_LabeledStatement) {
             var l = node.label;
             if (labels.has(l.name)) {
@@ -186,15 +169,12 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
         if (node instanceof AST_Symbol) {
             node.scope = scope;
         }
-        if (node instanceof AST_SymbolFunarg) {
-            node.object_destructuring_arg = !!in_destructuring;
-        }
         if (node instanceof AST_Label) {
             node.thedef = node;
             node.references = [];
         }
         if (node instanceof AST_SymbolLambda) {
-            defun.def_function(node, in_export, in_block);
+            defun.def_function(node);
         }
         else if (node instanceof AST_SymbolDefun) {
             // Careful here, the scope where this should be defined is
@@ -206,23 +186,24 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
             while (parent_lambda.is_block_scope()) {
                 parent_lambda = parent_lambda.parent_scope;
             }
-            (node.scope = parent_lambda).def_function(node, in_export, in_block);
+            mark_export((node.scope = parent_lambda).def_function(node), 1);
         }
         else if (node instanceof AST_SymbolClass) {
-            defun.def_variable(node, in_export, in_block);
+            mark_export(defun.def_variable(node), 1);
         }
         else if (node instanceof AST_SymbolImport) {
-            scope.def_variable(node, in_export, in_block);
+            scope.def_variable(node);
         }
         else if (node instanceof AST_SymbolDefClass) {
             // This deals with the name of the class being available
             // inside the class.
-            (node.scope = defun.parent_scope).def_function(node, in_export, in_block);
+            mark_export((node.scope = defun.parent_scope).def_function(node), 1);
         }
         else if (node instanceof AST_SymbolVar
             || node instanceof AST_SymbolLet
             || node instanceof AST_SymbolConst) {
-            var def = ((node instanceof AST_SymbolBlockDeclaration) ? scope : defun).def_variable(node, in_export, in_block);
+            var def = ((node instanceof AST_SymbolBlockDeclaration) ? scope : defun).def_variable(node);
+            if (!(node instanceof AST_SymbolFunarg)) mark_export(def, 2);
             def.destructuring = in_destructuring;
             if (defun !== scope) {
                 node.mark_enclosed(options);
@@ -234,7 +215,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
             }
         }
         else if (node instanceof AST_SymbolCatch) {
-            scope.def_variable(node, in_export, in_block).defun = defun;
+            scope.def_variable(node).defun = defun;
         }
         else if (node instanceof AST_LabelRef) {
             var sym = labels.get(node.name);
@@ -245,28 +226,32 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
             }));
             node.thedef = sym;
         }
+        if (!(scope instanceof AST_Toplevel) && (node instanceof AST_Export || node instanceof AST_Import)) {
+            js_error(
+                node.TYPE + " statement may only appear at top level",
+                node.start.file,
+                node.start.line,
+                node.start.col,
+                node.start.pos
+            );
+        }
+
+        function mark_export(def, level) {
+            if (in_destructuring) {
+                var i = 0;
+                do {
+                    level++;
+                } while (tw.parent(i++) !== in_destructuring);
+            }
+            var node = tw.parent(level);
+            def.export = node instanceof AST_Export;
+        }
     });
     self.walk(tw);
 
     // pass 2: find back references and eval
-    var func = null;
-    var cls = null;
-    var globals = self.globals = new Dictionary();
+    self.globals = new Dictionary();
     var tw = new TreeWalker(function(node, descend){
-        if (node instanceof AST_Lambda) {
-            var prev_func = func;
-            func = node;
-            descend();
-            func = prev_func;
-            return true;
-        }
-        if (node instanceof AST_Class) {
-            var prev_cls = cls;
-            cls = node;
-            descend();
-            cls = prev_cls;
-            return true;
-        }
         if (node instanceof AST_LoopControl && node.label) {
             node.label.thedef.references.push(node);
             return true;
@@ -278,17 +263,27 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
                     s.uses_eval = true;
                 }
             }
-            var sym = node.scope.find_variable(name);
-            if (node.scope instanceof AST_Lambda && name == "arguments") {
-                node.scope.uses_arguments = true;
-            }
-            if (!sym) {
+            var sym;
+            if (tw.parent() instanceof AST_NameMapping && tw.parent(1).module_name
+                || !(sym = node.scope.find_variable(name))) {
                 sym = self.def_global(node);
+            } else if (sym.scope instanceof AST_Lambda && name == "arguments") {
+                sym.scope.uses_arguments = true;
             }
             node.thedef = sym;
             node.reference(options);
             return true;
         }
+        // ensure mangling works if catch reuses a scope variable
+        var def;
+        if (node instanceof AST_SymbolCatch && (def = node.definition().redefined())) {
+            var s = node.scope;
+            while (s) {
+                push_uniq(s.enclosed, def);
+                if (s === def.scope) break;
+                s = s.parent_scope;
+            }
+        }
     });
     self.walk(tw);
 
@@ -351,22 +346,13 @@ AST_Scope.DEFMETHOD("init_scope_vars", function(parent_scope){
     this.cname = -1;                    // the current index for mangling functions/variables
 });
 
-AST_Node.DEFMETHOD("is_block_scope", function(){
-    return false; // Behaviour will be overridden by AST_Block
-});
-
-AST_Block.DEFMETHOD("is_block_scope", function(){
-    return (
-        !(this instanceof AST_Lambda) &&
-        !(this instanceof AST_Toplevel) &&
-        !(this instanceof AST_Class) &&
-        !(this instanceof AST_SwitchBranch)
-    );
-});
-
-AST_IterationStatement.DEFMETHOD("is_block_scope", function(){
-     return true;
-});
+AST_Node.DEFMETHOD("is_block_scope", return_false);
+AST_Class.DEFMETHOD("is_block_scope", return_false);
+AST_Lambda.DEFMETHOD("is_block_scope", return_false);
+AST_Toplevel.DEFMETHOD("is_block_scope", return_false);
+AST_SwitchBranch.DEFMETHOD("is_block_scope", return_false);
+AST_Block.DEFMETHOD("is_block_scope", return_true);
+AST_IterationStatement.DEFMETHOD("is_block_scope", return_true);
 
 AST_Lambda.DEFMETHOD("init_scope_vars", function(){
     AST_Scope.prototype.init_scope_vars.apply(this, arguments);
@@ -404,24 +390,18 @@ AST_Scope.DEFMETHOD("find_variable", function(name){
         || (this.parent_scope && this.parent_scope.find_variable(name));
 });
 
-AST_Scope.DEFMETHOD("def_function", function(symbol, in_export, in_block){
-    this.functions.set(symbol.name, this.def_variable(symbol, in_export, in_block));
+AST_Scope.DEFMETHOD("def_function", function(symbol){
+    var def = this.def_variable(symbol);
+    this.functions.set(symbol.name, def);
+    return def;
 });
 
-AST_Scope.DEFMETHOD("def_variable", function(symbol, in_export, in_block){
+AST_Scope.DEFMETHOD("def_variable", function(symbol){
     var def;
     if (!this.variables.has(symbol.name)) {
         def = new SymbolDef(this, this.variables.size(), symbol);
         this.variables.set(symbol.name, def);
-        def.object_destructuring_arg = symbol.object_destructuring_arg;
-        if (in_export) {
-            def.export = true;
-        }
-        if (in_block && symbol instanceof AST_SymbolBlockDeclaration) {
-            def.global = false;
-        } else {
         def.global = !this.parent_scope;
-        }
     } else {
         def = this.variables.get(symbol.name);
         def.orig.push(symbol);
@@ -470,18 +450,11 @@ AST_Function.DEFMETHOD("next_mangled", function(options, def){
 
 AST_Symbol.DEFMETHOD("unmangleable", function(options){
     var def = this.definition();
-    return def && def.unmangleable(options);
-});
-
-// property accessors are not mangleable
-AST_SymbolAccessor.DEFMETHOD("unmangleable", function(){
-    return true;
+    return !def || def.unmangleable(options);
 });
 
 // labels are always mangleable
-AST_Label.DEFMETHOD("unmangleable", function(){
-    return false;
-});
+AST_Label.DEFMETHOD("unmangleable", return_false);
 
 AST_Symbol.DEFMETHOD("unreferenced", function(){
     return this.definition().references.length == 0
@@ -492,13 +465,9 @@ AST_Symbol.DEFMETHOD("undeclared", function(){
     return this.definition().undeclared;
 });
 
-AST_LabelRef.DEFMETHOD("undeclared", function(){
-    return false;
-});
+AST_LabelRef.DEFMETHOD("undeclared", return_false);
 
-AST_Label.DEFMETHOD("undeclared", function(){
-    return false;
-});
+AST_Label.DEFMETHOD("undeclared", return_false);
 
 AST_Symbol.DEFMETHOD("definition", function(){
     return this.thedef;
@@ -509,7 +478,7 @@ AST_Symbol.DEFMETHOD("global", function(){
 });
 
 AST_Toplevel.DEFMETHOD("_default_mangler_options", function(options){
-    return defaults(options, {
+    options = defaults(options, {
         eval        : false,
         ie8         : false,
         keep_classnames: false,
@@ -517,6 +486,8 @@ AST_Toplevel.DEFMETHOD("_default_mangler_options", function(options){
         reserved    : [],
         toplevel    : false,
     });
+    if (!Array.isArray(options.reserved)) options.reserved = [];
+    return options;
 });
 
 AST_Toplevel.DEFMETHOD("mangle_names", function(options){
@@ -574,7 +545,6 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
     });
     this.walk(tw);
     to_mangle.forEach(function(def){
-        if (def.destructuring && !def.destructuring.is_array) return;
         def.mangle(options);
     });
 
@@ -585,111 +555,69 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
 
 AST_Toplevel.DEFMETHOD("compute_char_frequency", function(options){
     options = this._default_mangler_options(options);
-    var tw = new TreeWalker(function(node){
-        if (node instanceof AST_Constant)
-            base54.consider(node.print_to_string());
-        else if (node instanceof AST_Return)
-            base54.consider("return");
-        else if (node instanceof AST_Throw)
-            base54.consider("throw");
-        else if (node instanceof AST_Continue)
-            base54.consider("continue");
-        else if (node instanceof AST_Break)
-            base54.consider("break");
-        else if (node instanceof AST_Debugger)
-            base54.consider("debugger");
-        else if (node instanceof AST_Directive)
-            base54.consider(node.value);
-        else if (node instanceof AST_While)
-            base54.consider("while");
-        else if (node instanceof AST_Do)
-            base54.consider("do while");
-        else if (node instanceof AST_If) {
-            base54.consider("if");
-            if (node.alternative) base54.consider("else");
+    try {
+        AST_Node.prototype.print = function(stream, force_parens) {
+            this._print(stream, force_parens);
+            if (this instanceof AST_Symbol && !this.unmangleable(options)) {
+                base54.consider(this.name, -1);
+            } else if (options.properties) {
+                if (this instanceof AST_Dot) {
+                    base54.consider(this.property, -1);
+                } else if (this instanceof AST_Sub) {
+                    skip_string(this.property);
+                }
+            }
+        };
+        base54.consider(this.print_to_string(), 1);
+    } finally {
+        AST_Node.prototype.print = AST_Node.prototype._print;
     }
-        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)
-            base54.consider("for");
-        else if (node instanceof AST_ForIn)
-            base54.consider("for in");
-        else if (node instanceof AST_Switch)
-            base54.consider("switch");
-        else if (node instanceof AST_Case)
-            base54.consider("case");
-        else if (node instanceof AST_Default)
-            base54.consider("default");
-        else if (node instanceof AST_With)
-            base54.consider("with");
-        else if (node instanceof AST_ObjectSetter)
-            base54.consider("set" + (typeof node.key === "string" ? node.key : ""));
-        else if (node instanceof AST_ObjectGetter)
-            base54.consider("get" + (typeof node.key === "string" ? node.key : ""));
-        else if (node instanceof AST_ObjectKeyVal && typeof node.key === "string")
-            base54.consider(node.key);
-        else if (node instanceof AST_ConciseMethod && typeof node.key === "string")
-            base54.consider(node.key);
-        else if (node instanceof AST_New)
-            base54.consider("new");
-        else if (node instanceof AST_This)
-            base54.consider("this");
-        else if (node instanceof AST_Super)
-            base54.consider("super");
-        else if (node instanceof AST_Try)
-            base54.consider("try");
-        else if (node instanceof AST_Catch)
-            base54.consider("catch");
-        else if (node instanceof AST_Finally)
-            base54.consider("finally");
-        else if (node instanceof AST_Yield)
-            base54.consider("yield");
-        else if (node instanceof AST_Symbol && node.unmangleable(options))
-            base54.consider(node.name);
-        else if (node instanceof AST_Unary || node instanceof AST_Binary)
-            base54.consider(node.operator);
-        else if (node instanceof AST_Dot)
-            base54.consider(node.property);
-    });
-    this.walk(tw);
     base54.sort();
+
+    function skip_string(node) {
+        if (node instanceof AST_String) {
+            base54.consider(node.value, -1);
+        } else if (node instanceof AST_Conditional) {
+            skip_string(node.consequent);
+            skip_string(node.alternative);
+        } else if (node instanceof AST_Sequence) {
+            skip_string(node.expressions[node.expressions.length - 1]);
+        }
+    }
 });
 
 var base54 = (function() {
-    var string = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_0123456789";
+    var leading = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_".split("");
+    var digits = "0123456789".split("");
     var chars, frequency;
     function reset() {
         frequency = Object.create(null);
-        chars = string.split("").map(function(ch){ return ch.charCodeAt(0) });
-        chars.forEach(function(ch){ frequency[ch] = 0 });
+        leading.forEach(function(ch) {
+            frequency[ch] = 0;
+        });
+        digits.forEach(function(ch) {
+            frequency[ch] = 0;
+        });
     }
-    base54.consider = function(str){
+    base54.consider = function(str, delta) {
         for (var i = str.length; --i >= 0;) {
-            var code = str.charCodeAt(i);
-            if (code in frequency) ++frequency[code];
+            frequency[str[i]] += delta;
         }
     };
-    base54.sort = function() {
-        chars = mergeSort(chars, function(a, b){
-            if (is_digit(a) && !is_digit(b)) return 1;
-            if (is_digit(b) && !is_digit(a)) return -1;
+    function compare(a, b) {
         return frequency[b] - frequency[a];
-        });
+    }
+    base54.sort = function() {
+        chars = mergeSort(leading, compare).concat(mergeSort(digits, compare));
     };
     base54.reset = reset;
     reset();
-    base54.get = function(){ return chars };
-    base54.freq = function(){ return frequency };
     function base54(num) {
         var ret = "", base = 54;
         num++;
         do {
             num--;
-            ret += String.fromCharCode(chars[num % base]);
+            ret += chars[num % base];
             num = Math.floor(num / base);
             base = 64;
         } while (num > 0);

lib/transform.js

@@ -199,6 +199,10 @@ TreeTransformer.prototype = new TreeWalker;
         if (self.expression) self.expression = self.expression.transform(tw);
     });
 
+    _(AST_Await, function(self, tw){
+        self.expression = self.expression.transform(tw);
+    });
+
     _(AST_Unary, function(self, tw){
         self.expression = self.expression.transform(tw);
     });
@@ -239,6 +243,24 @@ TreeTransformer.prototype = new TreeWalker;
         self.expression = self.expression.transform(tw);
     });
 
+    _(AST_NameMapping, function(self, tw) {
+        self.foreign_name = self.foreign_name.transform(tw);
+        self.name = self.name.transform(tw);
+    });
+
+    _(AST_Import, function(self, tw) {
+        if (self.imported_name) self.imported_name = self.imported_name.transform(tw);
+        if (self.imported_names) do_list(self.imported_names, tw);
+        self.module_name = self.module_name.transform(tw);
+    });
+
+    _(AST_Export, function(self, tw) {
+        if (self.exported_definition) self.exported_definition = self.exported_definition.transform(tw);
+        if (self.exported_value) self.exported_value = self.exported_value.transform(tw);
+        if (self.exported_names) do_list(self.exported_names, tw);
+        if (self.module_name) self.module_name = self.module_name.transform(tw);
+    });
+
     _(AST_TemplateString, function(self, tw) {
         for (var i = 0; i < self.segments.length; i++) {
             if (!(self.segments[i] instanceof AST_TemplateSegment)) {

lib/utils.js

@@ -43,13 +43,6 @@
 
 "use strict";
 
-function array_to_hash(a) {
-    var ret = Object.create(null);
-    for (var i = 0; i < a.length; ++i)
-        ret[a[i]] = true;
-    return ret;
-};
-
 function slice(a, start) {
     return Array.prototype.slice.call(a, start || 0);
 };

package.json

@@ -1,10 +1,10 @@
 {
   "name": "uglify-es",
   "description": "JavaScript parser, mangler/compressor and beautifier toolkit",
-  "homepage": "http://lisperator.net/uglifyjs",
+  "homepage": "https://github.com/mishoo/UglifyJS2/tree/harmony",
   "author": "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)",
   "license": "BSD-2-Clause",
-  "version": "3.0.4",
+  "version": "3.0.20",
   "engines": {
     "node": ">=0.8.0"
   },
@@ -33,22 +33,12 @@
     "source-map": "~0.5.1"
   },
   "devDependencies": {
-    "acorn": "~0.6.0",
-    "escodegen": "~1.3.3",
-    "esfuzz": "~0.3.1",
-    "estraverse": "~1.5.1",
-    "mocha": "~2.3.4"
-  },
-  "optionalDependencies": {
-    "uglify-to-browserify": "~1.0.0"
-  },
-  "browserify": {
-    "transform": [
-      "uglify-to-browserify"
-    ]
+    "acorn": "~5.0.3",
+    "mocha": "~2.3.4",
+    "semver": "~5.3.0"
   },
   "scripts": {
     "test": "node test/run-tests.js"
   },
-  "keywords": ["uglify", "uglify-js", "minify", "minifier"]
+  "keywords": ["uglify", "uglify-js", "uglify-es", "minify", "minifier", "es5", "es6", "es2015"]
 }

test/benchmark.js

@@ -4,12 +4,13 @@
 "use strict";
 
 var createHash = require("crypto").createHash;
+var fetch = require("./fetch");
 var fork = require("child_process").fork;
 var args = process.argv.slice(2);
 if (!args.length) {
     args.push("-mc");
 }
-args.push("--stats");
+args.push("--timings");
 var urls = [
     "https://code.jquery.com/jquery-3.2.1.js",
     "https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.6.4/angular.js",
@@ -29,12 +30,7 @@ function done() {
             var info = results[url];
             console.log();
             console.log(url);
-            var elapsed = 0;
-            console.log(info.log.replace(/Elapsed: ([0-9]+)\s*/g, function(match, time) {
-                elapsed += 1e-3 * parseInt(time);
-                return "";
-            }));
-            console.log("Run-time:", elapsed.toFixed(3), "s");
+            console.log(info.log);
             console.log("Original:", info.input, "bytes");
             console.log("Uglified:", info.output, "bytes");
             console.log("SHA1 sum:", info.sha1);
@@ -57,7 +53,8 @@ urls.forEach(function(url) {
         output: 0,
         log: ""
     };
-    require(url.slice(0, url.indexOf(":"))).get(url, function(res) {
+    fetch(url, function(err, res) {
+        if (err) throw err;
         var uglifyjs = fork("bin/uglifyjs", args, { silent: true });
         res.on("data", function(data) {
             results[url].input += data.length;

test/compress/arrow.js

@@ -135,3 +135,148 @@ arrow_with_regexp: {
         num => /\d{11,14}/.test( num )
     }
 }
+
+arrow_unused: {
+    options = {
+        toplevel: false,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        top => dog;
+        let fn = a => { console.log(a * a); };
+        let u = (x, y) => x - y + g;
+        (() => { console.log("0"); })();
+        !function(x) {
+            (() => { console.log("1"); })();
+            let unused = x => { console.log(x); };
+            let baz = e => e + e;
+            console.log(baz(x));
+        }(1);
+        fn(3);
+    }
+    expect: {
+        let fn = a => { console.log(a * a); };
+        let u = (x, y) => x - y + g;
+        (() => { console.log("0"); })();
+        !function(x) {
+            (() => { console.log("1"); })();
+            let baz = e => e + e;
+            console.log(baz(x));
+        }(1);
+        fn(3);
+    }
+    expect_stdout: [ "0", "1", "2", "9" ]
+    node_version: ">=6"
+}
+
+arrow_unused_toplevel: {
+    options = {
+        toplevel: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        top => dog;
+        let fn = a => { console.log(a * a); };
+        let u = (x, y) => x - y + g;
+        (() => { console.log("0"); })();
+        !function(x) {
+            (() => { console.log("1"); })();
+            let unused = x => { console.log(x); };
+            let baz = e => e + e;
+            console.log(baz(x));
+        }(1);
+        fn(3);
+    }
+    expect: {
+        let fn = a => { console.log(a * a); };
+        (() => { console.log("0"); })();
+        !function(x) {
+            (() => { console.log("1"); })();
+            let baz = e => e + e;
+            console.log(baz(x));
+        }(1);
+        fn(3);
+    }
+    expect_stdout: [ "0", "1", "2", "9" ]
+    node_version: ">=6"
+}
+
+no_leading_parentheses: {
+    input: {
+        (x,y) => x(y);
+        async (x,y) => await x(y);
+    }
+    expect_exact: "(x,y)=>x(y);async(x,y)=>await x(y);"
+}
+
+async_identifiers: {
+    options = {
+        arrows: true,
+        ecma: 6,
+    }
+    input: {
+        var async = function(x){ console.log("async", x); };
+        var await = function(x){ console.log("await", x); };
+        async(1);
+        await(2);
+    }
+    expect: {
+        var async = x => { console.log("async", x); };
+        var await = x => { console.log("await", x); };
+        async(1);
+        await(2);
+    }
+    expect_stdout: [
+        "async 1",
+        "await 2",
+    ]
+    node_version: ">=4"
+}
+
+async_function_expression: {
+    options = {
+        arrows: true,
+        ecma: 6,
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        var named = async function foo() {
+            await bar(1 + 0) + (2 + 0);
+        }
+        var anon = async function() {
+            await (1 + 0) + bar(2 + 0);
+        }
+    }
+    expect: {
+        var named = async function foo() {
+            await bar(1);
+        };
+        var anon = async () => {
+            await 1, bar(2);
+        };
+    }
+}
+
+issue_27: {
+    options = {
+        arrows: true,
+        collapse_vars: true,
+        ecma: 6,
+        unused: true,
+    }
+    input: {
+        (function(jQuery) {
+            var $;
+            $ = jQuery;
+            $("body").addClass("foo");
+        })(jQuery);
+    }
+    expect: {
+        (jQuery => {
+            jQuery("body").addClass("foo");
+        })(jQuery);
+    }
+}

test/compress/async.js

@@ -0,0 +1,254 @@
+await_precedence: {
+    input: {
+        async function f1() { await x + y; }
+        async function f2() { await (x + y); }
+    }
+    expect_exact: "async function f1(){await x+y}async function f2(){await(x+y)}"
+}
+
+async_function_declaration: {
+    options = {
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        async function f0() {}
+        async function f1() { await x + y; }
+        async function f2() { await (x + y); }
+        async function f3() { await x + await y; }
+        async function f4() { await (x + await y); }
+        async function f5() { await x; await y; }
+        async function f6() { await x, await y; }
+    }
+    expect: {
+        async function f0() {}
+        async function f1() { await x, y; }
+        async function f2() { await (x + y); }
+        async function f3() { await x, await y; }
+        async function f4() { await (x + await y); }
+        async function f5() { await x; await y; }
+        async function f6() { await x, await y; }
+    }
+}
+
+async_function_expression: {
+    options = {
+        evaluate: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var named = async function foo() {
+            await bar(1 + 0) + (2 + 0);
+        }
+        var anon = async function() {
+            await (1 + 0) + bar(2 + 0);
+        }
+    }
+    expect: {
+        var named = async function() {
+            await bar(1);
+        };
+        var anon = async function() {
+            await 1, bar(2);
+        };
+    }
+}
+
+async_class: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        class Foo {
+            async m1() {
+                return await foo(1 + 2);
+            }
+            static async m2() {
+                return await foo(3 + 4);
+            }
+        }
+    }
+    expect: {
+        class Foo {
+            async m1() {
+                return await foo(3);
+            }
+            static async m2() {
+                return await foo(7);
+            }
+        }
+    }
+}
+
+async_object_literal: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        var obj = {
+            async a() {
+                await foo(1 + 0);
+            },
+            anon: async function(){
+                await foo(2 + 0);
+            }
+        };
+    }
+    expect: {
+        var obj = {
+            async a() {
+                await foo(1);
+            },
+            anon: async function() {
+                await foo(2);
+            }
+        };
+    }
+}
+
+async_export: {
+    input: {
+        export async function run() {};
+        export default async function def() {};
+    }
+    expect: {
+        export async function run() {};
+        export default async function def() {};
+    }
+}
+
+async_inline: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        evaluate: true,
+        inline: true,
+        negate_iife: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        (async function(){ return await 3; })();
+        (async function(x){ await console.log(x); })(4);
+
+        function echo(x) { return x; }
+        echo( async function(){ return await 1; }() );
+        echo( async function(x){ await console.log(x); }(2) );
+
+        function top() { console.log("top"); }
+        top();
+
+        async function async_top() { console.log("async_top"); }
+        async_top();
+    }
+    expect: {
+        !async function(){await 3}();
+        !async function(x){await console.log(4)}();
+
+        function echo(x){return x}
+        echo(async function(){return await 1}());
+        echo(async function(x){await console.log(2)}());
+
+        console.log("top");
+
+        !async function(){console.log("async_top")}();
+    }
+    expect_stdout: [
+        "4",
+        "2",
+        "top",
+        "async_top",
+    ]
+    node_version: ">=8"
+}
+
+async_identifiers: {
+    input: {
+        var async = function(x){ console.log("async", x); };
+        var await = function(x){ console.log("await", x); };
+        async(1);
+        await(2);
+    }
+    expect: {
+        var async = function(x){ console.log("async", x); };
+        var await = function(x){ console.log("await", x); };
+        async(1);
+        await(2);
+    }
+    expect_stdout: [
+        "async 1",
+        "await 2",
+    ]
+}
+
+async_shorthand_property: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        function print(o) { console.log(o.async + " " + o.await); }
+        var async = "Async", await = "Await";
+
+        print({ async });
+        print({ await });
+        print({ async, await });
+        print({ await, async });
+
+        print({ async: async });
+        print({ await: await });
+        print({ async: async, await: await });
+        print({ await: await, async: async });
+    }
+    expect: {
+        function a(a) { console.log(a.async + " " + a.await); }
+        var n = "Async", c = "Await";
+
+        a({ async: n });
+        a({ await: c });
+        a({ async: n, await: c });
+        a({ await: c, async: n });
+
+        a({ async: n });
+        a({ await: c });
+        a({ async: n, await: c });
+        a({ await: c, async: n });
+    }
+    expect_stdout: [
+        "Async undefined",
+        "undefined Await",
+        "Async Await",
+        "Async Await",
+        "Async undefined",
+        "undefined Await",
+        "Async Await",
+        "Async Await",
+    ]
+    node_version: ">=4"
+}
+
+async_arrow: {
+    input: {
+        let a1 = async x => await foo(x);
+        let a2 = async () => await bar();
+        let a3 = async (x) => await baz(x);
+        let a4 = async (x, y) => { await far(x, y); }
+        let a5 = async ({x = [1], y: z = 2}) => { await wow(x, z); }
+    }
+    expect: {
+        let a1 = async x => await foo(x);
+        let a2 = async () => await bar();
+        let a3 = async (x) => await baz(x);
+        let a4 = async (x, y) => { await far(x, y); }
+        let a5 = async ({x = [1], y: z = 2}) => { await wow(x, z); }
+    }
+}
+
+async_arrow_wait: {
+    input: {
+        var a = async (x, y) => await x(y);
+    }
+    expect_exact: "var a=async(x,y)=>await x(y);"
+}

test/compress/block-scope.js

@@ -106,32 +106,34 @@ regression_block_scope_resolves: {
         (function () {
             if (1) {
                 let x;
-                const y;
+                const y = 1;
                 class Zee {};
             }
             if (1) {
                 let ex;
-                const why;
+                const why = 2;
                 class Zi {};
             }
-            console.log(x, y, Zee, ex, why, Zi);
+            console.log(typeof x, typeof y, typeof Zee, typeof ex, typeof why, typeof Zi);
         }());
     }
     expect: {
         (function () {
             if (1) {
-                let o;
-                const n;
-                class c {};
+                let e;
+                const o = 1;
+                class t {};
             }
             if (1) {
-                let o;
-                const n;
-                class c {};
+                let e;
+                const o = 2;
+                class t {};
             }
-            console.log(x, y, Zee, ex, why, Zi);
+            console.log(typeof x, typeof y, typeof Zee, typeof ex, typeof why, typeof Zi);
         }());
     }
+    expect_stdout: "undefined undefined undefined undefined undefined undefined"
+    node_version: ">=6"
 }
 
 switch_block_scope_mangler: {
@@ -153,25 +155,37 @@ switch_block_scope_mangler: {
                     console.log(cat);
             }
         };
+        fn(1);
+        fn(2);
+        fn(3);
     }
     expect: {
-        var fn = function(o) {
-            switch (o) {
+        var fn = function(e) {
+            switch (e) {
               case 1:
-                let e = o + 1
-                let c = o + 4;
-                console.log(e, c);
+                let l = e + 1
+                let o = e + 4;
+                console.log(l, o);
                 break;
 
               case 2:
-                let l = o + 2;
-                console.log(l);
+                let n = e + 2;
+                console.log(n);
                 break;
 
               default:
-                let a = o + 3;
-                console.log(a);
+                let c = e + 3;
+                console.log(c);
             }
         };
+        fn(1);
+        fn(2);
+        fn(3);
     }
+    expect_stdout: [
+        "2 5",
+        "4",
+        "6",
+    ]
+    node_version: ">=6"
 }

test/compress/blocks.js

@@ -47,3 +47,142 @@ keep_some_blocks: {
         } else stuff();
     }
 }
+
+issue_1664: {
+    input: {
+        var a = 1;
+        function f() {
+            if (undefined) a = 2;
+            {
+                function undefined() {}
+                undefined();
+            }
+        }
+        f();
+        console.log(a);
+    }
+    expect: {
+        var a = 1;
+        function f() {
+            if (undefined) a = 2;
+            {
+                function undefined() {}
+                undefined();
+            }
+        }
+        f();
+        console.log(a);
+    }
+    expect_stdout: "1"
+    node_version: ">=6"
+}
+
+issue_1672_for: {
+    input: {
+        switch (function() {
+            return xxx;
+        }) {
+          case xxx:
+            for (; console.log("FAIL");) {
+                function xxx() {}
+            }
+            break;
+        }
+    }
+    expect: {
+        switch (function() {
+            return xxx;
+        }) {
+          case xxx:
+            for (; console.log("FAIL");) {
+                function xxx() {}
+            }
+            break;
+        }
+    }
+    expect_stdout: true
+    node_version: ">=6"
+}
+
+issue_1672_for_strict: {
+    input: {
+        "use strict";
+        switch (function() {
+            return xxx;
+        }) {
+          case xxx:
+            for (; console.log("FAIL");) {
+                function xxx() {}
+            }
+            break;
+        }
+    }
+    expect: {
+        "use strict";
+        switch (function() {
+            return xxx;
+        }) {
+          case xxx:
+            for (; console.log("FAIL");) {
+                function xxx() {}
+            }
+            break;
+        }
+    }
+    expect_stdout: true
+    node_version: ">=6"
+}
+
+issue_1672_if: {
+    input: {
+        switch (function() {
+            return xxx;
+        }) {
+          case xxx:
+            if (console.log("FAIL")) {
+                function xxx() {}
+            }
+            break;
+        }
+    }
+    expect: {
+        switch (function() {
+            return xxx;
+        }) {
+          case xxx:
+            if (console.log("FAIL")) function xxx() {}
+            break;
+        }
+    }
+    expect_stdout: true
+    node_version: ">=6"
+}
+
+issue_1672_if_strict: {
+    input: {
+        "use strict";
+        switch (function() {
+            return xxx;
+        }) {
+          case xxx:
+            if (console.log("FAIL")) {
+                function xxx() {}
+            }
+            break;
+        }
+    }
+    expect: {
+        "use strict";
+        switch (function() {
+            return xxx;
+        }) {
+          case xxx:
+            if (console.log("FAIL")) {
+                function xxx() {}
+            }
+            break;
+        }
+    }
+    expect_stdout: true
+    node_version: ">=6"
+}

test/compress/collapse_vars.js

@@ -1146,7 +1146,7 @@ collapse_vars_constants: {
         function f3(x) {
             var b = x.prop;
             sideeffect1();
-            return b + -9;
+            return b + (function() { return -9; })();
         }
     }
 }

test/compress/dead-code.js

@@ -31,7 +31,7 @@ dead_code_2_should_warn: {
         function f() {
             g();
             x = 10;
-            throw "foo";
+            throw new Error("foo");
             // completely discarding the `if` would introduce some
             // bugs.  UglifyJS v1 doesn't deal with this issue; in v2
             // we copy any declarations to the upper scope.
@@ -46,16 +46,60 @@ dead_code_2_should_warn: {
                 })();
             }
         }
+        f();
     }
     expect: {
         function f() {
             g();
             x = 10;
-            throw "foo";
+            throw new Error("foo");
+            var x;
+            var g;
+        }
+        f();
+    }
+    expect_stdout: true
+    node_version: ">=6"
+}
+
+dead_code_2_should_warn_strict: {
+    options = {
+        dead_code: true
+    };
+    input: {
+        "use strict";
+        function f() {
+            g();
+            x = 10;
+            throw new Error("foo");
+            // completely discarding the `if` would introduce some
+            // bugs.  UglifyJS v1 doesn't deal with this issue; in v2
+            // we copy any declarations to the upper scope.
+            if (x) {
+                y();
                 var x;
                 function g(){};
+                // but nested declarations should not be kept.
+                (function(){
+                    var q;
+                    function y(){};
+                })();
             }
         }
+        f();
+    }
+    expect: {
+        "use strict";
+        function f() {
+            g();
+            x = 10;
+            throw new Error("foo");
+            var x;
+        }
+        f();
+    }
+    expect_stdout: true
+    node_version: ">=4"
 }
 
 dead_code_constant_boolean_should_warn_more: {
@@ -78,16 +122,55 @@ dead_code_constant_boolean_should_warn_more: {
             foo();
             var moo;
         }
+        bar();
     }
     expect: {
         var foo;
-        function bar() {}
+        var bar;
         // nothing for the while
         // as for the for, it should keep:
         var x = 10, y;
         var moo;
+        bar();
     }
     expect_stdout: true
+    node_version: ">=6"
+}
+
+dead_code_constant_boolean_should_warn_more_strict: {
+    options = {
+        dead_code    : true,
+        loops        : true,
+        booleans     : true,
+        conditionals : true,
+        evaluate     : true,
+        side_effects : true,
+    };
+    input: {
+        "use strict";
+        while (!((foo && bar) || (x + "0"))) {
+            console.log("unreachable");
+            var foo;
+            function bar() {}
+        }
+        for (var x = 10, y; x && (y || x) && (!typeof x); ++x) {
+            asdf();
+            foo();
+            var moo;
+        }
+        bar();
+    }
+    expect: {
+        "use strict";
+        var foo;
+        // nothing for the while
+        // as for the for, it should keep:
+        var x = 10, y;
+        var moo;
+        bar();
+    }
+    expect_stdout: true
+    node_version: ">=4"
 }
 
 dead_code_block_decls_die: {
@@ -134,7 +217,7 @@ dead_code_const_declaration: {
         var unused;
         const CONST_FOO = !1;
         var moo;
-        function bar() {}
+        var bar;
     }
     expect_stdout: true
 }
@@ -162,7 +245,7 @@ dead_code_const_annotation: {
         var unused;
         var CONST_FOO_ANN = !1;
         var moo;
-        function bar() {}
+        var bar;
     }
     expect_stdout: true
 }
@@ -229,7 +312,7 @@ dead_code_const_annotation_complex_scope: {
         var CONST_FOO_ANN = !1;
         var unused_var_2;
         var moo;
-        function bar() {}
+        var bar;
         var beef = 'good';
         var meat = 'beef';
         var pork = 'bad';
@@ -278,3 +361,19 @@ try_catch_finally: {
         "1",
     ]
 }
+
+accessor: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        ({
+            get a() {},
+            set a(v){
+                this.b = 2;
+            },
+            b: 1
+        });
+    }
+    expect: {}
+}

test/compress/destructuring.js

@@ -328,5 +328,334 @@ issue_1886: {
         let [a] = [1];
         console.log(a);
     }
-    expect_exact: "1"
+}
+
+destructuring_decl_of_numeric_key: {
+    options = {
+        evaluate: true,
+        unused: true,
+    }
+    input: {
+        let { 3: x } = { [1 + 2]: 42 };
+        console.log(x);
+    }
+    expect: {
+        let { 3: x } = { [3]: 42 };
+        console.log(x);
+    }
+    expect_stdout: "42"
+    node_version: ">=6"
+}
+
+destructuring_decl_of_computed_key: {
+    options = {
+        evaluate: true,
+        unused: true,
+    }
+    input: {
+        let four = 4;
+        let { [7 - four]: x } = { [1 + 2]: 42 };
+        console.log(x);
+    }
+    expect: {
+        let four = 4;
+        let { [7 - four]: x } = { [3]: 42 };
+        console.log(x);
+    }
+    expect_stdout: "42"
+    node_version: ">=6"
+}
+
+destructuring_assign_of_numeric_key: {
+    options = {
+        evaluate: true,
+        unused: true,
+    }
+    input: {
+        let x;
+        ({ 3: x } = { [1 + 2]: 42 });
+        console.log(x);
+    }
+    expect: {
+        let x;
+        ({ 3: x } = { [3]: 42 });
+        console.log(x);
+    }
+    expect_stdout: "42"
+    node_version: ">=6"
+}
+
+destructuring_assign_of_computed_key: {
+    options = {
+        evaluate: true,
+        unused: true,
+    }
+    input: {
+        let x;
+        let four = 4;
+        ({ [(5 + 2) - four]: x } = { [1 + 2]: 42 });
+        console.log(x);
+    }
+    expect: {
+        let x;
+        let four = 4;
+        ({ [7 - four]: x } = { [3]: 42 });
+        console.log(x);
+    }
+    expect_stdout: "42"
+    node_version: ">=6"
+}
+
+mangle_destructuring_decl: {
+    options = {
+        evaluate: true,
+        unused: true,
+    }
+    mangle = {
+    }
+    input: {
+        function test(opts) {
+            let a = opts.a || { e: 7, n: 8 };
+            let { t, e, n, s =  5 + 4, o, r } = a;
+            console.log(t, e, n, s, o, r);
+        }
+        test({a: { t: 1, e: 2, n: 3, s: 4, o: 5, r: 6 }});
+        test({});
+    }
+    expect: {
+        function test(t) {
+            let e = t.a || { e: 7, n: 8 };
+            let {t: n,  e: o,  n: s,  s: l = 9,  o: a,  r: c} = e;
+            console.log(n, o, s, l, a, c);
+        }
+        test({ a: { t: 1, e: 2, n: 3, s: 4, o: 5, r: 6 } });
+        test({});
+    }
+    expect_stdout: [
+        "1 2 3 4 5 6",
+        "undefined 7 8 9 undefined undefined",
+    ]
+    node_version: ">=6"
+}
+
+mangle_destructuring_assign_toplevel_true: {
+    options = {
+        toplevel: true,
+        evaluate: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    beautify = {
+        ecma: 6
+    }
+    input: {
+        function test(opts) {
+            let s, o, r;
+            let a = opts.a || { e: 7, n: 8 };
+            ({ t, e, n, s =  5 + 4, o, r } = a);
+            console.log(t, e, n, s, o, r);
+        }
+        let t, e, n;
+        test({a: { t: 1, e: 2, n: 3, s: 4, o: 5, r: 6 }});
+        test({});
+    }
+    expect: {
+        function e(e) {
+            let l, s, a;
+            let c = e.a || { e: 7, n: 8 };
+            ({t: n,  e: o,  n: t,  s: l = 9,  o: s,  r: a} = c);
+            console.log(n, o, t, l, s, a);
+        }
+        let n, o, t;
+        e({ a: { t: 1, e: 2, n: 3, s: 4, o: 5, r: 6 } });
+        e({});
+    }
+    expect_stdout: [
+        "1 2 3 4 5 6",
+        "undefined 7 8 9 undefined undefined",
+    ]
+    node_version: ">=6"
+}
+
+mangle_destructuring_assign_toplevel_false: {
+    options = {
+        toplevel: false,
+        evaluate: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: false,
+    }
+    beautify = {
+        ecma: 6
+    }
+    input: {
+        function test(opts) {
+            let s, o, r;
+            let a = opts.a || { e: 7, n: 8 };
+            ({ t, e, n, s = 9, o, r } = a);
+            console.log(t, e, n, s, o, r);
+        }
+        let t, e, n;
+        test({a: { t: 1, e: 2, n: 3, s: 4, o: 5, r: 6 }});
+        test({});
+    }
+    expect: {
+        function test(o) {
+            let s, l, a;
+            let c = o.a || { e: 7, n: 8 };
+            ({t,  e,  n,  s = 9,  o: l,  r: a} = c);
+            console.log(t, e, n, s, l, a);
+        }
+        let t, e, n;
+        test({ a: { t: 1, e: 2, n: 3, s: 4, o: 5, r: 6 } });
+        test({});
+    }
+    expect_stdout: [
+        "1 2 3 4 5 6",
+        "undefined 7 8 9 undefined undefined",
+    ]
+    node_version: ">=6"
+}
+
+mangle_destructuring_decl_array: {
+    options = {
+        evaluate: true,
+        unused: true,
+        toplevel: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    beautify = {
+        ecma: 6
+    }
+    input: {
+        var [, t, e, n, s, o = 2, r = [ 1 + 2 ]] = [ 9, 8, 7, 6 ];
+        console.log(t, e, n, s, o, r);
+    }
+    expect: {
+        var [, o,  l,  a,  c,  e = 2,  g = [ 3 ]] = [ 9, 8, 7, 6 ];
+        console.log(o, l, a, c, e, g);
+    }
+    expect_stdout: "8 7 6 undefined 2 [ 3 ]"
+    node_version: ">=6"
+}
+
+anon_func_with_destructuring_args: {
+    options = {
+        evaluate: true,
+        unused: true,
+        toplevel: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    beautify = {
+        ecma: 5,
+    }
+    input: {
+        (function({foo = 1 + 0, bar = 2}, [car = 3, far = 4]) {
+            console.log(foo, bar, car, far);
+        })({bar: 5 - 0}, [, 6]);
+    }
+    expect: {
+        (function({foo: o = 1, bar: n = 2}, [a = 3, b = 4]) {
+            console.log(o, n, a, b);
+        })({bar: 5}, [, 6]);
+    }
+    expect_stdout: "1 5 3 6"
+    node_version: ">=6"
+}
+
+arrow_func_with_destructuring_args: {
+    options = {
+        evaluate: true,
+        unused: true,
+        toplevel: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    beautify = {
+        ecma: 5,
+    }
+    input: {
+        (({foo = 1 + 0, bar = 2}, [car = 3, far = 4]) => {
+            console.log(foo, bar, car, far);
+        })({bar: 5 - 0}, [, 6]);
+    }
+    expect: {
+        (({foo: o = 1, bar: a = 2}, [b = 3, l = 4]) => {
+            console.log(o, a, b, l);
+        })({bar: 5}, [, 6]);
+    }
+    expect_stdout: "1 5 3 6"
+    node_version: ">=6"
+}
+
+issue_2044_ecma_5: {
+    beautify = {
+        beautify: false,
+        ecma: 5,
+    }
+    input: {
+        ({x : a = 1, y = 2 + b, z = 3 - c} = obj);
+    }
+    expect_exact: "({x:a=1,y:y=2+b,z:z=3-c}=obj);"
+}
+
+issue_2044_ecma_6: {
+    beautify = {
+        beautify: false,
+        ecma: 6,
+    }
+    input: {
+        ({x : a = 1, y = 2 + b, z = 3 - c} = obj);
+    }
+    expect_exact: "({x:a=1,y=2+b,z=3-c}=obj);"
+}
+
+issue_2044_ecma_5_beautify: {
+    beautify = {
+        beautify: true,
+        ecma: 5,
+    }
+    input: {
+        ({x : a = 1, y = 2 + b, z = 3 - c} = obj);
+    }
+    expect_exact: "({x: a = 1, y: y = 2 + b, z: z = 3 - c} = obj);"
+}
+
+issue_2044_ecma_6_beautify: {
+    beautify = {
+        beautify: true,
+        ecma: 6,
+    }
+    input: {
+        ({x : a = 1, y = 2 + b, z = 3 - c} = obj);
+    }
+    expect_exact: "({x: a = 1, y = 2 + b, z = 3 - c} = obj);"
+}
+
+issue_2140: {
+    options = {
+        unused: true,
+    }
+    input: {
+        !function() {
+            var t = {};
+            console.log(([t.a] = [42])[0]);
+        }();
+    }
+    expect: {
+        !function() {
+            var t = {};
+            console.log(([t.a] = [42])[0]);
+        }();
+    }
+    expect_stdout: "42"
+    node_version: ">=6"
 }

test/compress/drop-unused.js

@@ -863,12 +863,12 @@ issue_1583: {
     expect: {
         function m(t) {
             (function(e) {
-                t = (function() {
+                t = e();
+            })(function() {
                 return (function(a) {
                     return a;
                 })(function(a) {});
-                })();
-            })();
+            });
         }
     }
 }
@@ -1253,3 +1253,159 @@ reassign_const: {
     }
     expect_stdout: true
 }
+
+issue_1968: {
+    options = {
+        unused: true,
+    }
+    input: {
+        function f(c) {
+            var a;
+            if (c) {
+                let b;
+                return (a = 2) + (b = 3);
+            }
+        }
+        console.log(f(1));
+    }
+    expect: {
+        function f(c) {
+            if (c) {
+                let b;
+                return 2 + (b = 3);
+            }
+        }
+        console.log(f(1));
+    }
+    expect_stdout: "5"
+    node_version: ">=6"
+}
+
+issue_2063: {
+    options = {
+        unused: true,
+    }
+    input: {
+        var a;
+        var a;
+    }
+    expect: {
+        var a;
+        var a;
+    }
+}
+
+issue_2105: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        !function(factory) {
+            factory();
+        }( function() {
+            return function(fn) {
+                fn()().prop();
+            }( function() {
+                function bar() {
+                    var quux = function() {
+                        console.log("PASS");
+                    }, foo = function() {
+                        console.log;
+                        quux();
+                    };
+                    return { prop: foo };
+                }
+                return bar;
+            } );
+        });
+    }
+    expect: {
+        !void function() {
+            var quux = function() {
+                console.log("PASS");
+            };
+            return {
+                prop: function() {
+                    console.log;
+                    quux();
+                }
+            };
+        }().prop();
+    }
+    expect_stdout: "PASS"
+}
+
+issue_2136_1: {
+    options = {
+        inline: true,
+        unused: true,
+    }
+    input: {
+        !function(a, ...b) {
+            console.log(b);
+        }();
+    }
+    expect: {
+        !function(a, ...b) {
+            console.log(b);
+        }();
+    }
+    expect_stdout: "[]"
+    node_version: ">=6"
+}
+
+issue_2136_2: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        function f(x) {
+            console.log(x);
+        }
+        !function(a, ...b) {
+            f(b[0]);
+        }(1, 2, 3);
+    }
+    expect: {
+        function f(x) {
+            console.log(x);
+        }
+        f([2,3][0]);
+    }
+    expect_stdout: "2"
+    node_version: ">=6"
+}
+
+issue_2136_3: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        inline: true,
+        passes: 3,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        function f(x) {
+            console.log(x);
+        }
+        !function(a, ...b) {
+            f(b[0]);
+        }(1, 2, 3);
+    }
+    expect: {
+        console.log(2);
+    }
+    expect_stdout: "2"
+    node_version: ">=6"
+}

test/compress/evaluate.js

@@ -738,6 +738,7 @@ unsafe_prototype_function: {
 call_args: {
     options = {
         evaluate: true,
+        inline: true,
         reduce_vars: true,
     }
     input: {
@@ -758,6 +759,7 @@ call_args: {
 call_args_drop_param: {
     options = {
         evaluate: true,
+        inline: true,
         keep_fargs: false,
         reduce_vars: true,
         unused: true,
@@ -873,13 +875,15 @@ unsafe_charAt_noop: {
     input: {
         console.log(
             s.charAt(0),
-            "string".charAt(x)
+            "string".charAt(x),
+            (typeof x).charAt()
         );
     }
     expect: {
         console.log(
             s.charAt(0),
-            "string".charAt(x)
+            "string".charAt(x),
+            (typeof x)[0]
         );
     }
 }
@@ -1083,3 +1087,78 @@ Infinity_NaN_undefined_LHS: {
         "}",
     ]
 }
+
+issue_1964_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unsafe_regexp: false,
+        unused: true,
+    }
+    input: {
+        function f() {
+            var long_variable_name = /\s/;
+            return "a b c".split(long_variable_name)[1];
+        }
+        console.log(f());
+    }
+    expect: {
+        function f() {
+            var long_variable_name = /\s/;
+            return "a b c".split(long_variable_name)[1];
+        }
+        console.log(f());
+    }
+    expect_stdout: "b"
+}
+
+issue_1964_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unsafe_regexp: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            var long_variable_name = /\s/;
+            return "a b c".split(long_variable_name)[1];
+        }
+        console.log(f());
+    }
+    expect: {
+        function f() {
+            return "a b c".split(/\s/)[1];
+        }
+        console.log(f());
+    }
+    expect_stdout: "b"
+}
+
+array_slice_index: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log([1,2,3].slice(1)[1]);
+    }
+    expect: {
+        console.log(3);
+    }
+    expect_stdout: "3"
+}
+
+string_charCodeAt: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log("foo".charCodeAt("bar".length));
+    }
+    expect: {
+        console.log(NaN);
+    }
+    expect_stdout: "NaN"
+}

test/compress/export.js

@@ -0,0 +1,228 @@
+issue_2038_1: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export var V = 1;
+        export let L = 2;
+        export const C = 3;
+    }
+    expect: {
+        export var V = 1;
+        export let L = 2;
+        export const C = 3;
+    }
+}
+
+issue_2038_2: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        let LET = 1;
+        const CONST = 2;
+        var VAR = 3;
+        export { LET, CONST, VAR };
+    }
+    expect: {
+        let t = 1;
+        const e = 2;
+        var o = 3;
+        export { t as LET, e as CONST, o as VAR };
+    }
+}
+
+issue_2126: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        import { foo as bar, cat as dog } from "stuff";
+        console.log(bar, dog);
+        export { bar as qux };
+        export { dog };
+    }
+    expect: {
+        import { foo as o, cat as s } from "stuff";
+        console.log(o, s);
+        export { o as qux };
+        export { s as dog };
+    }
+}
+
+beautify: {
+    beautify = {
+        beautify: true,
+    }
+    input: {
+        export { A as B, C as D };
+    }
+    expect_exact: "export { A as B, C as D };"
+}
+
+issue_2131: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function no() {
+            console.log(42);
+        }
+        function go() {
+            console.log(42);
+        }
+        var X = 1, Y = 2;
+        export function main() {
+            go(X);
+        };
+    }
+    expect: {
+        function go() {
+            console.log(42);
+        }
+        var X = 1;
+        export function main() {
+            go(X);
+        };
+    }
+}
+
+issue_2129: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export const { keys } = Object;
+    }
+    expect: {
+        export const { keys } = Object;
+    }
+}
+
+async_func: {
+    options = {
+        keep_fargs: false,
+        unused: true,
+    }
+    input: {
+        export async function Foo(x){};
+    }
+    expect: {
+        export async function Foo(){};
+    }
+}
+
+issue_2134_1: {
+    options = {
+        keep_fargs: false,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export function Foo(x){};
+        Foo.prototype = {};
+    }
+    expect: {
+        export function Foo(){};
+        Foo.prototype = {};
+    }
+}
+
+issue_2134_2: {
+    options = {
+        keep_fargs: false,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export async function Foo(x){};
+        Foo.prototype = {};
+    }
+    expect: {
+        export async function Foo(){};
+        Foo.prototype = {};
+    }
+}
+
+redirection: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        let foo = 1, bar = 2;
+        export { foo as delete };
+        export { bar as default };
+        export { foo as var } from "module.js";
+    }
+    expect: {
+        let e = 1, o = 2;
+        export { e as delete };
+        export { o as default };
+        export { foo as var } from "module.js";
+    }
+}
+
+keyword_invalid_1: {
+    input: {
+        export { default };
+    }
+    expect: {
+        export { default };
+    }
+}
+
+keyword_invalid_2: {
+    input: {
+        export { default as Alias };
+    }
+    expect: {
+        export { default as Alias };
+    }
+}
+
+keyword_invalid_3: {
+    input: {
+        export { default as default };
+    }
+    expect: {
+        export { default as default };
+    }
+}
+
+keyword_valid_1: {
+    input: {
+        export { default } from "module.js";
+    }
+    expect: {
+        export { default } from "module.js";
+    }
+}
+
+keyword_valid_2: {
+    input: {
+        export { default as Alias } from "module.js";
+    }
+    expect: {
+        export { default as Alias } from "module.js";
+    }
+}
+
+keyword_valid_3: {
+    input: {
+        export { default as default } from "module.js";
+    }
+    expect: {
+        export { default as default } from "module.js";
+    }
+}

test/compress/functions.js

@@ -21,6 +21,7 @@ iifes_returning_constants_keep_fargs_true: {
         join_vars     : true,
         reduce_vars   : true,
         cascade       : true,
+        inline        : true,
     }
     input: {
         (function(){ return -1.23; }());
@@ -56,6 +57,7 @@ iifes_returning_constants_keep_fargs_false: {
         join_vars     : true,
         reduce_vars   : true,
         cascade       : true,
+        inline        : true,
     }
     input: {
         (function(){ return -1.23; }());
@@ -82,6 +84,7 @@ issue_485_crashing_1530: {
         conditionals: true,
         dead_code: true,
         evaluate: true,
+        inline: true,
     }
     input: {
         (function(a) {
@@ -154,6 +157,7 @@ function_returning_constant_literal: {
         evaluate: true,
         cascade: true,
         unused: true,
+        inline: true,
     }
     input: {
         function greeter() {
@@ -167,3 +171,342 @@ function_returning_constant_literal: {
     }
     expect_stdout: "Hello there"
 }
+
+hoist_funs: {
+    options = {
+        hoist_funs: true,
+    }
+    input: {
+        console.log(1, typeof f, typeof g);
+        if (console.log(2, typeof f, typeof g))
+            console.log(3, typeof f, typeof g);
+        else {
+            console.log(4, typeof f, typeof g);
+            function f() {}
+            console.log(5, typeof f, typeof g);
+        }
+        function g() {}
+        console.log(6, typeof f, typeof g);
+    }
+    expect: {
+        function g() {}
+        console.log(1, typeof f, typeof g);
+        if (console.log(2, typeof f, typeof g))
+            console.log(3, typeof f, typeof g);
+        else {
+            console.log(4, typeof f, typeof g);
+            function f() {}
+            console.log(5, typeof f, typeof g);
+        }
+        console.log(6, typeof f, typeof g);
+    }
+    expect_stdout: [
+        "1 'undefined' 'function'",
+        "2 'undefined' 'function'",
+        "4 'function' 'function'",
+        "5 'function' 'function'",
+        "6 'function' 'function'",
+    ]
+    node_version: ">=6"
+}
+
+hoist_funs_strict: {
+    options = {
+        hoist_funs: true,
+    }
+    input: {
+        "use strict";
+        console.log(1, typeof f, typeof g);
+        if (console.log(2, typeof f, typeof g))
+            console.log(3, typeof f, typeof g);
+        else {
+            console.log(4, typeof f, typeof g);
+            function f() {}
+            console.log(5, typeof f, typeof g);
+        }
+        function g() {}
+        console.log(6, typeof f, typeof g);
+    }
+    expect: {
+        "use strict";
+        function g() {}
+        console.log(1, typeof f, typeof g);
+        if (console.log(2, typeof f, typeof g))
+            console.log(3, typeof f, typeof g);
+        else {
+            console.log(4, typeof f, typeof g);
+            function f() {}
+            console.log(5, typeof f, typeof g);
+        }
+        console.log(6, typeof f, typeof g);
+    }
+    expect_stdout: [
+        "1 'undefined' 'function'",
+        "2 'undefined' 'function'",
+        "4 'function' 'function'",
+        "5 'function' 'function'",
+        "6 'undefined' 'function'",
+    ]
+    node_version: ">=4"
+}
+
+issue_203: {
+    options = {
+        keep_fargs: false,
+        side_effects: true,
+        unsafe_Func: true,
+        unused: true,
+    }
+    input: {
+        var m = {};
+        var fn = Function("require", "module", "exports", "module.exports = 42;");
+        fn(null, m, m.exports);
+        console.log(m.exports);
+    }
+    expect: {
+        var m = {};
+        var fn = Function("n", "o", "o.exports=42");
+        fn(null, m, m.exports);
+        console.log(m.exports);
+    }
+    expect_stdout: "42"
+}
+
+no_webkit: {
+    beautify = {
+        webkit: false,
+    }
+    input: {
+        console.log(function() {
+            1 + 1;
+        }.a = 1);
+    }
+    expect_exact: "console.log(function(){1+1}.a=1);"
+    expect_stdout: "1"
+}
+
+webkit: {
+    beautify = {
+        webkit: true,
+    }
+    input: {
+        console.log(function() {
+            1 + 1;
+        }.a = 1);
+    }
+    expect_exact: "console.log((function(){1+1}).a=1);"
+    expect_stdout: "1"
+}
+
+issue_2084: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        evaluate: true,
+        inline: true,
+        passes: 2,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var c = 0;
+        !function() {
+            !function(c) {
+                c = 1 + c;
+                var c = 0;
+                function f14(a_1) {
+                    if (c = 1 + c, 0 !== 23..toString())
+                        c = 1 + c, a_1 && (a_1[0] = 0);
+                }
+                f14();
+            }(-1);
+        }();
+        console.log(c);
+    }
+    expect: {
+        var c = 0;
+        !function(c) {
+            c = 1 + c,
+            c = 1 + (c = 0),
+            0 !== 23..toString() && (c = 1 + c);
+        }(-1),
+        console.log(c);
+    }
+    expect_stdout: "0"
+}
+
+issue_2097: {
+    options = {
+        negate_iife: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            try {
+                throw 0;
+            } catch (e) {
+                console.log(arguments[0]);
+            }
+        }
+        f(1);
+    }
+    expect: {
+        !function() {
+            try {
+                throw 0;
+            } catch (e) {
+                console.log(arguments[0]);
+            }
+        }(1);
+    }
+    expect_stdout: "1"
+}
+
+issue_2101: {
+    options = {
+        inline: true,
+    }
+    input: {
+        a = {};
+        console.log(function() {
+            return function() {
+                return this.a;
+            }();
+        }() === function() {
+            return a;
+        }());
+    }
+    expect: {
+        a = {};
+        console.log(function() {
+            return this.a;
+        }() === a);
+    }
+    expect_stdout: "true"
+}
+
+inner_ref: {
+    options = {
+        inline: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(a) {
+            return function() {
+                return a;
+            }();
+        }(1), function(a) {
+            return function(a) {
+                return a;
+            }();
+        }(2));
+    }
+    expect: {
+        console.log(function(a) {
+            return a;
+        }(1), function(a) {
+            return a;
+        }());
+    }
+    expect_stdout: "1 undefined"
+}
+
+issue_2107: {
+    options = {
+        cascade: true,
+        collapse_vars: true,
+        inline: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var c = 0;
+        !function() {
+            c++;
+        }(c++ + new function() {
+            this.a = 0;
+            var a = (c = c + 1) + (c = 1 + c);
+            return c++ + a;
+        }());
+        console.log(c);
+    }
+    expect: {
+        var c = 0;
+        c++, new function() {
+            this.a = 0, c = 1 + (c += 1), c++;
+        }(), c++, console.log(c);
+    }
+    expect_stdout: "5"
+}
+
+issue_2114_1: {
+    options = {
+        collapse_vars: true,
+        if_return: true,
+        inline: true,
+        keep_fargs: false,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var c = 0;
+        !function(a) {
+            a = 0;
+        }([ {
+            0: c = c + 1,
+            length: c = 1 + c
+        }, typeof void function a() {
+            var b = function f1(a) {
+            }(b && (b.b += (c = c + 1, 0)));
+        }() ]);
+        console.log(c);
+    }
+    expect: {
+        var c = 0;
+        !function() {
+            0;
+        }((c += 1, c = 1 + c, function() {
+            var b = void (b && (b.b += (c += 1, 0)));
+        }()));
+        console.log(c);
+    }
+    expect_stdout: "2"
+}
+
+issue_2114_2: {
+    options = {
+        collapse_vars: true,
+        if_return: true,
+        inline: true,
+        keep_fargs: false,
+        passes: 2,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var c = 0;
+        !function(a) {
+            a = 0;
+        }([ {
+            0: c = c + 1,
+            length: c = 1 + c
+        }, typeof void function a() {
+            var b = function f1(a) {
+            }(b && (b.b += (c = c + 1, 0)));
+        }() ]);
+        console.log(c);
+    }
+    expect: {
+        var c = 0;
+        c = 1 + (c += 1), function() {
+            var b = void (b && (b.b += (c += 1, 0)));
+        }();
+        console.log(c);
+    }
+    expect_stdout: "2"
+}

test/compress/global_defs.js

@@ -160,3 +160,17 @@ issue_1801: {
         console.log(!0);
     }
 }
+
+issue_1986: {
+    options = {
+        global_defs: {
+            "@alert": "console.log",
+        },
+    }
+    input: {
+        alert(42);
+    }
+    expect: {
+        console.log(42);
+    }
+}

test/compress/harmony.js

@@ -16,9 +16,12 @@ typeof_arrow_functions: {
         evaluate: true
     }
     input: {
-        var foo = typeof (x) => null;
+        var foo = typeof (x => null);
+        console.log(foo);
     }
-    expect_exact: "var foo=\"function\";"
+    expect_exact: "var foo=\"function\";console.log(foo);"
+    expect_stdout: "function"
+    node_version: ">=4"
 }
 
 classes: {
@@ -60,15 +63,15 @@ class_name_can_be_mangled: {
         function x() {
             class Foo {
             }
-            var class1 = Foo
-            var class2 = class Bar {}
+            var class1 = Foo;
+            var class2 = class Bar {};
         }
     }
     expect: {
         function x() {
             class a { }
-            var n = a
-            var r = class a {}
+            var s = a;
+            var c = class a {};
         }
     }
 }
@@ -203,15 +206,66 @@ import_all_statement: {
 }
 
 export_statement: {
+    options = {
+        evaluate: true,
+    }
     input: {
-        export default 1;
+        export default 1 + 2;
         export var foo = 4;
         export let foo = 6;
         export const foo = 6;
         export function foo() {};
         export class foo { };
     }
-    expect_exact: "export default 1;export var foo=4;export let foo=6;export const foo=6;export function foo(){};export class foo{};"
+    expect_exact: "export default 3;export var foo=4;export let foo=6;export const foo=6;export function foo(){};export class foo{};"
+}
+
+export_default_object_expression: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        export default {
+            foo: 1 + 2,
+            bar() { return 4; },
+            get baz() { return this.foo; },
+        };
+    }
+    expect_exact: "export default{foo:3,bar(){return 4},get baz(){return this.foo}};"
+}
+
+export_default_array: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        export default [ 1 + 2, foo ];
+    }
+    expect_exact: "export default[3,foo];"
+}
+
+export_default_anon_function: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        export default function(){
+            console.log(1 + 2);
+        }
+    }
+    expect_exact: "export default function(){console.log(3)};"
+}
+
+export_default_anon_class: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        export default class {
+            foo() { console.log(1 + 2); }
+        }
+    }
+    expect_exact: "export default class{foo(){console.log(3)}};"
 }
 
 export_module_statement: {
@@ -236,12 +290,12 @@ import_statement_mangling: {
         Whatever();
     }
     expect: {
-        import l from "foo";
-        import e, {Food as o} from "lel";
+        import o from "foo";
+        import m, {Food as r} from "lel";
         import {What as f} from "lel";
-        l();
-        e();
         o();
+        m();
+        r();
         f();
     }
 }
@@ -415,10 +469,10 @@ issue_1898: {
     expect: {
         class Foo {
             bar() {
-                for (const n of [ 6, 5 ])
+                for (const f of [ 6, 5 ])
                     for (let r of [ 4, 3 ])
                         for (var o of [ 2, 1 ])
-                            console.log(n, r, o);
+                            console.log(f, r, o);
             }
         }
         new Foo().bar();
@@ -443,9 +497,9 @@ issue_1753: {
     expect: {
         class SomeClass {
             constructor(r) {
-                let a = [];
-                for (let s = 0; s < 6; s++)
-                    a.push({
+                let s = [];
+                for (let a = 0; a < 6; a++)
+                    s.push({
                         mainDrawNumbers: [],
                         extraDrawNumbers: []
                     });
@@ -472,9 +526,9 @@ issue_1753_disable: {
     expect: {
         class SomeClass {
             constructor(r) {
-                let a = [];
+                let s = [];
                 for (let r = 0; r < 6; r++)
-                    a.push({
+                    s.push({
                         mainDrawNumbers: [],
                         extraDrawNumbers: []
                     });
@@ -482,3 +536,162 @@ issue_1753_disable: {
         }
     }
 }
+
+class_extends: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        function f() {
+            class foo extends bar {}
+            class pro extends some.prop {}
+            class arr extends stuff[1 - 1] {}
+            class bin extends (a || b) {}
+            class seq extends (a, b) {}
+            class ter extends (a ? b : c) {}
+            class uni extends (!0) {}
+        }
+    }
+    expect_exact: "function f(){class foo extends bar{}class pro extends some.prop{}class arr extends stuff[0]{}class bin extends(a||b){}class seq extends(a,b){}class ter extends(a?b:c){}class uni extends(!0){}}"
+}
+
+class_extends_class: {
+    options = {
+    }
+    input: {
+        class anon extends class {} {}
+        class named extends class base {} {}
+    }
+    expect_exact: "class anon extends class{}{}class named extends class base{}{}"
+}
+
+class_extends_function: {
+    options = {
+    }
+    input: {
+        class anon extends function(){} {}
+        class named extends function base(){} {}
+    }
+    expect_exact: "class anon extends function(){}{}class named extends function base(){}{}"
+}
+
+class_extends_regex: {
+    options = {
+    }
+    input: {
+        function f() {
+            class rx1 extends (/rx/) {}
+            // class rx2 extends /rx/ {}  // FIXME - parse error
+        }
+    }
+    expect_exact: "function f(){class rx1 extends(/rx/){}}"
+}
+
+issue_2028: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        var a = {};
+        (function(x) {
+            x.X = function() {
+                return X;
+            };
+            class X {
+                static hello() {
+                    console.log("hello");
+                }
+            }
+        }(a));
+        a.X().hello();
+    }
+    expect: {
+        var a = {};
+        (function(x) {
+            x.X = function() {
+                return X;
+            };
+            class X {
+                static hello() {
+                    console.log("hello");
+                }
+            }
+        }(a));
+        a.X().hello();
+    }
+    expect_stdout: "hello"
+    node_version: ">=6"
+}
+
+class_expression_statement: {
+    options = {
+        toplevel: false,
+        side_effects: false,
+        unused: false,
+    }
+    input: {
+        (class {});
+        (class NamedClassExpr {});
+        let expr = (class AnotherClassExpr {});
+        class C {}
+    }
+    expect_exact: "(class{});(class NamedClassExpr{});let expr=class AnotherClassExpr{};class C{}"
+}
+
+class_expression_statement_unused: {
+    options = {
+        toplevel: false,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        (class {});
+        (class NamedClassExpr {});
+        let expr = (class AnotherClassExpr {});
+        class C {}
+    }
+    expect_exact: "let expr=class{};class C{}"
+}
+
+class_expression_statement_unused_toplevel: {
+    options = {
+        toplevel: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        (class {});
+        (class NamedClassExpr {});
+        let expr = (class AnotherClassExpr {});
+        class C {}
+    }
+    expect_exact: ""
+}
+
+export_default_function_decl: {
+    options = {
+        toplevel: true,
+        passes: 3,
+        unused: true,
+    }
+    input: {
+        // do not drop "unused" exports
+        export default function Foo() {};
+        export function Far() {};
+    }
+    expect_exact: "export default function Foo(){};export function Far(){};"
+}
+
+export_default_class_decl: {
+    options = {
+        toplevel: true,
+        passes: 3,
+        unused: true,
+    }
+    input: {
+        // do not drop "unused" exports
+        export default class Car {};
+        export class Cab {};
+    }
+    expect_exact: "export default class Car{};export class Cab{};"
+}

test/compress/if_return.js

@@ -302,3 +302,85 @@ issue_1437_conditionals: {
         }
     }
 }
+
+issue_512: {
+    options = {
+        conditionals: true,
+        if_return: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        function a() {
+            if (b()) {
+                c();
+                return;
+            }
+            throw e;
+        }
+    }
+    expect: {
+        function a() {
+            if (!b()) throw e;
+            c();
+        }
+    }
+}
+
+issue_1317: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        !function(a) {
+            if (a) return;
+            let b = 1;
+            function g() {
+                return b;
+            }
+            console.log(g());
+        }();
+    }
+    expect: {
+        !function(a) {
+            if (a) return;
+            let b = 1;
+            function g() {
+                return b;
+            }
+            console.log(g());
+        }();
+    }
+    expect_stdout: "1"
+    node_version: ">=6"
+}
+
+issue_1317_strict: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        "use strict";
+        !function(a) {
+            if (a) return;
+            let b = 1;
+            function g() {
+                return b;
+            }
+            console.log(g());
+        }();
+    }
+    expect: {
+        "use strict";
+        !function(a) {
+            if (a) return;
+            let b = 1;
+            function g() {
+                return b;
+            }
+            console.log(g());
+        }();
+    }
+    expect_stdout: "1"
+    node_version: ">=4"
+}

test/compress/issue-1034.js

@@ -116,3 +116,137 @@ non_hoisted_function_after_return_2b: {
         "WARN: Dropping unreachable code [test/compress/issue-1034.js:101,12]",
     ]
 }
+
+non_hoisted_function_after_return_strict: {
+    options = {
+        hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
+        evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
+        if_return: true, join_vars: true, cascade: true, side_effects: true
+    }
+    input: {
+        "use strict";
+        function foo(x) {
+            if (x) {
+                return bar();
+                not_called1();
+            } else {
+                return baz();
+                not_called2();
+            }
+            function bar() { return 7; }
+            return not_reached;
+            function UnusedFunction() {}
+            function baz() { return 8; }
+        }
+        console.log(foo(0), foo(1));
+    }
+    expect: {
+        "use strict";
+        function foo(x) {
+            return x ? bar() : baz();
+            function bar() { return 7 }
+            function baz() { return 8 }
+        }
+        console.log(foo(0), foo(1));
+    }
+    expect_stdout: "8 7"
+    expect_warnings: [
+        'WARN: Dropping unreachable code [test/compress/issue-1034.js:131,16]',
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:134,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:137,12]",
+        "WARN: Dropping unused function UnusedFunction [test/compress/issue-1034.js:138,21]"
+    ]
+}
+
+non_hoisted_function_after_return_2a_strict: {
+    options = {
+        hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
+        evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
+        if_return: true, join_vars: true, cascade: true, side_effects: true,
+        collapse_vars: false, passes: 2, warnings: "verbose"
+    }
+    input: {
+        "use strict";
+        function foo(x) {
+            if (x) {
+                return bar(1);
+                var a = not_called(1);
+            } else {
+                return bar(2);
+                var b = not_called(2);
+            }
+            var c = bar(3);
+            function bar(x) { return 7 - x; }
+            function nope() {}
+            return b || c;
+        }
+        console.log(foo(0), foo(1));
+    }
+    expect: {
+        "use strict";
+        function foo(x) {
+            return bar(x ? 1 : 2);
+            function bar(x) {
+                return 7 - x;
+            }
+        }
+        console.log(foo(0), foo(1));
+    }
+    expect_stdout: "5 6"
+    expect_warnings: [
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:173,16]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:173,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:176,16]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:176,16]",
+        "WARN: Dropping unused variable a [test/compress/issue-1034.js:173,20]",
+        "WARN: Dropping unused function nope [test/compress/issue-1034.js:180,21]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:178,12]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:178,12]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:181,12]",
+        "WARN: Dropping unused variable b [test/compress/issue-1034.js:176,20]",
+        "WARN: Dropping unused variable c [test/compress/issue-1034.js:178,16]",
+    ]
+}
+
+non_hoisted_function_after_return_2b_strict: {
+    options = {
+        hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
+        evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
+        if_return: true, join_vars: true, cascade: true, side_effects: true,
+        collapse_vars: false
+    }
+    input: {
+        "use strict";
+        function foo(x) {
+            if (x) {
+                return bar(1);
+            } else {
+                return bar(2);
+                var b;
+            }
+            var c = bar(3);
+            function bar(x) {
+                return 7 - x;
+            }
+            return b || c;
+        }
+        console.log(foo(0), foo(1));
+    }
+    expect: {
+        "use strict";
+        function foo(x) {
+            return bar(x ? 1 : 2);
+            function bar(x) { return 7 - x; }
+        }
+        console.log(foo(0), foo(1));
+    }
+    expect_stdout: "5 6"
+    expect_warnings: [
+        // duplicate warnings no longer emitted
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:225,16]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:225,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:227,12]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:227,12]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:231,12]",
+    ]
+}

test/compress/issue-1052.js

@@ -1,90 +1,91 @@
 multiple_functions: {
-    options = { if_return: true, hoist_funs: false };
+    options = {
+        hoist_funs: false,
+        if_return: true,
+    }
     input: {
         ( function() {
             if ( !window ) {
                 return;
             }
-
             function f() {}
             function g() {}
         } )();
     }
     expect: {
         ( function() {
-            function f() {}
-            function g() {}
-
             // NOTE: other compression steps will reduce this
             // down to just `window`.
             if ( window );
+            function f() {}
+            function g() {}
         } )();
     }
 }
 
 single_function: {
-    options = { if_return: true, hoist_funs: false };
+    options = {
+        hoist_funs: false,
+        if_return: true,
+    }
     input: {
         ( function() {
             if ( !window ) {
                 return;
             }
-
             function f() {}
         } )();
     }
     expect: {
         ( function() {
-            function f() {}
-
             if ( window );
+            function f() {}
         } )();
     }
 }
 
 deeply_nested: {
-    options = { if_return: true, hoist_funs: false };
+    options = {
+        hoist_funs: false,
+        if_return: true,
+    }
     input: {
         ( function() {
             if ( !window ) {
                 return;
             }
-
             function f() {}
             function g() {}
-
             if ( !document ) {
                 return;
             }
-
             function h() {}
         } )();
     }
     expect: {
         ( function() {
-            function f() {}
-            function g() {}
-
-            function h() {}
-
             // NOTE: other compression steps will reduce this
             // down to just `window`.
             if ( window )
                 if (document);
+            function f() {}
+            function g() {}
+            function h() {}
         } )();
     }
 }
 
 not_hoisted_when_already_nested: {
-    options = { if_return: true, hoist_funs: false };
+    options = {
+        hoist_funs: false,
+        if_return: true,
+    }
     input: {
         ( function() {
             if ( !window ) {
                 return;
             }
-
             if ( foo ) function f() {}
-
         } )();
     }
     expect: {
@@ -94,3 +95,69 @@ not_hoisted_when_already_nested: {
         } )();
     }
 }
+
+defun_if_return: {
+    options = {
+        hoist_funs: false,
+        if_return: true,
+    }
+    input: {
+        function e() {
+            function f() {}
+            if (!window) return;
+            else function g() {}
+            function h() {}
+        }
+    }
+    expect: {
+        function e() {
+            function f() {}
+            if (window) function g() {}
+            function h() {}
+        }
+    }
+}
+
+defun_hoist_funs: {
+    options = {
+        hoist_funs: true,
+        if_return: true,
+    }
+    input: {
+        function e() {
+            function f() {}
+            if (!window) return;
+            else function g() {}
+            function h() {}
+        }
+    }
+    expect: {
+        function e() {
+            function f() {}
+            function h() {}
+            if (window) function g() {}
+        }
+    }
+}
+
+defun_else_if_return: {
+    options = {
+        hoist_funs: false,
+        if_return: true,
+    }
+    input: {
+        function e() {
+            function f() {}
+            if (window) function g() {}
+            else return;
+            function h() {}
+        }
+    }
+    expect: {
+        function e() {
+            function f() {}
+            if (window) function g() {}
+            function h() {}
+        }
+    }
+}

test/compress/issue-1321.js

@@ -10,9 +10,9 @@ issue_1321_no_debug: {
     }
     expect: {
         var x = {};
-        x.b = 1;
-        x["a"] = 2 * x.b;
-        console.log(x.b, x["a"]);
+        x.o = 1;
+        x["a"] = 2 * x.o;
+        console.log(x.o, x["a"]);
     }
     expect_stdout: true
 }
@@ -30,9 +30,9 @@ issue_1321_debug: {
     }
     expect: {
         var x = {};
-        x.a = 1;
-        x["_$foo$_"] = 2 * x.a;
-        console.log(x.a, x["_$foo$_"]);
+        x.o = 1;
+        x["_$foo$_"] = 2 * x.o;
+        console.log(x.o, x["_$foo$_"]);
     }
     expect_stdout: true
 }
@@ -49,9 +49,9 @@ issue_1321_with_quoted: {
     }
     expect: {
         var x = {};
-        x.a = 1;
-        x["b"] = 2 * x.a;
-        console.log(x.a, x["b"]);
+        x.o = 1;
+        x["x"] = 2 * x.o;
+        console.log(x.o, x["x"]);
     }
     expect_stdout: true
 }

test/compress/issue-1466.js

@@ -33,8 +33,8 @@ same_variable_in_multiple_for_loop: {
             console.log(o, l);
             for (let o = 0; o < 2; o++) {
                 console.log(o, l);
-                let c = 2;
-                console.log(c);
+                let e = 2;
+                console.log(e);
             }
         }
     }
@@ -114,12 +114,12 @@ same_variable_in_multiple_forIn: {
     }
     expect: {
         var test = [ "a", "b", "c" ];
-        for (let o in test) {
-            console.log(o);
-            let e;
-            e = [ "e", "f", "g" ];
-            for (let o in test)
-                console.log(o);
+        for (let e in test) {
+            console.log(e);
+            let t;
+            t = [ "e", "f", "g" ];
+            for (let e in test)
+                console.log(e);
         }
     }
     expect_stdout: true
@@ -160,8 +160,8 @@ different_variable_in_multiple_for_loop: {
             console.log(o, l);
             for (let o = 0; o < 2; o++) {
                 console.log(o, l);
-                let c = 2;
-                console.log(c);
+                let e = 2;
+                console.log(e);
             }
         }
     }
@@ -241,12 +241,12 @@ different_variable_in_multiple_forIn: {
     }
     expect: {
         var test = [ "a", "b", "c" ];
-        for (let o in test) {
-            console.log(o);
-            let e;
-            e = [ "e", "f", "g" ];
-            for (let o in test)
-                console.log(o);
+        for (let e in test) {
+            console.log(e);
+            let t;
+            t = [ "e", "f", "g" ];
+            for (let e in test)
+                console.log(e);
         }
     }
     expect_stdout: true
@@ -281,10 +281,10 @@ more_variable_in_multiple_for: {
     }
     expect: {
         for (let o = 9, l = 0; l < 20; l += o) {
-            let c = o++ + l;
-            console.log(o, c, l);
-            for (let l = c, e = c * c, f = 0; f < 10; f++)
-                console.log(o, c, e, l, f);
+            let e = o++ + l;
+            console.log(o, e, l);
+            for (let l = e, t = e * e, c = 0; c < 10; c++)
+                console.log(o, e, t, l, c);
         }
     }
     expect_stdout: true

test/compress/issue-1770.js

@@ -82,7 +82,7 @@ numeric_literal: {
         '    42: 2,',
         '    "42": 3,',
         '    37: 4,',
-        '    a: 5,',
+        '    o: 5,',
         '    1e42: 6,',
         '    b: 7,',
         '    "1e+42": 8',
@@ -92,7 +92,7 @@ numeric_literal: {
         '',
         'console.log(obj[42], obj["42"]);',
         '',
-        'console.log(obj[37], obj["a"], obj[37], obj["37"]);',
+        'console.log(obj[37], obj["o"], obj[37], obj["37"]);',
         '',
         'console.log(obj[1e42], obj["b"], obj["1e+42"]);',
     ]

test/compress/issue-1787.js

@@ -1,6 +1,7 @@
 unary_prefix: {
     options = {
         evaluate: true,
+        inline: true,
         reduce_vars: true,
         unused: true,
     }

test/compress/issue-1943.js

@@ -0,0 +1,31 @@
+operator: {
+    input: {
+        a. //comment
+        typeof
+    }
+    expect_exact: "a.typeof;"
+}
+
+name: {
+    input: {
+        a. //comment
+        b
+    }
+    expect_exact: "a.b;"
+}
+
+keyword: {
+    input: {
+        a. //comment
+        default
+    }
+    expect_exact: "a.default;"
+}
+
+atom: {
+    input: {
+        a. //comment
+        true
+    }
+    expect_exact: "a.true;"
+}

test/compress/issue-2001.js

@@ -0,0 +1,281 @@
+export_func_1: {
+    options = {
+        hoist_funs: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export function f(){};
+    }
+    expect_exact: "export function f(){};"
+}
+
+export_func_2: {
+    options = {
+        hoist_funs: true,
+        side_effects: false,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export function f(){}(1);
+    }
+    expect_exact: "export function f(){};1;"
+}
+
+export_func_3: {
+    options = {
+        hoist_funs: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export function f(){}(1);
+    }
+    expect_exact: "export function f(){};"
+}
+
+export_default_func_1: {
+    options = {
+        hoist_funs: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default function f(){};
+    }
+    expect_exact: "export default function f(){};"
+}
+
+export_default_func_2: {
+    options = {
+        hoist_funs: true,
+        side_effects: false,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default function f(){}(1);
+    }
+    expect_exact: "export default function f(){};1;"
+}
+
+export_default_func_3: {
+    options = {
+        hoist_funs: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default function f(){}(1);
+    }
+    expect_exact: "export default function f(){};"
+}
+
+export_class_1: {
+    options = {
+        hoist_funs: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export class C {};
+    }
+    expect_exact: "export class C{};"
+}
+
+export_class_2: {
+    options = {
+        hoist_funs: true,
+        side_effects: false,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export class C {}(1);
+    }
+    expect_exact: "export class C{};1;"
+}
+
+export_class_3: {
+    options = {
+        hoist_funs: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export class C {}(1);
+    }
+    expect_exact: "export class C{};"
+}
+
+export_default_class_1: {
+    options = {
+        hoist_funs: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default class C {};
+    }
+    expect_exact: "export default class C{};"
+}
+
+export_default_class_2: {
+    options = {
+        hoist_funs: true,
+        side_effects: false,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default class C {}(1);
+    }
+    expect_exact: "export default class C{};1;"
+}
+
+export_default_class_3: {
+    options = {
+        hoist_funs: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default class C {}(1);
+    }
+    expect_exact: "export default class C{};"
+}
+
+export_mangle_1: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export function foo(one, two) {
+            return one - two;
+        };
+    }
+    expect_exact: "export function foo(o,n){return o-n};"
+}
+
+export_mangle_2: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export default function foo(one, two) {
+            return one - two;
+        };
+    }
+    expect_exact: "export default function foo(o,t){return o-t};"
+}
+
+export_mangle_3: {
+    options = {
+        collapse_vars: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export class C {
+            go(one, two) {
+                var z = one;
+                return one - two + z;
+            }
+        };
+    }
+    expect_exact: "export class C{go(r,e){return r-e+r}};"
+}
+
+export_mangle_4: {
+    options = {
+        collapse_vars: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export default class C {
+            go(one, two) {
+                var z = one;
+                return one - two + z;
+            }
+        };
+    }
+    expect_exact: "export default class C{go(e,r){return e-r+e}};"
+}
+
+export_mangle_5: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export default {
+            prop: function(one, two) {
+                return one - two;
+            }
+        };
+    }
+    expect_exact: "export default{prop:function(r,t){return r-t}};"
+}
+
+export_mangle_6: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        var baz = 2;
+        export let foo = 1, bar = baz;
+    }
+    expect_exact: "var o=2;export let foo=1,bar=o;"
+}
+
+export_toplevel_1: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f(){}
+        export function g(){};
+        export default function h(){};
+    }
+    expect: {
+        export function g(){};
+        export default function h(){};
+    }
+}
+
+export_toplevel_2: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        class A {}
+        export class B {};
+        export default class C {};
+    }
+    expect: {
+        export class B {};
+        export default class C {};
+    }
+}
+
+export_default_func_ref: {
+    options = {
+        hoist_funs: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default function f(){};
+        f();
+    }
+    expect_exact: "export default function f(){};f();"
+}

test/compress/issue-203.js

@@ -1,19 +1,21 @@
 
 compress_new_function: {
     options = {
-        unsafe: true
+        unsafe: true,
+        unsafe_Func: true,
     }
     input: {
         new Function("aa, bb", 'return aa;');
     }
     expect: {
-        Function("a", "b", "return a");
+        Function("n", "r", "return n");
     }
 }
 
 compress_new_function_with_destruct: {
     options = {
         unsafe: true,
+        unsafe_Func: true,
         ecma: 6
     }
     beautify = {
@@ -25,10 +27,30 @@ compress_new_function_with_destruct: {
         new Function("[[aa]], [{bb}]", 'return aa;');
     }
     expect: {
-        Function("a", "[b]", "return a");
-        Function("a", "{bb}", "return a");
-        Function("[[a]]", "[{bb}]", 'return a');
+        Function("n", "[r]", "return n");
+        Function("n", "{bb:b}", "return n");
+        Function("[[n]]", "[{bb:b}]", "return n");
     }
 }
 
-
+compress_new_function_with_destruct_arrows: {
+    options = {
+        arrows: true,
+        unsafe: true,
+        unsafe_Func: true,
+        ecma: 6
+    }
+    beautify = {
+        ecma: 6
+    }
+    input: {
+        new Function("aa, [bb]", 'return aa;');
+        new Function("aa, {bb}", 'return aa;');
+        new Function("[[aa]], [{bb}]", 'return aa;');
+    }
+    expect: {
+        Function("aa, [bb]", 'return aa;');
+        Function("aa, {bb}", 'return aa;');
+        Function("[[aa]], [{bb}]", 'return aa;');
+    }
+}

test/compress/issue-281.js

@@ -0,0 +1,483 @@
+collapse_vars_constants: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        inline: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function f1(x) {
+            var a = 4, b = x.prop, c = 5, d = sideeffect1(), e = sideeffect2();
+            return b + (function() { return d - a * e - c; })();
+        }
+        function f2(x) {
+            var a = 4, b = x.prop, c = 5, not_used = sideeffect1(), e = sideeffect2();
+            return b + (function() { return -a * e - c; })();
+        }
+    }
+    expect: {
+        function f1(x) {
+            var b = x.prop, d = sideeffect1(), e = sideeffect2();
+            return b + (d - 4 * e - 5);
+        }
+        function f2(x) {
+            var b = x.prop;
+            sideeffect1();
+            return b + (-4 * sideeffect2() - 5);
+        }
+    }
+}
+
+modified: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        unused: true,
+    }
+    input: {
+        function f5(b) {
+            var a = function() {
+                return b;
+            }();
+            return b++ + a;
+        }
+        console.log(f5(1));
+    }
+    expect: {
+        function f5(b) {
+            var a = b;
+            return b++ + a;
+        }
+        console.log(f5(1));
+    }
+    expect_stdout: "2"
+}
+
+ref_scope: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            var a = 1, b = 2, c = 3;
+            var a = c++, b = b /= a;
+            return function() {
+                return a;
+            }() + b;
+        }());
+    }
+    expect: {
+        console.log(function() {
+            var a = 1, b = 2, c = 3;
+            b = b /= a = c++;
+            return a + b;
+        }());
+    }
+    expect_stdout: true
+}
+
+safe_undefined: {
+    options = {
+        conditionals: true,
+        if_return: true,
+        inline: true,
+        unsafe: false,
+        unused: true,
+    }
+    mangle = {}
+    input: {
+        var a, c;
+        console.log(function(undefined) {
+            return function() {
+                if (a)
+                    return b;
+                if (c)
+                    return d;
+            };
+        }(1)());
+    }
+    expect: {
+        var a, c;
+        console.log(a ? b : c ? d : void 0);
+    }
+    expect_stdout: true
+}
+
+negate_iife_3: {
+    options = {
+        conditionals: true,
+        expression: true,
+        inline: true,
+        negate_iife: true,
+    }
+    input: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+    }
+    expect: {
+        t ? console.log(true) : console.log(false);
+    }
+}
+
+negate_iife_3_off: {
+    options = {
+        conditionals: true,
+        expression: true,
+        inline: true,
+        negate_iife: false,
+    }
+    input: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+    }
+    expect: {
+        t ? console.log(true) : console.log(false);
+    }
+}
+
+negate_iife_4: {
+    options = {
+        conditionals: true,
+        expression: true,
+        inline: true,
+        negate_iife: true,
+        sequences: true,
+    }
+    input: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+        (function(){
+            console.log("something");
+        })();
+    }
+    expect: {
+        t ? console.log(true) : console.log(false), void console.log("something");
+    }
+}
+
+negate_iife_5: {
+    options = {
+        conditionals: true,
+        expression: true,
+        inline: true,
+        negate_iife: true,
+        sequences: true,
+    }
+    input: {
+        if ((function(){ return t })()) {
+            foo(true);
+        } else {
+            bar(false);
+        }
+        (function(){
+            console.log("something");
+        })();
+    }
+    expect: {
+        t ? foo(true) : bar(false), void console.log("something");
+    }
+}
+
+negate_iife_5_off: {
+    options = {
+        conditionals: true,
+        expression: true,
+        inline: true,
+        negate_iife: false,
+        sequences: true,
+    };
+    input: {
+        if ((function(){ return t })()) {
+            foo(true);
+        } else {
+            bar(false);
+        }
+        (function(){
+            console.log("something");
+        })();
+    }
+    expect: {
+        t ? foo(true) : bar(false), void console.log("something");
+    }
+}
+
+issue_1254_negate_iife_true: {
+    options = {
+        expression: true,
+        inline: true,
+        negate_iife: true,
+    }
+    input: {
+        (function() {
+            return function() {
+                console.log('test')
+            };
+        })()();
+    }
+    expect_exact: 'void console.log("test");'
+    expect_stdout: true
+}
+
+issue_1254_negate_iife_nested: {
+    options = {
+        expression: true,
+        inline: true,
+        negate_iife: true,
+    }
+    input: {
+        (function() {
+            return function() {
+                console.log('test')
+            };
+        })()()()()();
+    }
+    expect_exact: '(void console.log("test"))()()();'
+}
+
+negate_iife_issue_1073: {
+    options = {
+        conditionals: true,
+        evaluate: true,
+        inline: true,
+        negate_iife: true,
+        reduce_vars: true,
+        sequences: true,
+        unused: true,
+    };
+    input: {
+        new (function(a) {
+            return function Foo() {
+                this.x = a;
+                console.log(this);
+            };
+        }(7))();
+    }
+    expect: {
+        new function() {
+            this.x = 7,
+            console.log(this);
+        }();
+    }
+    expect_stdout: true
+}
+
+issue_1288_side_effects: {
+    options = {
+        conditionals: true,
+        evaluate: true,
+        inline: true,
+        negate_iife: true,
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    };
+    input: {
+        if (w) ;
+        else {
+            (function f() {})();
+        }
+        if (!x) {
+            (function() {
+                x = {};
+            })();
+        }
+        if (y)
+            (function() {})();
+        else
+            (function(z) {
+                return z;
+            })(0);
+    }
+    expect: {
+        w;
+        x || (x = {});
+        y;
+    }
+}
+
+inner_var_for_in_1: {
+    options = {
+        evaluate: true,
+        inline: true,
+        reduce_vars: true,
+    }
+    input: {
+        function f() {
+            var a = 1, b = 2;
+            for (b in (function() {
+                return x(a, b, c);
+            })()) {
+                var c = 3, d = 4;
+                x(a, b, c, d);
+            }
+            x(a, b, c, d);
+        }
+    }
+    expect: {
+        function f() {
+            var a = 1, b = 2;
+            for (b in x(1, b, c)) {
+                var c = 3, d = 4;
+                x(1, b, c, d);
+            }
+            x(1, b, c, d);
+        }
+    }
+}
+
+issue_1595_3: {
+    options = {
+        evaluate: true,
+        inline: true,
+        passes: 2,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function f(a) {
+            return g(a + 1);
+        })(2);
+    }
+    expect: {
+        g(3);
+    }
+}
+
+issue_1758: {
+    options = {
+        inline: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(function(c) {
+            var undefined = 42;
+            return function() {
+                c--;
+                c--, c.toString();
+                return;
+            }();
+        }());
+    }
+    expect: {
+        console.log(function(c) {
+            var undefined = 42;
+            return c--, c--, void c.toString();
+        }());
+    }
+    expect_stdout: "undefined"
+}
+wrap_iife: {
+    options = {
+        inline: true,
+        negate_iife: false,
+    }
+    beautify = {
+        wrap_iife: true,
+    }
+    input: {
+        (function() {
+            return function() {
+                console.log('test')
+            };
+        })()();
+    }
+    expect_exact: 'void console.log("test");'
+}
+
+wrap_iife_in_expression: {
+    options = {
+        inline: true,
+        negate_iife: false,
+    }
+    beautify = {
+        wrap_iife: true,
+    }
+    input: {
+        foo = (function () {
+            return bar();
+        })();
+    }
+    expect_exact: 'foo=bar();'
+}
+
+wrap_iife_in_return_call: {
+    options = {
+        inline: true,
+        negate_iife: false,
+    }
+    beautify = {
+        wrap_iife: true,
+    }
+    input: {
+        (function() {
+            return (function() {
+                console.log('test')
+            })();
+        })()();
+    }
+    expect_exact: '(void console.log("test"))();'
+}
+
+pure_annotation: {
+    options = {
+        inline: true,
+        side_effects: true,
+    }
+    input: {
+        /*@__PURE__*/(function() {
+            console.log("hello");
+        }());
+    }
+    expect_exact: ""
+}
+
+drop_fargs: {
+    options = {
+        cascade: true,
+        inline: true,
+        keep_fargs: false,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var a = 1;
+        !function(a_1) {
+            a++;
+        }(a++ + (a && a.var));
+        console.log(a);
+    }
+    expect: {
+        var a = 1;
+        !function() {
+            a++;
+        }(++a && a.var);
+        console.log(a);
+    }
+    expect_stdout: "3"
+}
+
+keep_fargs: {
+    options = {
+        cascade: true,
+        inline: true,
+        keep_fargs: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var a = 1;
+        !function(a_1) {
+            a++;
+        }(a++ + (a && a.var));
+        console.log(a);
+    }
+    expect: {
+        var a = 1;
+        !function(a_1) {
+            a++;
+        }(++a && a.var);
+        console.log(a);
+    }
+    expect_stdout: "3"
+}

test/compress/issue-747.js

@@ -1,37 +1,41 @@
 dont_reuse_prop: {
     mangle_props = {
         regex: /asd/
-    };
-
+    }
     input: {
+        "aaaaaaaaaabbbbb";
         var obj = {};
         obj.a = 123;
         obj.asd = 256;
         console.log(obj.a);
     }
     expect: {
+        "aaaaaaaaaabbbbb";
         var obj = {};
         obj.a = 123;
         obj.b = 256;
         console.log(obj.a);
     }
+    expect_stdout: "123"
 }
 
 unmangleable_props_should_always_be_reserved: {
     mangle_props = {
         regex: /asd/
-    };
-
+    }
     input: {
+        "aaaaaaaaaabbbbb";
         var obj = {};
         obj.asd = 256;
         obj.a = 123;
         console.log(obj.a);
     }
     expect: {
+        "aaaaaaaaaabbbbb";
         var obj = {};
         obj.b = 256;
         obj.a = 123;
         console.log(obj.a);
     }
+    expect_stdout: "123"
 }

test/compress/negate-iife.js

@@ -22,7 +22,8 @@ negate_iife_1_off: {
 
 negate_iife_2: {
     options = {
-        negate_iife: true
+        inline: true,
+        negate_iife: true,
     };
     input: {
         (function(){ return {} })().x = 10;
@@ -32,6 +33,7 @@ negate_iife_2: {
 
 negate_iife_2_side_effects: {
     options = {
+        inline: true,
         negate_iife: true,
         side_effects: true,
     }
@@ -58,6 +60,7 @@ negate_iife_3_evaluate: {
     options = {
         conditionals: true,
         evaluate: true,
+        inline: true,
         negate_iife: true,
     }
     input: {
@@ -100,6 +103,7 @@ negate_iife_3_off_evaluate: {
     options = {
         conditionals: true,
         evaluate: true,
+        inline: true,
         negate_iife: false,
     }
     input: {

test/compress/node_version.js

@@ -0,0 +1,38 @@
+eval_let_6: {
+    input: {
+        eval("let a;");
+        console.log();
+    }
+    expect: {
+        eval("let a;");
+        console.log();
+    }
+    expect_stdout: ""
+    node_version: ">=6"
+}
+
+eval_let_4: {
+    input: {
+        eval("let a;");
+        console.log();
+    }
+    expect: {
+        eval("let a;");
+        console.log();
+    }
+    expect_stdout: SyntaxError("Block-scoped declarations (let, const, function, class) not yet supported outside strict mode")
+    node_version: "4"
+}
+
+eval_let_0: {
+    input: {
+        eval("let a;");
+        console.log();
+    }
+    expect: {
+        eval("let a;");
+        console.log();
+    }
+    expect_stdout: SyntaxError("Unexpected identifier")
+    node_version: "<=0.12"
+}

test/compress/object.js

@@ -105,7 +105,7 @@ getter_setter_mangler: {
             };
         }
     }
-    expect_exact: "function f(n,t){return{get:n,set:t,get g(){},set s(n){},c,a:1,m(){}}}"
+    expect_exact: "function f(t,e){return{get:t,set:e,get g(){},set s(t){},c,a:1,m(){}}}"
 }
 
 use_shorthand_opportunity: {
@@ -297,7 +297,7 @@ concise_methods_and_mangle_props: {
     expect: {
         function x() {
             obj = {
-                a() { return 1; }
+                o() { return 1; }
             }
         }
     }

test/compress/parameters.js

@@ -1,4 +1,7 @@
 arrow_functions: {
+    options = {
+        arrows: true,
+    }
     input: {
         (a) => b;  // 1 args
         (a, b) => c;  // n args
@@ -13,6 +16,9 @@ arrow_functions: {
 }
 
 arrow_return: {
+    options = {
+        arrows: true,
+    }
     input: {
         () => {};
         () => { return; };

test/compress/properties.js

@@ -135,11 +135,11 @@ mangle_properties: {
         a['run']({color: "blue", foo: "baz"});
     }
     expect: {
-        a["a"] = "bar";
-        a.b = "red";
-        x = {c: 10};
-        a.d(x.c, a.a);
-        a['d']({b: "blue", a: "baz"});
+        a["o"] = "bar";
+        a.a = "red";
+        x = {r: 10};
+        a.b(x.r, a.o);
+        a['b']({a: "blue", o: "baz"});
     }
 }
 
@@ -178,16 +178,16 @@ mangle_unquoted_properties: {
         function f1() {
             a["foo"] = "bar";
             a.color = "red";
-            a.b = 2;
-            x = {"bar": 10, c: 7};
-            a.c = 9;
+            a.o = 2;
+            x = {"bar": 10, f: 7};
+            a.f = 9;
         }
         function f2() {
             a.foo = "bar";
             a['color'] = "red";
-            x = {bar: 10, c: 7};
-            a.c = 9;
-            a.b = 3;
+            x = {bar: 10, f: 7};
+            a.f = 9;
+            a.o = 3;
         }
     }
 }
@@ -557,3 +557,105 @@ native_prototype: {
         "".indexOf.call(e, "bar");
     }
 }
+
+accessor_boolean: {
+    input: {
+        var a = 1;
+        var b = {
+            get true() {
+                return a;
+            },
+            set false(c) {
+                a = c;
+            }
+        };
+        console.log(b.true, b.false = 2, b.true);
+    }
+    expect_exact: 'var a=1;var b={get true(){return a},set false(c){a=c}};console.log(b.true,b.false=2,b.true);'
+    expect_stdout: "1 2 2"
+}
+
+accessor_get_set: {
+    input: {
+        var a = 1;
+        var b = {
+            get set() {
+                return a;
+            },
+            set get(c) {
+                a = c;
+            }
+        };
+        console.log(b.set, b.get = 2, b.set);
+    }
+    expect_exact: 'var a=1;var b={get set(){return a},set get(c){a=c}};console.log(b.set,b.get=2,b.set);'
+    expect_stdout: "1 2 2"
+}
+
+accessor_null_undefined: {
+    input: {
+        var a = 1;
+        var b = {
+            get null() {
+                return a;
+            },
+            set undefined(c) {
+                a = c;
+            }
+        };
+        console.log(b.null, b.undefined = 2, b.null);
+    }
+    expect_exact: 'var a=1;var b={get null(){return a},set undefined(c){a=c}};console.log(b.null,b.undefined=2,b.null);'
+    expect_stdout: "1 2 2"
+}
+
+accessor_number: {
+    input: {
+        var a = 1;
+        var b = {
+            get 42() {
+                return a;
+            },
+            set 42(c) {
+                a = c;
+            }
+        };
+        console.log(b[42], b[42] = 2, b[42]);
+    }
+    expect_exact: 'var a=1;var b={get 42(){return a},set 42(c){a=c}};console.log(b[42],b[42]=2,b[42]);'
+    expect_stdout: "1 2 2"
+}
+
+accessor_string: {
+    input: {
+        var a = 1;
+        var b = {
+            get "a-b"() {
+                return a;
+            },
+            set "a-b"(c) {
+                a = c;
+            }
+        };
+        console.log(b["a-b"], b["a-b"] = 2, b["a-b"]);
+    }
+    expect_exact: 'var a=1;var b={get"a-b"(){return a},set"a-b"(c){a=c}};console.log(b["a-b"],b["a-b"]=2,b["a-b"]);'
+    expect_stdout: "1 2 2"
+}
+
+accessor_this: {
+    input: {
+        var a = 1;
+        var b = {
+            get this() {
+                return a;
+            },
+            set this(c) {
+                a = c;
+            }
+        };
+        console.log(b.this, b.this = 2, b.this);
+    }
+    expect_exact: 'var a=1;var b={get this(){return a},set this(c){a=c}};console.log(b.this,b.this=2,b.this);'
+    expect_stdout: "1 2 2"
+}

test/compress/pure_getters.js

@@ -119,3 +119,269 @@ 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: {}
+}
+
+issue_2110_1: {
+    options = {
+        cascade: true,
+        pure_getters: "strict",
+        sequences: true,
+        side_effects: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            function f() {}
+            function g() {
+                return this;
+            }
+            f.g = g;
+            return f.g();
+        }
+        console.log(typeof f());
+    }
+    expect: {
+        function f() {
+            function f() {}
+            return f.g = function() {
+                return this;
+            }, f.g();
+        }
+        console.log(typeof f());
+    }
+    expect_stdout: "function"
+}
+
+issue_2110_2: {
+    options = {
+        collapse_vars: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            function f() {}
+            function g() {
+                return this;
+            }
+            f.g = g;
+            return f.g();
+        }
+        console.log(typeof f());
+    }
+    expect: {
+        function f() {
+            function f() {}
+            f.g = function() {
+                return this;
+            };
+            return f.g();
+        }
+        console.log(typeof f());
+    }
+    expect_stdout: "function"
+}
+
+set_immutable_1: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 1;
+        a.foo += "";
+        if (a.foo) console.log("FAIL");
+        else console.log("PASS");
+    }
+    expect: {
+        1..foo += "";
+        if (1..foo) console.log("FAIL");
+        else console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+set_immutable_2: {
+    options = {
+        cascade: true,
+        conditionals: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 1;
+        a.foo += "";
+        if (a.foo) console.log("FAIL");
+        else console.log("PASS");
+    }
+    expect: {
+        var a = 1;
+        a.foo += "", a.foo ? console.log("FAIL") : console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+set_immutable_3: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        var a = 1;
+        a.foo += "";
+        if (a.foo) console.log("FAIL");
+        else console.log("PASS");
+    }
+    expect: {
+        "use strict";
+        1..foo += "";
+        if (1..foo) console.log("FAIL");
+        else console.log("PASS");
+    }
+    expect_stdout: true
+}
+
+set_immutable_4: {
+    options = {
+        cascade: true,
+        conditionals: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        "use strict";
+        var a = 1;
+        a.foo += "";
+        if (a.foo) console.log("FAIL");
+        else console.log("PASS");
+    }
+    expect: {
+        "use strict";
+        var a = 1;
+        a.foo += "", a.foo ? console.log("FAIL") : console.log("PASS");
+    }
+    expect_stdout: true
+}
+
+set_mutable_1: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        !function a() {
+            a.foo += "";
+            if (a.foo) console.log("PASS");
+            else console.log("FAIL");
+        }();
+    }
+    expect: {
+        !function a() {
+            if (a.foo += "") console.log("PASS");
+            else console.log("FAIL");
+        }();
+    }
+    expect_stdout: "PASS"
+}
+
+set_mutable_2: {
+    options = {
+        cascade: true,
+        conditionals: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        !function a() {
+            a.foo += "";
+            if (a.foo) console.log("PASS");
+            else console.log("FAIL");
+        }();
+    }
+    expect: {
+        !function a() {
+            (a.foo += "") ? console.log("PASS") : console.log("FAIL");
+        }();
+    }
+    expect_stdout: "PASS"
+}

test/compress/reduce_vars.js

@@ -2,6 +2,7 @@ reduce_vars: {
     options = {
         conditionals  : true,
         evaluate      : true,
+        inline        : true,
         global_defs   : {
             C : 0
         },
@@ -41,20 +42,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
 }
@@ -1032,6 +1033,7 @@ defun_inline_2: {
 defun_inline_3: {
     options = {
         evaluate: true,
+        inline: true,
         passes: 2,
         reduce_vars: true,
         side_effects: true,
@@ -1054,6 +1056,7 @@ defun_inline_3: {
 
 defun_call: {
     options = {
+        inline: true,
         reduce_vars: true,
         unused: true,
     }
@@ -1080,6 +1083,7 @@ defun_call: {
 
 defun_redefine: {
     options = {
+        inline: true,
         reduce_vars: true,
         unused: true,
     }
@@ -1112,6 +1116,7 @@ defun_redefine: {
 
 func_inline: {
     options = {
+        inline: true,
         reduce_vars: true,
         unused: true,
     }
@@ -1138,6 +1143,7 @@ func_inline: {
 
 func_modified: {
     options = {
+        inline: true,
         reduce_vars: true,
         unused: true,
     }
@@ -1311,19 +1317,47 @@ iife_func_side_effects: {
         unused: true,
     }
     input: {
+        function x() {
+            console.log("x");
+        }
+        function y() {
+            console.log("y");
+        }
+        function z() {
+            console.log("z");
+        }
         (function(a, b, c) {
-            return b();
+            function y() {
+                console.log("FAIL");
+            }
+            return y + b();
         })(x(), function() {
             return y();
         }, z());
     }
     expect: {
+        function x() {
+            console.log("x");
+        }
+        function y() {
+            console.log("y");
+        }
+        function z() {
+            console.log("z");
+        }
         (function(a, b, c) {
             return function() {
+                console.log("FAIL");
+            } + b();
+        })(x(), function() {
             return y();
-            }();
-        })(x(), 0, z());
+        }, z());
     }
+    expect_stdout: [
+        "x",
+        "z",
+        "y",
+    ]
 }
 
 issue_1595_1: {
@@ -1687,6 +1721,7 @@ redefine_arguments_1: {
 redefine_arguments_2: {
     options = {
         evaluate: true,
+        inline: true,
         keep_fargs: false,
         reduce_vars: true,
         side_effects: true,
@@ -1723,6 +1758,7 @@ redefine_arguments_2: {
 redefine_arguments_3: {
     options = {
         evaluate: true,
+        inline: true,
         keep_fargs: false,
         passes: 3,
         reduce_vars: true,
@@ -1749,7 +1785,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"
 }
@@ -1796,6 +1835,7 @@ redefine_farg_1: {
 redefine_farg_2: {
     options = {
         evaluate: true,
+        inline: true,
         keep_fargs: false,
         reduce_vars: true,
         side_effects: true,
@@ -1832,6 +1872,7 @@ redefine_farg_2: {
 redefine_farg_3: {
     options = {
         evaluate: true,
+        inline: true,
         keep_fargs: false,
         passes: 3,
         reduce_vars: true,
@@ -2461,3 +2502,151 @@ 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"
+}
+
+issue_2090_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function() {
+            var x = 1;
+            [].forEach(() => x = 2);
+            return x;
+        }());
+    }
+    expect: {
+        console.log(function() {
+            var x = 1;
+            [].forEach(() => x = 2);
+            return x;
+        }());
+    }
+    expect_stdout: "1"
+    node_version: ">=4"
+}
+
+issue_2090_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function() {
+            var x = 1;
+            [].forEach(() => {
+                x = 2;
+            });
+            return x;
+        }());
+    }
+    expect: {
+        console.log(function() {
+            var x = 1;
+            [].forEach(() => {
+                x = 2;
+            });
+            return x;
+        }());
+    }
+    expect_stdout: "1"
+    node_version: ">=4"
+}
+
+for_in_prop: {
+    options = {
+        reduce_vars: true,
+    }
+    input: {
+        var a = {
+            foo: function() {
+                for (this.b in [1, 2]);
+            }
+        };
+        a.foo();
+        console.log(a.b);
+    }
+    expect: {
+        var a = {
+            foo: function() {
+                for (this.b in [1, 2]);
+            }
+        };
+        a.foo();
+        console.log(a.b);
+    }
+    expect_stdout: "1"
+}

test/compress/sandbox.js

@@ -0,0 +1,14 @@
+console_log: {
+    input: {
+        console.log("%% %s");
+        console.log("%% %s", "%s");
+    }
+    expect: {
+        console.log("%% %s");
+        console.log("%% %s", "%s");
+    }
+    expect_stdout: [
+        "%% %s",
+        "% %s",
+    ]
+}

test/compress/screw-ie8.js

@@ -255,3 +255,73 @@ issue_1586_2: {
     }
     expect_exact: "function f(){try{x()}catch(c){console.log(c.message)}}"
 }
+
+issue_2120_1: {
+    mangle = {
+        ie8: false,
+    }
+    input: {
+        "aaaaaaaa";
+        var a = 1, b = "FAIL";
+        try {
+            throw 1;
+        } catch (c) {
+            try {
+                throw 0;
+            } catch (a) {
+                if (c) b = "PASS";
+            }
+        }
+        console.log(b);
+    }
+    expect: {
+        "aaaaaaaa";
+        var a = 1, b = "FAIL";
+        try {
+            throw 1;
+        } catch (t) {
+            try {
+                throw 0;
+            } catch (a) {
+                if (t) b = "PASS";
+            }
+        }
+        console.log(b);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_2120_2: {
+    mangle = {
+        ie8: true,
+    }
+    input: {
+        "aaaaaaaa";
+        var a = 1, b = "FAIL";
+        try {
+            throw 1;
+        } catch (c) {
+            try {
+                throw 0;
+            } catch (a) {
+                if (c) b = "PASS";
+            }
+        }
+        console.log(b);
+    }
+    expect: {
+        "aaaaaaaa";
+        var a = 1, b = "FAIL";
+        try {
+            throw 1;
+        } catch (c) {
+            try {
+                throw 0;
+            } catch (a) {
+                if (c) b = "PASS";
+            }
+        }
+        console.log(b);
+    }
+    expect_stdout: "PASS"
+}

test/compress/sequences.js

@@ -734,3 +734,23 @@ reassign_const: {
     }
     expect_stdout: true
 }
+
+issue_2062: {
+    options = {
+        booleans: true,
+        cascade: true,
+        conditionals: true,
+        side_effects: true,
+    }
+    input: {
+        var a = 1;
+        if ([ a || a++ + a--, a++ + a--, a && a.var ]);
+        console.log(a);
+    }
+    expect: {
+        var a = 1;
+        a || (a++, a--), a++, --a && a.var;
+        console.log(a);
+    }
+    expect_stdout: "1"
+}

test/compress/string-literal.js

@@ -8,3 +8,12 @@ octal_escape_sequence: {
         var border_check = "\x20\x30\x38\x30\x00\x30\xc0\x30";
     }
 }
+
+issue_1929: {
+    input: {
+        function f(s) {
+            return s.split(/[\\/]/);
+        }
+    }
+    expect_exact: "function f(s){return s.split(/[\\\\/]/)}"
+}

test/compress/yield.js

@@ -190,3 +190,12 @@ yield_sub: {
     }
     expect_exact: 'function*foo(){yield x["foo"];(yield x)["foo"];yield(yield obj.foo())["bar"]()}'
 }
+
+yield_as_ES5_property: {
+    input: {
+        "use strict";
+        console.log({yield: 42}.yield);
+    }
+    expect_exact: '"use strict";console.log({yield:42}.yield);'
+    expect_stdout: "42"
+}

test/fetch.js

@@ -0,0 +1,31 @@
+var fs = require("fs");
+var path = require("path");
+
+try {
+    fs.mkdirSync("./tmp");
+} catch (e) {
+    if (e.code != "EEXIST") throw e;
+}
+
+function local(url) {
+    return path.join("./tmp", encodeURIComponent(url));
+}
+
+function read(url) {
+    return fs.createReadStream(local(url));
+}
+
+module.exports = function(url, callback) {
+    var result = read(url);
+    result.on("error", function(e) {
+        if (e.code != "ENOENT") return callback(e);
+        require(url.slice(0, url.indexOf(":"))).get(url, function(res) {
+            if (res.statusCode !== 200) return callback(res);
+            res.pipe(fs.createWriteStream(local(url)).on("close", function() {
+                callback(null, read(url));
+            }));
+        });
+    }).on("open", function() {
+        callback(null, result);
+    });
+};

test/input/invalid/else.js

@@ -0,0 +1 @@
+if (0) else 1;

test/input/invalid/export_1.js

@@ -0,0 +1,3 @@
+{
+    export var V = 1;
+}

test/input/invalid/export_2.js

@@ -0,0 +1 @@
+export class{};

test/input/invalid/export_3.js

@@ -0,0 +1 @@
+export function(){};

test/input/invalid/for-in_1.js

@@ -0,0 +1,4 @@
+var a, b = [1, 2];
+for (1, 2, a in b) {
+    console.log(a, b[a]);
+}

test/input/invalid/for-in_2.js

@@ -0,0 +1,4 @@
+var c = [1, 2];
+for (var a, b in c) {
+    console.log(a, c[a]);
+}

test/input/invalid/import.js

@@ -0,0 +1,3 @@
+{
+    import A from "B";
+}

test/input/invalid/return.js

@@ -0,0 +1 @@
+return 42;

test/input/invalid/sequence.js

@@ -0,0 +1 @@
+(a, ...b);

test/input/issue-2082/sample.js

@@ -0,0 +1 @@
+console.log(x);

test/input/issue-2082/sample.js.map

@@ -0,0 +1 @@
+{"version": 3,"sources": ["index.js"],"mappings": ";"}

test/input/issue-505/input.js

@@ -0,0 +1,5 @@
+function test(callback) {
+    'aaaaaaaaaaaaaaaa';
+    callback(err, data);
+    callback(err, data);
+}

test/input/issue-505/output.js

@@ -0,0 +1,5 @@
+function test(a){
+"aaaaaaaaaaaaaaaa"
+;a(err,data),a(err,data)
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIjAiXSwibmFtZXMiOlsidGVzdCIsImNhbGxiYWNrIiwiZXJyIiwiZGF0YSJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsS0FBS0M7QUFDVjtDQUNBQSxFQUFTQyxJQUFLQyxNQUNkRixFQUFTQyxJQUFLQyJ9

test/input/issue-520/output.js

@@ -1,2 +1,2 @@
 new function(){console.log(3)};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0ZGluIl0sIm5hbWVzIjpbImNvbnNvbGUiLCJsb2ciXSwibWFwcGluZ3MiOiJBQUErQyxHQUFyQyxZQUFnQkEsUUFBUUMsSUFBSSIsInNvdXJjZXNDb250ZW50IjpbImNsYXNzIEZvbyB7IGNvbnN0cnVjdG9yKCl7Y29uc29sZS5sb2coMSsyKTt9IH0gbmV3IEZvbygpO1xuIl19
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0ZGluIl0sIm5hbWVzIjpbImNvbnNvbGUiLCJsb2ciXSwibWFwcGluZ3MiOiJBQUErQyxJQUFyQyxXQUFnQkEsUUFBUUMsSUFBSSIsInNvdXJjZXNDb250ZW50IjpbImNsYXNzIEZvbyB7IGNvbnN0cnVjdG9yKCl7Y29uc29sZS5sb2coMSsyKTt9IH0gbmV3IEZvbygpO1xuIl19

test/jetstream.js

@@ -3,7 +3,7 @@
 
 "use strict";
 
-var site = "http://browserbench.org/JetStream/";
+var site = "http://browserbench.org/JetStream";
 if (typeof phantom == "undefined") {
     // workaround for tty output truncation upon process.exit()
     [process.stdout, process.stderr].forEach(function(stream){
@@ -11,25 +11,38 @@ if (typeof phantom == "undefined") {
             stream._handle.setBlocking(true);
     });
     var args = process.argv.slice(2);
+    var debug = args.indexOf("--debug");
+    if (debug >= 0) {
+        args.splice(debug, 1);
+        debug = true;
+    } else {
+        debug = false;
+    }
     if (!args.length) {
-        args.push("-mc");
+        args.push("-mcb", "beautify=false,webkit");
     }
-    args.push("--stats");
+    args.push("--timings");
     var child_process = require("child_process");
-    try {
-        require("phantomjs-prebuilt");
-    } catch(e) {
-        child_process.execSync("npm install phantomjs-prebuilt@2.1.14");
-    }
+    var fetch = require("./fetch");
     var http = require("http");
     var server = http.createServer(function(request, response) {
         request.resume();
-        var url = decodeURIComponent(request.url.slice(1));
+        var url = site + request.url;
+        fetch(url, function(err, res) {
+            if (err) throw err;
+            response.writeHead(200, {
+                "Content-Type": {
+                    css: "text/css",
+                    js: "application/javascript",
+                    png: "image/png"
+                }[url.slice(url.lastIndexOf(".") + 1)] || "text/html; charset=utf-8"
+            });
+            if (/\.js$/.test(url)) {
                 var stderr = "";
                 var uglifyjs = child_process.fork("bin/uglifyjs", args, {
                     silent: true
                 }).on("exit", function(code) {
-            console.log("uglifyjs", url.indexOf(site) == 0 ? url.slice(site.length) : url, args.join(" "));
+                    console.log("uglifyjs", url.slice(site.length + 1), args.join(" "));
                     console.log(stderr);
                     if (code) throw new Error("uglifyjs failed with code " + code);
                 });
@@ -37,20 +50,31 @@ if (typeof phantom == "undefined") {
                     stderr += data;
                 }).setEncoding("utf8");
                 uglifyjs.stdout.pipe(response);
-        http.get(url, function(res) {
                 res.pipe(uglifyjs.stdin);
+            } else {
+                res.pipe(response);
+            }
         });
-    }).listen().on("listening", function() {
-        var phantomjs = require("phantomjs-prebuilt");
-        var program = phantomjs.exec(process.argv[1], server.address().port);
+    }).listen();
+    server.on("listening", function() {
+        var port = server.address().port;
+        if (debug) {
+            console.log("http://localhost:" + port + "/");
+        } else {
+            child_process.exec("npm install phantomjs-prebuilt@2.1.14 --no-save", function(error) {
+                if (error) throw error;
+                var program = require("phantomjs-prebuilt").exec(process.argv[1], port);
                 program.stdout.pipe(process.stdout);
                 program.stderr.pipe(process.stderr);
                 program.on("exit", function(code) {
                     server.close();
                     if (code) throw new Error("JetStream failed!");
                     console.log("JetStream completed successfully.");
+                    process.exit(0);
                 });
             });
+        }
+    });
     server.timeout = 0;
 } else {
     var page = require("webpage").create();
@@ -63,10 +87,6 @@ if (typeof phantom == "undefined") {
         phantom.exit(1);
     };
     var url = "http://localhost:" + require("system").args[1] + "/";
-    page.onResourceRequested = function(requestData, networkRequest) {
-        if (/\.js$/.test(requestData.url))
-            networkRequest.changeUrl(url + encodeURIComponent(requestData.url));
-    }
     page.onConsoleMessage = function(msg) {
         if (/Error:/i.test(msg)) {
             console.error(msg);
@@ -77,8 +97,8 @@ if (typeof phantom == "undefined") {
             phantom.exit();
         }
     };
-    page.open(site, function(status) {
-        if (status != "success") phantomjs.exit(1);
+    page.open(url, function(status) {
+        if (status != "success") phantom.exit(1);
         page.evaluate(function() {
             JetStream.switchToQuick();
             JetStream.start();

test/mocha/arrow.js

@@ -62,23 +62,20 @@ describe("Arrow functions", function() {
         }
     });
     it("Should not accept arrow functions in the middle or end of an expression", function() {
-        var tests = [
+        [
+            "0 + x => 0",
+            "0 + async x => 0",
             "typeof x => 0",
-            "0 + x => 0"
-        ];
-        var test = function(code) {
-            return function() {
+            "typeof async x => 0",
+            "typeof (x) => null",
+            "typeof async (x) => null",
+        ].forEach(function(code) {
+            assert.throws(function() {
                 uglify.parse(code);
-            }
-        }
-        var error = function(e) {
-            return e instanceof uglify.JS_Parse_Error &&
-                e.message === "Unexpected token: arrow (=>)";
-        }
-
-        for (var i = 0; i < tests.length; i++) {
-            assert.throws(test(tests[i]), error);
-        }
+            }, function(e) {
+                return e instanceof uglify.JS_Parse_Error && /^Unexpected /.test(e.message);
+            }, code);
+        });
     });
 
     it("Should parse a function containing default assignment correctly", function() {

test/mocha/cli.js

@@ -1,6 +1,7 @@
 var assert = require("assert");
 var exec = require("child_process").exec;
 var readFileSync = require("fs").readFileSync;
+var semver = require("semver");
 
 function read(path) {
     return readFileSync(path, "utf8");
@@ -9,9 +10,11 @@ function read(path) {
 describe("bin/uglifyjs", function () {
     var uglifyjscmd = '"' + process.argv[0] + '" bin/uglifyjs';
     it("should produce a functional build when using --self", function (done) {
-        this.timeout(15000);
+        this.timeout(60000);
 
-        var command = uglifyjscmd + ' --self -cm --wrap WrappedUglifyJS';
+        var command = uglifyjscmd + ' --self -mc ecma=';
+        command += semver.satisfies(process.version, ">=4") ? "6" : "5";
+        command += ',passes=3,keep_fargs=false,unsafe --wrap WrappedUglifyJS';
 
         exec(command, function (err, stdout) {
             if (err) throw err;
@@ -19,7 +22,9 @@ describe("bin/uglifyjs", function () {
             eval(stdout);
 
             assert.strictEqual(typeof WrappedUglifyJS, 'object');
-            assert.strictEqual(WrappedUglifyJS.minify("foo([true,,2+3]);").code, "foo([!0,,5]);");
+            var result = WrappedUglifyJS.minify("foo([true,,2+3]);");
+            assert.strictEqual(result.error, undefined);
+            assert.strictEqual(result.code, "foo([!0,,5]);");
 
             done();
         });
@@ -61,7 +66,7 @@ describe("bin/uglifyjs", function () {
             if (err) throw err;
 
             assert.strictEqual(stdout, "var bar=function(){function foo(bar){return bar}return foo}();\n" +
-               "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaW5wdXQvaXNzdWUtMTMyMy9zYW1wbGUuanMiXSwibmFtZXMiOlsiYmFyIiwiZm9vIl0sIm1hcHBpbmdzIjoiQUFBQSxHQUFJQSxLQUFNLFdBQ04sUUFBU0MsS0FBS0QsS0FDVixNQUFPQSxLQUdYLE1BQU9DIn0=\n");
+                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaW5wdXQvaXNzdWUtMTMyMy9zYW1wbGUuanMiXSwibmFtZXMiOlsiYmFyIiwiZm9vIl0sIm1hcHBpbmdzIjoiQUFBQSxJQUFJQSxJQUFNLFdBQ04sU0FBU0MsSUFBS0QsS0FDVixPQUFPQSxJQUdYLE9BQU9DIn0=\n");
             done();
         });
     });
@@ -75,6 +80,23 @@ describe("bin/uglifyjs", function () {
             done();
         });
     });
+    it("should not consider source map file content as source map file name (issue #2082)", function (done) {
+        var command = [
+            uglifyjscmd,
+            "test/input/issue-2082/sample.js",
+            "--source-map", "content=test/input/issue-2082/sample.js.map",
+            "--source-map", "url=inline",
+        ].join(" ");
+
+        exec(command, function (err, stdout, stderr) {
+            if (err) throw err;
+
+            var stderrLines = stderr.split('\n');
+            assert.strictEqual(stderrLines[0], 'INFO: Using input source map: test/input/issue-2082/sample.js.map');
+            assert.notStrictEqual(stderrLines[1], 'INFO: Using input source map: {"version": 3,"sources": ["index.js"],"mappings": ";"}');
+            done();
+        });
+    });
     it("Should work with --keep-fnames (mangle only)", function (done) {
         var command = uglifyjscmd + ' test/input/issue-1431/sample.js --keep-fnames -m';
 
@@ -173,7 +195,7 @@ describe("bin/uglifyjs", function () {
 
             assert.strictEqual(stdout, [
                 "var bar=function(){function foo(bar){return bar}return foo}();",
-                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaW5wdXQvaXNzdWUtMTMyMy9zYW1wbGUuanMiXSwibmFtZXMiOlsiYmFyIiwiZm9vIl0sIm1hcHBpbmdzIjoiQUFBQSxHQUFJQSxLQUFNLFdBQ04sUUFBU0MsS0FBS0QsS0FDVixNQUFPQSxLQUdYLE1BQU9DIn0=",
+                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaW5wdXQvaXNzdWUtMTMyMy9zYW1wbGUuanMiXSwibmFtZXMiOlsiYmFyIiwiZm9vIl0sIm1hcHBpbmdzIjoiQUFBQSxJQUFJQSxJQUFNLFdBQ04sU0FBU0MsSUFBS0QsS0FDVixPQUFPQSxJQUdYLE9BQU9DIn0=",
                 "",
             ].join("\n"));
             assert.strictEqual(stderr, "WARN: inline source map not found\n");
@@ -484,6 +506,141 @@ describe("bin/uglifyjs", function () {
             done();
         });
     });
+    it("Should throw syntax error (else)", function(done) {
+        var command = uglifyjscmd + ' test/input/invalid/else.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/else.js:1,7",
+                "if (0) else 1;",
+                "       ^",
+                "ERROR: Unexpected token: keyword (else)"
+            ].join("\n"));
+            done();
+        });
+    });
+    it("Should throw syntax error (return)", function(done) {
+        var command = uglifyjscmd + ' test/input/invalid/return.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/return.js:1,0",
+                "return 42;",
+                "^",
+                "ERROR: 'return' outside of function"
+            ].join("\n"));
+            done();
+        });
+    });
+    it("Should throw syntax error (block-level export)", function(done) {
+        var command = uglifyjscmd + ' test/input/invalid/export_1.js -m';
+
+        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/export_1.js:2,4",
+                "    export var V = 1;",
+                "    ^",
+                "ERROR: Export statement may only appear at top level"
+            ].join("\n"));
+            done();
+        });
+    });
+    it("Should throw syntax error (block-level import)", function(done) {
+        var command = uglifyjscmd + ' test/input/invalid/import.js -m';
+
+        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/import.js:2,4",
+                '    import A from "B";',
+                "    ^",
+                "ERROR: Import statement may only appear at top level"
+            ].join("\n"));
+            done();
+        });
+    });
+    it("Should throw syntax error (anonymous class)", function(done) {
+        var command = uglifyjscmd + ' test/input/invalid/export_2.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/export_2.js:1,12",
+                "export class{};",
+                "            ^",
+                "ERROR: Unexpected token: punc ({)"
+            ].join("\n"));
+            done();
+        });
+    });
+    it("Should throw syntax error (anonymous function)", function(done) {
+        var command = uglifyjscmd + ' test/input/invalid/export_3.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/export_3.js:1,15",
+                "export function(){};",
+                "               ^",
+                "ERROR: Unexpected token: punc (()"
+            ].join("\n"));
+            done();
+        });
+    });
+    it("Should throw syntax error (spread in sequence)", function(done) {
+        var command = uglifyjscmd + ' test/input/invalid/sequence.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/sequence.js:1,4",
+                "(a, ...b);",
+                "    ^",
+                "ERROR: Unexpected token: expand (...)"
+            ].join("\n"));
+            done();
+        });
+    });
+    it("Should throw syntax error (for-in init)", function(done) {
+        var command = uglifyjscmd + ' test/input/invalid/for-in_1.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/for-in_1.js:2,5",
+                "for (1, 2, a in b) {",
+                "     ^",
+                "ERROR: Invalid left-hand side in for..in loop"
+            ].join("\n"));
+            done();
+        });
+    });
+    it("Should throw syntax error (for-in var)", function(done) {
+        var command = uglifyjscmd + ' test/input/invalid/for-in_2.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/for-in_2.js:2,5",
+                "for (var a, b in c) {",
+                "     ^",
+                "ERROR: Only one variable declaration allowed in for..in loop"
+            ].join("\n"));
+            done();
+        });
+    });
     it("Should handle literal string as source map input", function(done) {
         var command = [
             uglifyjscmd,
@@ -497,7 +654,7 @@ describe("bin/uglifyjs", function () {
 
             assert.strictEqual(stdout, [
                 '"use strict";var foo=function foo(x){return"foo "+x};console.log(foo("bar"));',
-                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LmpzIl0sIm5hbWVzIjpbImZvbyIsIngiLCJjb25zb2xlIiwibG9nIl0sIm1hcHBpbmdzIjoiWUFBQSxJQUFJQSxLQUFNLFFBQU5BLEtBQU1DLEdBQUEsTUFBSyxPQUFTQSxFQUN4QkMsU0FBUUMsSUFBSUgsSUFBSSJ9",
+                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LmpzIl0sIm5hbWVzIjpbImZvbyIsIngiLCJjb25zb2xlIiwibG9nIl0sIm1hcHBpbmdzIjoiYUFBQSxJQUFJQSxJQUFNLFNBQU5BLElBQU1DLEdBQUEsTUFBSyxPQUFTQSxHQUN4QkMsUUFBUUMsSUFBSUgsSUFBSSJ9",
                 ""
             ].join("\n"));
             done();
@@ -520,4 +677,33 @@ describe("bin/uglifyjs", function () {
             done();
         });
     });
+    it("Should print supported options on invalid option syntax", function(done) {
+        var command = uglifyjscmd + " test/input/comments/filter.js -b ascii-only";
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.ok(/^Supported options:\n[\s\S]*?\nERROR: `ascii-only` is not a supported option/.test(stderr), stderr);
+            done();
+        });
+    });
+    it("Should work with --mangle reserved=[]", function (done) {
+        var command = uglifyjscmd + ' test/input/issue-505/input.js -m reserved=[callback]';
+
+        exec(command, function (err, stdout) {
+            if (err) throw err;
+
+            assert.strictEqual(stdout, 'function test(callback){"aaaaaaaaaaaaaaaa";callback(err,data);callback(err,data)}\n');
+            done();
+        });
+    });
+    it("Should work with --mangle reserved=false", function (done) {
+        var command = uglifyjscmd + ' test/input/issue-505/input.js -m reserved=false';
+
+        exec(command, function (err, stdout) {
+            if (err) throw err;
+
+            assert.strictEqual(stdout, 'function test(a){"aaaaaaaaaaaaaaaa";a(err,data);a(err,data)}\n');
+            done();
+        });
+    });
 });

test/mocha/directives.js

@@ -361,18 +361,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/export.js

@@ -3,7 +3,6 @@ var uglify = require("../node");
 
 describe("Export", function() {
     it("Should parse export directives", function() {
-
         var inputs = [
             ['export * from "a.js"', ['*'], "a.js"],
             ['export {A} from "a.js"', ['A'], "a.js"],
@@ -12,17 +11,17 @@ describe("Export", function() {
             ['export {A, B} from "a.js"', ['A', 'B'], "a.js"],
         ];
 
-        var test = function(code) {
+        function test(code) {
             return uglify.parse(code);
-        };
+        }
 
-        var extractNames = function(symbols) {
+        function extractNames(symbols) {
             var ret = [];
             for (var i = 0; i < symbols.length; i++) {
-                ret.push(symbols[i].name.name)
+                ret.push(symbols[i].foreign_name.name);
             }
             return ret;
-        };
+        }
 
         for (var i = 0; i < inputs.length; i++) {
             var ast = test(inputs[i][0]);
@@ -34,7 +33,7 @@ describe("Export", function() {
             assert(st instanceof uglify.AST_Export);
             var actualNames = extractNames(st.exported_names);
             assert.deepEqual(actualNames, names);
-            assert.equal(st.module_name.value, filename)
+            assert.equal(st.module_name.value, filename);
         }
-    })
+    });
 });

test/mocha/function.js

@@ -191,15 +191,51 @@ describe("Function", function() {
         ];
         var test = function(code) {
             return function() {
-                uglify.parse(code);
+                uglify.parse(code, { ecma: 5 });
             }
         }
         var error = function(e) {
-            return e instanceof uglify.JS_Parse_Error &&
-                e.message === "Invalid function parameter";
+            return e instanceof uglify.JS_Parse_Error;
         }
         for (var i = 0; i < tests.length; i++) {
-            assert.throws(test(tests[i]), error);
+            assert.throws(test(tests[i]), error, tests[i]);
+        }
+    });
+    it("Should accept trailing commas only for ES8", function() {
+        [
+            "new Foo(a, );",
+            "async(...[1, 2], );",
+            "console.log(...[1, 2], );",
+            "!function(a, b, ){ console.log(a + b); }(3, 4, );",
+        ].forEach(function(code) {
+            uglify.parse(code, { ecma: 8 });
+            assert.throws(function() {
+                uglify.parse(code, { ecma: 6 });
+            }, function(e) {
+                return e instanceof uglify.JS_Parse_Error;
+            }, code);
+        });
+    });
+    it("Should not accept invalid trailing commas", function() {
+        var tests = [
+            "f(, );",
+            "(, ) => {};",
+            "(...p, ) => {};",
+            "function f(, ) {}",
+            "function f(...p, ) {}",
+            "function foo(a, b, , ) {}",
+            'console.log("hello", , );',
+        ];
+        var test = function(code) {
+            return function() {
+                uglify.parse(code, { ecma: 8 });
+            }
+        }
+        var error = function(e) {
+            return e instanceof uglify.JS_Parse_Error;
+        }
+        for (var i = 0; i < tests.length; i++) {
+            assert.throws(test(tests[i]), error, tests[i]);
         }
     });
     it("Should not accept an initializer when parameter is a rest parameter", function() {

test/mocha/glob.js

@@ -31,7 +31,7 @@ describe("bin/uglifyjs with input file globs", function() {
         exec(command, function(err, stdout) {
             if (err) throw err;
 
-            assert.strictEqual(stdout, 'var print=console.log.bind(console),a=function(n){return 3*n}(3),b=function(n){return n/2}(12);print("qux",a,b),function(n){print("Foo:",2*n)}(11);\n');
+            assert.strictEqual(stdout, 'var print=console.log.bind(console);print("qux",9,6),print("Foo:",2*11);\n');
             done();
         });
     });

test/mocha/let.js

@@ -2,29 +2,37 @@ var Uglify = require('../../');
 var assert = require("assert");
 
 describe("let", function() {
-    it("Should not produce `let` as a variable name in mangle", function(done) {
+    it("Should not produce reserved keywords as variable name in mangle", function(done) {
         this.timeout(10000);
 
         // Produce a lot of variables in a function and run it through mangle.
-        var s = '"use strict"; function foo() {';
-        for (var i = 0; i < 21000; ++i) {
+        var s = '"dddddeeeeelllllooooottttt"; function foo() {';
+        for (var i = 0; i < 18000; i++) {
             s += "var v" + i + "=0;";
         }
         s += '}';
         var result = Uglify.minify(s, {compress: false});
 
         // Verify that select keywords and reserved keywords not produced
-        assert.strictEqual(result.code.indexOf("var let="), -1);
-        assert.strictEqual(result.code.indexOf("var do="), -1);
-        assert.strictEqual(result.code.indexOf("var var="), -1);
+        [
+            "do",
+            "let",
+            "var",
+        ].forEach(function(name) {
+            assert.strictEqual(result.code.indexOf("var " + name + "="), -1);
+        });
 
         // Verify that the variable names that appeared immediately before
-        // and after the erroneously generated `let` variable name still exist
+        // and after the erroneously generated variable name still exist
         // to show the test generated enough symbols.
-        assert(result.code.indexOf("var ket=") >= 0);
-        assert(result.code.indexOf("var met=") >= 0);
+        [
+            "to", "eo",
+            "eet", "fet",
+            "rar", "oar",
+        ].forEach(function(name) {
+            assert.ok(result.code.indexOf("var " + name + "=") >= 0);
+        });
 
         done();
     });
 });
-

test/mocha/minify.js

@@ -13,6 +13,13 @@ describe("minify", function() {
         assert.strictEqual(result.code, 'function foo(n){return n?3:7}');
     });
 
+    it("Should skip inherited keys from `files`", function() {
+        var files = Object.create({ skip: this });
+        files[0] = "alert(1 + 1)";
+        var result = Uglify.minify(files);
+        assert.strictEqual(result.code, "alert(2);");
+    });
+
     describe("keep_quoted_props", function() {
         it("Should preserve quotes in object literals", function() {
             var js = 'var foo = {"x": 1, y: 2, \'z\': 3};';
@@ -106,7 +113,7 @@ describe("minify", function() {
                         content: "inline"
                     }
                 });
-                assert.strictEqual(result.code, "var bar=function(){function foo(bar){return bar}return foo}();");
+                assert.strictEqual(result.code, "var bar=function(){return function(bar){return bar}}();");
                 assert.strictEqual(warnings.length, 1);
                 assert.strictEqual(warnings[0], "inline source map not found");
             } finally {
@@ -138,13 +145,25 @@ describe("minify", function() {
             });
             var code = result.code;
             assert.strictEqual(code, "var a=function(n){return n};\n" +
-                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIjAiXSwibmFtZXMiOlsiYSIsImZvbyJdLCJtYXBwaW5ncyI6IkFBQUEsR0FBSUEsR0FBSSxTQUFTQyxHQUFPLE1BQU9BIn0=");
+                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIjAiXSwibmFtZXMiOlsiYSIsImZvbyJdLCJtYXBwaW5ncyI6IkFBQUEsSUFBSUEsRUFBSSxTQUFTQyxHQUFPLE9BQU9BIn0=");
         });
         it("should not append source map to output js when sourceMapInline is not enabled", function() {
             var result = Uglify.minify('var a = function(foo) { return foo; };');
             var code = result.code;
             assert.strictEqual(code, "var a=function(n){return n};");
         });
+        it("should work with max_line_len", function() {
+            var result = Uglify.minify(read("./test/input/issue-505/input.js"), {
+                output: {
+                    max_line_len: 20
+                },
+                sourceMap: {
+                    url: "inline"
+                }
+            });
+            assert.strictEqual(result.error, undefined);
+            assert.strictEqual(result.code, read("./test/input/issue-505/output.js"));
+        });
     });
 
     describe("#__PURE__", function() {
@@ -181,4 +200,31 @@ describe("minify", function() {
             assert.strictEqual(err.col, 12);
         });
     });
+
+    describe("global_defs", function() {
+        it("should throw for non-trivial expressions", function() {
+            var result = Uglify.minify("alert(42);", {
+                compress: {
+                    global_defs: {
+                        "@alert": "debugger"
+                    }
+                }
+            });
+            var err = result.error;
+            assert.ok(err instanceof Error);
+            assert.strictEqual(err.stack.split(/\n/)[0], "Error: Can't handle expression: debugger");
+        });
+        it("should skip inherited properties", function() {
+            var foo = Object.create({ skip: this });
+            foo.bar = 42;
+            var result = Uglify.minify("alert(FOO);", {
+                compress: {
+                    global_defs: {
+                        FOO: foo
+                    }
+                }
+            });
+            assert.strictEqual(result.code, "alert({bar:42});");
+        });
+    });
 });

test/mocha/release.js

@@ -1,23 +1,20 @@
 var assert = require("assert");
+var semver = require("semver");
 var spawn = require("child_process").spawn;
 
 if (!process.env.UGLIFYJS_TEST_ALL) return;
 
 function run(command, args, done) {
-    var id = setInterval(function() {
-        process.stdout.write("\0");
-    }, 5 * 60 * 1000);
     spawn(command, args, {
-        stdio: "ignore"
+        stdio: [ "ignore", 1, 2 ]
     }).on("exit", function(code) {
-        clearInterval(id);
         assert.strictEqual(code, 0);
         done();
     });
 }
 
 describe("test/benchmark.js", function() {
-    this.timeout(5 * 60 * 1000);
+    this.timeout(10 * 60 * 1000);
     [
         "-b",
         "-b bracketize",
@@ -36,11 +33,9 @@ describe("test/benchmark.js", function() {
     });
 });
 
+if (semver.satisfies(process.version, "0.12")) return;
 describe("test/jetstream.js", function() {
     this.timeout(20 * 60 * 1000);
-    it("Should install phantomjs-prebuilt", function(done) {
-        run("npm", ["install", "phantomjs-prebuilt@2.1.14"], done);
-    });
     [
         "-mc",
         "-mc keep_fargs=false,passes=3,pure_getters,unsafe,unsafe_comps,unsafe_math,unsafe_proto",
@@ -48,6 +43,7 @@ describe("test/jetstream.js", function() {
         it("Should pass with options " + options, function(done) {
             var args = options.split(/ /);
             args.unshift("test/jetstream.js");
+            args.push("-b", "beautify=false,webkit");
             run(process.argv[0], args, done);
         });
     });

test/mocha/spidermonkey.js

@@ -4,7 +4,7 @@ var uglify = require("../node");
 
 describe("spidermonkey export/import sanity test", function() {
     it("should produce a functional build when using --self with spidermonkey", function(done) {
-        this.timeout(30000);
+        this.timeout(60000);
 
         var uglifyjs = '"' + process.argv[0] + '" bin/uglifyjs';
         var command = uglifyjs + " --self -cm --wrap SpiderUglify -o spidermonkey | " +
@@ -15,7 +15,9 @@ describe("spidermonkey export/import sanity test", function() {
 
             eval(stdout);
             assert.strictEqual(typeof SpiderUglify, "object");
-            assert.strictEqual(SpiderUglify.minify("foo([true,,2+3]);").code, "foo([!0,,5]);");
+            var result = SpiderUglify.minify("foo([true,,2+3]);");
+            assert.strictEqual(result.error, undefined);
+            assert.strictEqual(result.code, "foo([!0,,5]);");
 
             done();
         });

test/mocha/yield.js

@@ -65,9 +65,9 @@ describe("Yield", function() {
         );
     });
 
-    it("Should not allow yield to be used as symbol, identifier or property outside generators in strict mode", function() {
+    it("Should not allow yield to be used as symbol, identifier or shorthand property outside generators in strict mode", function() {
         var tests = [
-            // Fail as as_symbol
+            // Fail in as_symbol
             '"use strict"; import yield from "bar";',
             '"use strict"; yield = 123;',
             '"use strict"; yield: "123";',
@@ -79,13 +79,12 @@ describe("Yield", function() {
             '"use strict"; var yield = "foo";',
             '"use strict"; class yield {}',
 
-            // Fail as maybe_assign
+            // Fail in maybe_assign
             '"use strict"; var foo = yield;',
             '"use strict"; var foo = bar = yield',
 
-            // Fail as as_property_name
+            // Fail in as_property_name
             '"use strict"; var foo = {yield};',
-            '"use strict"; var bar = {yield: "foo"};'
         ];
 
         var fail = function(e) {

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

@@ -5,6 +5,7 @@ var path = require("path");
 var fs = require("fs");
 var assert = require("assert");
 var sandbox = require("./sandbox");
+var semver = require("semver");
 
 var tests_dir = path.dirname(module.filename);
 var failures = 0;
@@ -23,12 +24,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() {
@@ -91,7 +86,6 @@ function run_compress_tests() {
         log_start_file(file);
         function test_case(test) {
             log_test(test.name);
-            U.base54.reset();
             var output_options = test.beautify || {};
             var expect;
             if (test.expect) {
@@ -106,9 +100,6 @@ function run_compress_tests() {
                 quote_style: 3,
                 keep_quoted_props: true
             });
-            if (test.mangle_props) {
-                input = U.mangle_properties(input, test.mangle_props);
-            }
             var options = U.defaults(test.options, {
                 warnings: false
             });
@@ -123,10 +114,16 @@ function run_compress_tests() {
             var cmp = new U.Compressor(options, true);
             var output = cmp.compress(input);
             output.figure_out_scope(test.mangle);
-            if (test.mangle) {
+            if (test.mangle || test.mangle_props) {
+                U.base54.reset();
                 output.compute_char_frequency(test.mangle);
+            }
+            if (test.mangle) {
                 output.mangle_names(test.mangle);
             }
+            if (test.mangle_props) {
+                output = U.mangle_properties(output, test.mangle_props);
+            }
             output = make_code(output, output_options);
             if (expect != output) {
                 log("!!! failed\n---INPUT---\n{input}\n---OUTPUT---\n{output}\n---EXPECTED---\n{expected}\n\n", {
@@ -170,7 +167,8 @@ function run_compress_tests() {
                         failed_files[file] = 1;
                     }
                 }
-                if (test.expect_stdout) {
+                if (test.expect_stdout
+                    && (!test.node_version || semver.satisfies(process.version, test.node_version))) {
                     var stdout = sandbox.run_code(input_code);
                     if (test.expect_stdout === true) {
                         test.expect_stdout = stdout;
@@ -280,7 +278,14 @@ function parse_test(file) {
             if (node instanceof U.AST_LabeledStatement) {
                 var label = node.label;
                 assert.ok(
-                    ["input", "expect", "expect_exact", "expect_warnings", "expect_stdout"].indexOf(label.name) >= 0,
+                    [
+                        "input",
+                        "expect",
+                        "expect_exact",
+                        "expect_warnings",
+                        "expect_stdout",
+                        "node_version",
+                    ].indexOf(label.name) >= 0,
                     tmpl("Unsupported label {name} [{line},{col}]", {
                         name: label.name,
                         line: label.start.line,
@@ -288,11 +293,25 @@ function parse_test(file) {
                     })
                 );
                 var stat = node.body;
-                if (label.name == "expect_exact") {
+                if (label.name == "expect_exact" || label.name == "node_version") {
                     test[label.name] = read_string(stat);
                 } else if (label.name == "expect_stdout") {
-                    if (stat.TYPE == "SimpleStatement" && stat.body instanceof U.AST_Boolean) {
-                        test[label.name] = stat.body.value;
+                    var body = stat.body;
+                    if (body instanceof U.AST_Boolean) {
+                        test[label.name] = body.value;
+                    } else if (body instanceof U.AST_Call) {
+                        var ctor = global[body.expression.name];
+                        assert.ok(ctor === Error || ctor.prototype instanceof Error, tmpl("Unsupported expect_stdout format [{line},{col}]", {
+                            line: label.start.line,
+                            col: label.start.col
+                        }));
+                        test[label.name] = ctor.apply(null, body.args.map(function(node) {
+                            assert.ok(node instanceof U.AST_Constant, tmpl("Unsupported expect_stdout format [{line},{col}]", {
+                                line: label.start.line,
+                                col: label.start.col
+                            }));
+                            return node.value;
+                        }));
                     } else {
                         test[label.name] = read_string(stat) + "\n";
                     }

test/sandbox.js

@@ -1,14 +1,17 @@
+var semver = require("semver");
 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;
@@ -16,23 +19,25 @@ function safe_log(arg) {
 
 var FUNC_TOSTRING = [
     "Function.prototype.toString = Function.prototype.valueOf = function() {",
-    "    var id = 0;",
+    "    var id = 100000;",
     "    return function() {",
     '        if (this === Array) return "[Function: Array]";',
     '        if (this === Object) return "[Function: Object]";',
     "        var i = this.name;",
     '        if (typeof i != "number") {',
     "            i = ++id;",
+].concat(Object.getOwnPropertyDescriptor(Function.prototype, "name").configurable ? [
     '            Object.defineProperty(this, "name", {',
     "                get: function() {",
     "                    return i;",
     "                }",
     "            });",
+] : [], [
     "        }",
     '        return "[Function: " + i + "]";',
     "    }",
     "}();",
-].join("\n");
+]).join("\n");
 exports.run_code = function(code) {
     var stdout = "";
     var original_write = process.stdout.write;
@@ -47,8 +52,13 @@ exports.run_code = function(code) {
             "}();",
         ].join("\n"), {
             console: {
-                log: function() {
-                    return console.log.apply(console, [].map.call(arguments, safe_log));
+                log: function(msg) {
+                    if (arguments.length == 1 && typeof msg == "string") {
+                        return console.log("%s", msg);
+                    }
+                    return console.log.apply(console, [].map.call(arguments, function(arg) {
+                        return safe_log(arg, 3);
+                    }));
                 }
             }
         }, { timeout: 5000 });
@@ -59,7 +69,7 @@ exports.run_code = function(code) {
         process.stdout.write = original_write;
     }
 };
-exports.same_stdout = ~process.version.lastIndexOf("v0.12.", 0) ? function(expected, actual) {
+exports.same_stdout = semver.satisfies(process.version, "0.12") ? function(expected, actual) {
     if (typeof expected != typeof actual) return false;
     if (typeof expected != "string") {
         if (expected.name != actual.name) return false;

test/sourcemaps.js

@@ -1,4 +1,4 @@
-var UglifyJS = require("./node");
+var UglifyJS = require("..");
 var ok = require("assert");
 
 module.exports = function () {
@@ -26,11 +26,11 @@ module.exports = function () {
 }
 
 function source_map(js) {
-    var source_map = UglifyJS.SourceMap();
-    var stream = UglifyJS.OutputStream({ source_map: source_map });
-    var parsed = UglifyJS.parse(js);
-    parsed.print(stream);
-    return JSON.parse(source_map.toString());
+    return JSON.parse(UglifyJS.minify(js, {
+        compress: false,
+        mangle: false,
+        sourceMap: true
+    }).map);
 }
 
 // Run standalone

test/ufuzz.js

@@ -12,7 +12,7 @@
         stream._handle.setBlocking(true);
 });
 
-var UglifyJS = require("./node");
+var UglifyJS = require("..");
 var randomBytes = require("crypto").randomBytes;
 var sandbox = require("./sandbox");
 
@@ -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;
@@ -98,22 +102,23 @@ for (var i = 2; i < process.argv.length; ++i) {
       case '--help':
       case '-h':
       case '-?':
-        console.log('** UglifyJS fuzzer help **');
-        console.log('Valid options (optional):');
-        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('--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');
-        console.log('--without-stmt <statement names>: a comma delimited black list of statements never to generate');
-        console.log('List of accepted statement names: ' + Object.keys(STMT_ARG_TO_ID));
-        console.log('** UglifyJS fuzzer exiting **');
+        println('** UglifyJS fuzzer help **');
+        println('Valid options (optional):');
+        println('<number>: generate this many cases (if used must be first arg)');
+        println('-v: print every generated test case');
+        println('-V: print every 100th generated test case');
+        println('-t <int>: generate this many toplevels per run (more take longer)');
+        println('-r <int>: maximum recursion depth for generator (higher takes longer)');
+        println('-s1 <statement name>: force the first level statement to be this one (see list below)');
+        println('-s2 <statement name>: force the second level statement to be this one (see list below)');
+        println('--no-catch-redef: do not redefine catch variables');
+        println('--no-directive: do not generate directives');
+        println('--use-strict: generate "use strict"');
+        println('--stmt-depth-from-func: reset statement depth counter at each function, counts from global otherwise');
+        println('--only-stmt <statement names>: a comma delimited white list of statements that may be generated');
+        println('--without-stmt <statement names>: a comma delimited black list of statements never to generate');
+        println('List of accepted statement names: ' + Object.keys(STMT_ARG_TO_ID));
+        println('** UglifyJS fuzzer exiting **');
         return 0;
       default:
         // first arg may be a number.
@@ -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,18 +923,35 @@ 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 '';
 }
 
-function try_beautify(code, result) {
+if (require.main !== module) {
+    exports.createTopLevelCode = createTopLevelCode;
+    exports.num_iterations = num_iterations;
+    return;
+}
+
+function println(msg) {
+    if (typeof msg != "undefined") process.stdout.write(msg);
+    process.stdout.write("\n");
+}
+
+function errorln(msg) {
+    if (typeof msg != "undefined") process.stderr.write(msg);
+    process.stderr.write("\n");
+}
+
+function try_beautify(code, result, printfn) {
     var beautified = UglifyJS.minify(code, {
         compress: false,
         mangle: false,
@@ -865,51 +961,34 @@ function try_beautify(code, result) {
         },
     });
     if (beautified.error) {
-        console.log("// !!! beautify failed !!!");
-        console.log(beautified.error.stack);
+        printfn("// !!! beautify failed !!!");
+        printfn(beautified.error.stack);
     } else if (sandbox.same_stdout(sandbox.run_code(beautified.code), result)) {
-        console.log("// (beautified)");
-        console.log(beautified.code);
+        printfn("// (beautified)");
+        printfn(beautified.code);
         return;
     }
-    console.log("//");
-    console.log(code);
+    printfn("//");
+    printfn(code);
 }
 
-function infer_options(ctor) {
-    try {
-        ctor({ 0: 0 });
-    } catch (e) {
-        return e.defs;
-    }
-}
-
-var default_options = {
-    compress: infer_options(UglifyJS.Compressor),
-    mangle: {
-        "cache": null,
-        "eval": false,
-        "ie8": false,
-        "keep_fnames": false,
-        "toplevel": false,
-    },
-    output: infer_options(UglifyJS.OutputStream),
-};
+var default_options = UglifyJS.default_options();
 
 function log_suspects(minify_options, component) {
     var options = component in minify_options ? minify_options[component] : true;
     if (!options) return;
-    options = UglifyJS.defaults(options, default_options[component]);
-    var suspects = Object.keys(default_options[component]).filter(function(name) {
-        if (options[name]) {
+    if (typeof options != "object") options = {};
+    var defs = default_options[component];
+    var suspects = Object.keys(defs).filter(function(name) {
+        if ((name in options ? options : defs)[name]) {
             var m = JSON.parse(JSON.stringify(minify_options));
             var o = JSON.parse(JSON.stringify(options));
             o[name] = false;
             m[component] = o;
             var result = UglifyJS.minify(original_code, m);
             if (result.error) {
-                console.log("Error testing options." + component + "." + name);
-                console.log(result.error);
+                errorln("Error testing options." + component + "." + name);
+                errorln(result.error.stack);
             } else {
                 var r = sandbox.run_code(result.code);
                 return sandbox.same_stdout(original_result, r);
@@ -917,49 +996,49 @@ function log_suspects(minify_options, component) {
         }
     });
     if (suspects.length > 0) {
-        console.log("Suspicious", component, "options:");
+        errorln("Suspicious " + component + " options:");
         suspects.forEach(function(name) {
-            console.log("  " + name);
+            errorln("  " + name);
         });
-        console.log();
+        errorln();
     }
 }
 
 function log(options) {
-    if (!ok) console.log('\n\n\n\n\n\n!!!!!!!!!!\n\n\n');
-    console.log("//=============================================================");
-    if (!ok) console.log("// !!!!!! Failed... round", round);
-    console.log("// original code");
-    try_beautify(original_code, original_result);
-    console.log();
-    console.log();
-    console.log("//-------------------------------------------------------------");
+    if (!ok) errorln('\n\n\n\n\n\n!!!!!!!!!!\n\n\n');
+    errorln("//=============================================================");
+    if (!ok) errorln("// !!!!!! Failed... round " + round);
+    errorln("// original code");
+    try_beautify(original_code, original_result, errorln);
+    errorln();
+    errorln();
+    errorln("//-------------------------------------------------------------");
     if (typeof uglify_code == "string") {
-        console.log("// uglified code");
-        try_beautify(uglify_code, uglify_result);
-        console.log();
-        console.log();
-        console.log("original result:");
-        console.log(original_result);
-        console.log("uglified result:");
-        console.log(uglify_result);
+        errorln("// uglified code");
+        try_beautify(uglify_code, uglify_result, errorln);
+        errorln();
+        errorln();
+        errorln("original result:");
+        errorln(typeof original_result == "string" ? original_result : original_result.stack);
+        errorln("uglified result:");
+        errorln(typeof uglify_result == "string" ? uglify_result : uglify_result.stack);
     } else {
-        console.log("// !!! uglify failed !!!");
-        console.log(uglify_code.stack);
+        errorln("// !!! uglify failed !!!");
+        errorln(uglify_code.stack);
         if (typeof original_result != "string") {
-            console.log();
-            console.log();
-            console.log("original stacktrace:");
-            console.log(original_result.stack);
+            errorln();
+            errorln();
+            errorln("original stacktrace:");
+            errorln(original_result.stack);
         }
     }
-    console.log("minify(options):");
+    errorln("minify(options):");
     options = JSON.parse(options);
-    console.log(options);
-    console.log();
+    errorln(JSON.stringify(options, null, 2));
+    errorln();
     if (!ok && typeof uglify_code == "string") {
         Object.keys(default_options).forEach(log_suspects.bind(null, options));
-        console.log("!!!!!! Failed... round", round);
+        errorln("!!!!!! Failed... round " + round);
     }
 }
 
@@ -973,10 +1052,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,20 +1067,20 @@ 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") {
-            console.log("//=============================================================");
-            console.log("// original code");
-            try_beautify(original_code, original_result);
-            console.log();
-            console.log();
-            console.log("original result:");
-            console.log(original_result);
-            console.log();
+        else if (typeof original_result != "string") {
+            println("//=============================================================");
+            println("// original code");
+            try_beautify(original_code, original_result, println);
+            println();
+            println();
+            println("original result:");
+            println(original_result.stack);
+            println();
         }
         if (!ok && isFinite(num_iterations)) {
-            console.log();
+            println();
             process.exit(1);
         }
     });
 }
-console.log();
+println();

tools/exports.js

@@ -1,4 +1,5 @@
 exports["Dictionary"] = Dictionary;
 exports["TreeWalker"] = TreeWalker;
+exports["TreeTransformer"] = TreeTransformer;
 exports["minify"] = minify;
 exports["_push_uniq"] = push_uniq;

tools/node.js

@@ -61,5 +61,22 @@ function describe_ast() {
         }
     };
     doitem(AST_Node);
-    return out + "";
+    return out + "\n";
 }
+
+function infer_options(options) {
+    var result = UglifyJS.minify("", options);
+    return result.error && result.error.defs;
+}
+
+UglifyJS.default_options = function() {
+    var defs = {};
+    Object.keys(infer_options({ 0: 0 })).forEach(function(component) {
+        var options = {};
+        options[component] = { 0: 0 };
+        if (options = infer_options(options)) {
+            defs[component] = options;
+        }
+    });
+    return defs;
+};