harmony-v3.1.8

fixes #2442

README.md

@@ -102,7 +102,7 @@ a double dash to prevent input files being used as option arguments:
                                 sequences.
     --config-file <file>        Read `minify()` options from JSON file.
     -d, --define <expr>[=value] Global definitions.
-    --ecma <version>            Specifiy ECMAScript release: 5, 6, 7 or 8.
+    --ecma <version>            Specify ECMAScript release: 5, 6, 7 or 8.
     --ie8                       Support non-standard Internet Explorer 8.
                                 Equivalent to setting `ie8: true` in `minify()`
                                 for `compress`, `mangle` and `output` options.
@@ -151,10 +151,10 @@ Additional options:
 - `--source-map "filename='<NAME>'"` to specify the name of the source map.
 
 - `--source-map "root='<URL>'"` to pass the URL where the original files can be found.
-  Otherwise UglifyJS assumes HTTP `X-SourceMap` is being used and will omit the
-  `//# sourceMappingURL=` directive.
 
 - `--source-map "url='<URL>'"` to specify the URL where the source map can be found.
+  Otherwise UglifyJS assumes HTTP `X-SourceMap` is being used and will omit the
+  `//# sourceMappingURL=` directive.
 
 For example:
 
@@ -201,11 +201,9 @@ Example:
 To enable the mangler you need to pass `--mangle` (`-m`).  The following
 (comma-separated) options are supported:
 
-- `toplevel` — mangle names declared in the top level scope (disabled by
-  default).
+- `toplevel` (default `false`) -- mangle names declared in the top level scope.
 
-- `eval` — mangle names visible in scopes where `eval` or `with` are used
-  (disabled by default).
+- `eval` (default `false`) -- mangle names visible in scopes where `eval` or `with` are used.
 
 When mangling is enabled but you want to prevent certain names from being
 mangled, you can declare those names with `--mangle reserved` — pass a
@@ -221,7 +219,7 @@ to prevent the `require`, `exports` and `$` names from being changed.
 is a separate step, different from variable name mangling.  Pass
 `--mangle-props` to enable it.  It will mangle all properties in the
 input code with the exception of built in DOM properties and properties
-in core javascript classes.  For example:
+in core JavaScript classes.  For example:
 
 ```javascript
 // example.js
@@ -236,7 +234,7 @@ x.bar_ = 2;
 x["baz_"] = 3;
 console.log(x.calc());
 ```
-Mangle all properties (except for javascript `builtins`):
+Mangle all properties (except for JavaScript `builtins`):
 ```bash
 $ uglifyjs example.js -c -m --mangle-props
 ```
@@ -511,6 +509,9 @@ if (result.error) throw result.error;
 
 - `ie8` (default `false`) - set to `true` to support IE8.
 
+- `keep_fnames` (default: `false`) - pass `true` to prevent discarding or mangling
+  of function names.  Useful for code relying on `Function.prototype.name`.
+
 ## Minify options structure
 
 ```javascript
@@ -592,125 +593,103 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
 ## Parse options
 
 - `bare_returns` (default `false`) -- support top level `return` statements
+
 - `ecma` (default: `8`) -- specify one of `5`, `6`, `7` or `8`. Note: this setting
   is not presently enforced except for ES8 optional trailing commas in function
   parameter lists and calls with `ecma` `8`.
+
 - `html5_comments` (default `true`)
+
 - `shebang` (default `true`) -- support `#!command` as the first line
 
 ## Compress options
 
-- `sequences` (default: true) -- join consecutive simple statements using the
-  comma operator.  May be set to a positive integer to specify the maximum number
-  of consecutive comma sequences that will be generated. If this option is set to
-  `true` then the default `sequences` limit is `200`. Set option to `false` or `0`
-  to disable. The smallest `sequences` length is `2`. A `sequences` value of `1`
-  is grandfathered to be equivalent to `true` and as such means `200`. On rare
-  occasions the default sequences limit leads to very slow compress times in which
-  case a value of `20` or less is recommended.
-
-- `properties` -- rewrite property access using the dot notation, for
-  example `foo["bar"] → foo.bar`
-
-- `dead_code` -- remove unreachable code
-
-- `drop_debugger` -- remove `debugger;` statements
-
-- `unsafe` (default: false) -- apply "unsafe" transformations (discussion below)
-
-- `unsafe_comps` (default: false) -- Reverse `<` and `<=` to `>` and `>=` to
-  allow improved compression. This might be unsafe when an at least one of two
-  operands is an object with computed values due the use of methods like `get`,
-  or `valueOf`. This could cause change in execution order after operands in the
-  comparison are switching. Compression only works if both `comparisons` and
-  `unsafe_comps` are both set to true.
-
-- `unsafe_Func` (default: false) -- compress and mangle `Function(args, code)`
-  when both `args` and `code` are string literals.
-
-- `unsafe_math` (default: false) -- optimize numerical expressions like
-  `2 * x * 3` into `6 * x`, which may give imprecise floating point results.
-
-- `unsafe_proto` (default: false) -- optimize expressions like
-  `Array.prototype.slice.call(a)` into `[].slice.call(a)`
-
-- `unsafe_regexp` (default: false) -- enable substitutions of variables with
-  `RegExp` values the same way as if they are constants.
-
-- `conditionals` -- apply optimizations for `if`-s and conditional
-  expressions
-
-- `comparisons` -- apply certain optimizations to binary nodes, for example:
-  `!(a <= b) → a > b` (only when `unsafe_comps`), attempts to negate binary
-  nodes, e.g. `a = !b && !c && !d && !e → a=!(b||c||d||e)` etc.
-
-- `evaluate` -- attempt to evaluate constant expressions
-
-- `arrows` (default `true`) -- Converts `()=>{return x}` to `()=>x`. Class
+- `arrows` (default: `true`) -- Converts `()=>{return x}` to `()=>x`. Class
   and object literal methods will also be converted to arrow expressions if
   the resultant code is shorter: `m(){return x}` becomes `m:()=>x`.
   This transform requires that the `ecma` compress option is set to `6` or greater.
 
-- `unsafe_arrows` (default `false`) -- Convert ES5 style anonymous function
-  expressions to arrow functions if the function body does not reference `this`.
-  Note: it is not always safe to perform this conversion if code relies on the
-  the function having a `prototype`, which arrow functions lack.
-  This transform requires that the `ecma` compress option is set to `6` or greater.
-
-- `booleans` -- various optimizations for boolean context, for example `!!a
+- `booleans` (default: `true`) -- various optimizations for boolean context, for example `!!a
   ? b : c → a ? b : c`
 
-- `typeofs` -- default `true`.  Transforms `typeof foo == "undefined"` into
-  `foo === void 0`.  Note: recommend to set this value to `false` for IE10 and
-  earlier versions due to known issues.
-
-- `loops` -- optimizations for `do`, `while` and `for` loops when we can
-  statically determine the condition
-
-- `unused` -- drop unreferenced functions and variables (simple direct variable
-  assignments do not count as references unless set to `"keep_assign"`)
-
-- `toplevel` -- drop unreferenced functions (`"funcs"`) and/or variables (`"vars"`)
-  in the top level scope (`false` by default, `true` to drop both unreferenced
-  functions and variables)
-
-- `top_retain` -- prevent specific toplevel functions and variables from `unused`
-  removal (can be array, comma-separated, RegExp or function. Implies `toplevel`)
-
-- `hoist_funs` -- hoist function declarations
-
-- `hoist_vars` (default: false) -- hoist `var` declarations (this is `false`
-  by default because it seems to increase the size of the output in general)
-
-- `if_return` -- optimizations for if/return and if/continue
-
-- `inline` -- embed simple functions
-
-- `join_vars` -- join consecutive `var` statements
-
-- `cascade` -- small optimization for sequences, transform `x, x` into `x`
+- `cascade` (default: `true`) -- small optimization for sequences, transform `x, x` into `x`
   and `x = something(), x` into `x = something()`
 
-- `collapse_vars` -- Collapse single-use non-constant variables - side
+- `collapse_vars` (default: `true`) -- Collapse single-use non-constant variables - side
   effects permitting.
 
-- `reduce_vars` -- Improve optimization on variables assigned with and
-  used as constant values.
+- `comparisons` (default: `true`) -- apply certain optimizations to binary nodes, for example:
+  `!(a <= b) → a > b` (only when `unsafe_comps`), attempts to negate binary
+  nodes, e.g. `a = !b && !c && !d && !e → a=!(b||c||d||e)` etc.
 
-- `warnings` -- display warnings when dropping unreachable code or unused
-  declarations etc.
+- `computed_props` (default: `true`) -- Transforms constant computed properties
+  into regular ones: `{["computed"]: 1}` is converted to `{computed: 1}`.
 
-- `negate_iife` -- negate "Immediately-Called Function Expressions"
+- `conditionals` (default: `true`) -- apply optimizations for `if`-s and conditional
+  expressions
+
+- `dead_code` (default: `true`) -- remove unreachable code
+
+- `drop_console` (default: `false`) -- default `false`.  Pass `true` to discard calls to
+  `console.*` functions. If you wish to drop a specific function call
+  such as `console.info` and/or retain side effects from function arguments
+  after dropping the function call then use `pure_funcs` instead.
+
+- `drop_debugger` (default: `true`) -- remove `debugger;` statements
+
+- `ecma` (default: `5`) -- Pass `6` or greater to enable `compress` options that
+  will transform ES5 code into smaller ES6+ equivalent forms.
+
+- `evaluate` (default: `true`) -- attempt to evaluate constant expressions
+
+- `expression` (default: `false`) -- default `false`.  Pass `true` to preserve completion values
+  from terminal statements without `return`, e.g. in bookmarklets.
+
+- `global_defs` (default: `{}`) -- see [conditional compilation](#conditional-compilation)
+
+- `hoist_funs` (default: `true`) -- hoist function declarations
+
+- `hoist_props` (default: `false`) -- hoist properties from constant object and
+  array literals into regular variables subject to a set of constraints. For example:
+  `var o={p:1, q:2}; f(o.p, o.q);` is converted to `f(1, 2);`. Note: `hoist_props`
+  works best with `mangle` enabled, the `compress` option `passes` set to `2` or higher,
+  and the `compress` option `toplevel` enabled.
+
+- `hoist_vars` (default: `false`) -- hoist `var` declarations (this is `false`
+  by default because it seems to increase the size of the output in general)
+
+- `if_return` (default: `true`) -- optimizations for if/return and if/continue
+
+- `inline` (default: `true`) -- embed simple functions
+
+- `join_vars` (default: `true`) -- join consecutive `var` statements
+
+- `keep_fargs` (default: `true`) -- default `true`.  Prevents the
+  compressor from discarding unused function arguments.  You need this
+  for code which relies on `Function.length`.
+
+- `keep_fnames` (default: `false`) -- Pass `true` to prevent the
+  compressor from discarding function names.  Useful for code relying on
+  `Function.prototype.name`. See also: the `keep_fnames` [mangle option](#mangle).
+
+- `keep_infinity` (default: `false`) -- default `false`. Pass `true` to prevent `Infinity` from
+  being compressed into `1/0`, which may cause performance issues on Chrome.
+
+- `loops` (default: `true`) -- optimizations for `do`, `while` and `for` loops when we can
+  statically determine the condition
+
+- `negate_iife` (default: `true`) -- negate "Immediately-Called Function Expressions"
   where the return value is discarded, to avoid the parens that the
   code generator would insert.
 
-- `pure_getters` -- the default is `false`.  If you pass `true` for
-  this, UglifyJS will assume that object property access
-  (e.g. `foo.bar` or `foo["bar"]`) doesn't have any side effects.
-  Specify `"strict"` to treat `foo.bar` as side-effect-free only when
-  `foo` is certain to not throw, i.e. not `null` or `undefined`.
+- `passes` (default: `1`) -- The maximum number of times to run compress.
+  In some cases more than one pass leads to further compressed code.  Keep in
+  mind more passes will take more time.
 
-- `pure_funcs` -- default `null`.  You can pass an array of names and
+- `properties` (default: `true`) -- rewrite property access using the dot notation, for
+  example `foo["bar"] → foo.bar`
+
+- `pure_funcs` (default: `null`) -- You can pass an array of names and
   UglifyJS will assume that those functions do not produce side
   effects.  DANGER: will not check if the name is redefined in scope.
   An example case here, for instance `var q = Math.floor(a/b)`.  If
@@ -721,44 +700,86 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
   statement would get discarded.  The current implementation adds some
   overhead (compression will be slower).
 
-- `drop_console` -- default `false`.  Pass `true` to discard calls to
-  `console.*` functions. If you wish to drop a specific function call
-  such as `console.info` and/or retain side effects from function arguments
-  after dropping the function call then use `pure_funcs` instead.
+- `pure_getters` (default: `"strict"`) -- If you pass `true` for
+  this, UglifyJS will assume that object property access
+  (e.g. `foo.bar` or `foo["bar"]`) doesn't have any side effects.
+  Specify `"strict"` to treat `foo.bar` as side-effect-free only when
+  `foo` is certain to not throw, i.e. not `null` or `undefined`.
 
-- `expression` -- default `false`.  Pass `true` to preserve completion values
-  from terminal statements without `return`, e.g. in bookmarklets.
+- `reduce_vars` (default: `true`) -- Improve optimization on variables assigned with and
+  used as constant values.
 
-- `keep_fargs` -- default `true`.  Prevents the
-  compressor from discarding unused function arguments.  You need this
-  for code which relies on `Function.length`.
+- `sequences` (default: `true`) -- join consecutive simple statements using the
+  comma operator.  May be set to a positive integer to specify the maximum number
+  of consecutive comma sequences that will be generated. If this option is set to
+  `true` then the default `sequences` limit is `200`. Set option to `false` or `0`
+  to disable. The smallest `sequences` length is `2`. A `sequences` value of `1`
+  is grandfathered to be equivalent to `true` and as such means `200`. On rare
+  occasions the default sequences limit leads to very slow compress times in which
+  case a value of `20` or less is recommended.
 
-- `keep_fnames` -- default `false`.  Pass `true` to prevent the
-  compressor from discarding function names.  Useful for code relying on
-  `Function.prototype.name`. See also: the `keep_fnames` [mangle option](#mangle).
-
-- `passes` -- default `1`. The maximum number of times to run compress.
-  In some cases more than one pass leads to further compressed code.  Keep in
-  mind more passes will take more time.
-
-- `keep_infinity` -- default `false`. Pass `true` to prevent `Infinity` from
-  being compressed into `1/0`, which may cause performance issues on Chrome.
-
-- `side_effects` -- default `true`. Pass `false` to disable potentially dropping
+- `side_effects` (default: `true`) -- default `true`. Pass `false` to disable potentially dropping
   functions marked as "pure".  A function call is marked as "pure" if a comment
   annotation `/*@__PURE__*/` or `/*#__PURE__*/` immediately precedes the call. For
   example: `/*@__PURE__*/foo();`
 
-- `ecma` -- default `5`. Pass `6` or greater to enable `compress` options that
-  will transform ES5 code into smaller ES6+ equivalent forms.
+- `switches` (default: `true`) -- de-duplicate and remove unreachable `switch` branches
+
+- `toplevel` (default: `false`) -- drop unreferenced functions (`"funcs"`) and/or variables (`"vars"`)
+  in the top level scope (`false` by default, `true` to drop both unreferenced
+  functions and variables)
+
+- `top_retain` (default: `null`) -- prevent specific toplevel functions and variables from `unused`
+  removal (can be array, comma-separated, RegExp or function. Implies `toplevel`)
+
+- `typeofs` (default: `true`) -- default `true`.  Transforms `typeof foo == "undefined"` into
+  `foo === void 0`.  Note: recommend to set this value to `false` for IE10 and
+  earlier versions due to known issues.
+
+- `unsafe` (default: `false`) -- apply "unsafe" transformations (discussion below)
+
+- `unsafe_arrows` (default: `false`) -- Convert ES5 style anonymous function
+  expressions to arrow functions if the function body does not reference `this`.
+  Note: it is not always safe to perform this conversion if code relies on the
+  the function having a `prototype`, which arrow functions lack.
+  This transform requires that the `ecma` compress option is set to `6` or greater.
+
+- `unsafe_comps` (default: `false`) -- Reverse `<` and `<=` to `>` and `>=` to
+  allow improved compression. This might be unsafe when an at least one of two
+  operands is an object with computed values due the use of methods like `get`,
+  or `valueOf`. This could cause change in execution order after operands in the
+  comparison are switching. Compression only works if both `comparisons` and
+  `unsafe_comps` are both set to true.
+
+- `unsafe_Func` (default: `false`) -- compress and mangle `Function(args, code)`
+  when both `args` and `code` are string literals.
+
+- `unsafe_math` (default: `false`) -- optimize numerical expressions like
+  `2 * x * 3` into `6 * x`, which may give imprecise floating point results.
+
+- `unsafe_methods` (default: false) -- Converts `{ m: function(){} }` to
+  `{ m(){} }`. `ecma` must be set to `6` or greater to enable this transform.
+  If `unsafe_methods` is a RegExp then key/value pairs with keys matching the
+  RegExp will be converted to concise methods.
+  Note: if enabled there is a risk of getting a "`<method name>` is not a
+  constructor" TypeError should any code try to `new` the former function.
+
+- `unsafe_proto` (default: `false`) -- optimize expressions like
+  `Array.prototype.slice.call(a)` into `[].slice.call(a)`
+
+- `unsafe_regexp` (default: `false`) -- enable substitutions of variables with
+  `RegExp` values the same way as if they are constants.
+
+- `unused` (default: `true`) -- drop unreferenced functions and variables (simple direct variable
+  assignments do not count as references unless set to `"keep_assign"`)
+
+- `warnings` (default: `false`) -- display warnings when dropping unreachable code or unused
+  declarations etc.
 
 ## Mangle options
 
-- `reserved` (default `[]`). Pass an array of identifiers that should be
-  excluded from mangling. Example: `["foo", "bar"]`.
-
-- `toplevel` (default `false`). Pass `true` to mangle names declared in the
-  top level scope.
+- `eval` (default `false`). Pass `true` to mangle names visible in scopes
+  where `eval` or `with` are used.
 
 - `keep_classnames` (default `false`).  Pass `true` to not mangle class names.
 
@@ -766,8 +787,11 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
   Useful for code relying on `Function.prototype.name`. See also: the `keep_fnames`
   [compress option](#compress-options).
 
-- `eval` (default `false`). Pass `true` to mangle names visible in scopes
-  where `eval` or `with` are used.
+- `reserved` (default `[]`). Pass an array of identifiers that should be
+  excluded from mangling. Example: `["foo", "bar"]`.
+
+- `toplevel` (default `false`). Pass `true` to mangle names declared in the
+  top level scope.
 
 - `safari10` (default `false`). Pass `true` to work around the Safari 10 loop
   iterator [bug](https://bugs.webkit.org/show_bug.cgi?id=171041)
@@ -797,16 +821,20 @@ UglifyJS.minify(code, { mangle: { toplevel: true } }).code;
 
 ### Mangle properties options
 
-- `reserved` (default: `[]`) -- Do not mangle property names listed in the
-  `reserved` array.
-- `regex` (default: `null`) -— Pass a RegExp literal to only mangle property
-  names matching the regular expression.
-- `keep_quoted` (default: `false`) -— Only mangle unquoted property names.
-- `debug` (default: `false`) -— Mangle names with the original name still present.
-  Pass an empty string `""` to enable, or a non-empty string to set the debug suffix.
 - `builtins` (default: `false`) -- Use `true` to allow the mangling of builtin
   DOM properties. Not recommended to override this setting.
 
+- `debug` (default: `false`) -— Mangle names with the original name still present.
+  Pass an empty string `""` to enable, or a non-empty string to set the debug suffix.
+
+- `keep_quoted` (default: `false`) -— Only mangle unquoted property names.
+
+- `regex` (default: `null`) -— Pass a RegExp literal to only mangle property
+  names matching the regular expression.
+
+- `reserved` (default: `[]`) -- Do not mangle property names listed in the
+  `reserved` array.
+
 ## Output options
 
 The code generator tries to output shortest code possible by default.  In
@@ -815,37 +843,50 @@ can pass additional arguments that control the code output:
 
 - `ascii_only` (default `false`) -- escape Unicode characters in strings and
   regexps (affects directives with non-ascii characters becoming invalid)
+
 - `beautify` (default `true`) -- whether to actually beautify the output.
   Passing `-b` will set this to true, but you might need to pass `-b` even
   when you want to generate minified code, in order to specify additional
   arguments, so you can use `-b beautify=false` to override it.
+
 - `bracketize` (default `false`) -- always insert brackets in `if`, `for`,
   `do`, `while` or `with` statements, even if their body is a single
   statement.
+
 - `comments` (default `false`) -- pass `true` or `"all"` to preserve all
   comments, `"some"` to preserve some comments, a regular expression string
   (e.g. `/^!/`) or a function.
+
 - `ecma` (default `5`) -- set output printing mode. Set `ecma` to `6` or
   greater to emit shorthand object properties - i.e.: `{a}` instead of `{a: a}`.
   The `ecma` option will only change the output in direct control of the
   beautifier. Non-compatible features in the abstract syntax tree will still
   be output as is. For example: an `ecma` setting of `5` will **not** convert
   ES6+ code to ES5.
-- `indent_level` (default 4)
-- `indent_start` (default 0) -- prefix all lines by that many spaces
+
+- `indent_level` (default `4`)
+
+- `indent_start` (default `0`) -- prefix all lines by that many spaces
+
 - `inline_script` (default `false`) -- escape the slash in occurrences of
   `</script` in strings
+
 - `keep_quoted_props` (default `false`) -- when turned on, prevents stripping
   quotes from property names in object literals.
+
 - `max_line_len` (default `false`) -- maximum line length (for uglified code)
+
 - `preamble` (default `null`) -- when passed it must be a string and
   it will be prepended to the output literally.  The source map will
   adjust for this text.  Can be used to insert a comment containing
   licensing information, for example.
+
 - `preserve_line` (default `false`) -- pass `true` to preserve lines, but it
   only works if `beautify` is set to `false`.
+
 - `quote_keys` (default `false`) -- pass `true` to quote all keys in literal
   objects
+
 - `quote_style` (default `0`) -- preferred quote style for strings (affects
   quoted property names and directives as well):
   - `0` -- prefers double quotes, switches to single quotes when there are
@@ -853,16 +894,20 @@ can pass additional arguments that control the code output:
   - `1` -- always use single quotes
   - `2` -- always use double quotes
   - `3` -- always use the original quotes
+
 - `semicolons` (default `true`) -- separate statements with semicolons.  If
   you pass `false` then whenever possible we will use a newline instead of a
   semicolon, leading to more readable output of uglified code (size before
   gzip could be smaller; size after gzip insignificantly larger).
+
 - `shebang` (default `true`) -- preserve shebang `#!` in preamble (bash scripts)
-- `width` (default 80) -- only takes effect when beautification is on, this
+
+- `width` (default `80`) -- only takes effect when beautification is on, this
   specifies an (orientative) line width that the beautifier will try to
   obey.  It refers to the width of the line text (excluding indentation).
   It doesn't work very well currently, but it does make the code generated
   by UglifyJS more readable.
+
 - `wrap_iife` (default `false`) -- pass `true` to wrap immediately invoked
   function expressions. See
   [#640](https://github.com/mishoo/UglifyJS2/issues/640) for more details.
@@ -1064,7 +1109,7 @@ in total it's a bit more than just using UglifyJS's own parser.
 ### Uglify Fast Minify Mode
 
 It's not well known, but whitespace removal and symbol mangling accounts
-for 95% of the size reduction in minified code for most javascript - not
+for 95% of the size reduction in minified code for most JavaScript - not
 elaborate code transforms. One can simply disable `compress` to speed up
 Uglify builds by 3 to 4 times. In this fast `mangle`-only mode Uglify has
 comparable minify speeds and gzip sizes to

bin/uglifyjs

@@ -44,7 +44,7 @@ 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("--ecma <version>", "Specify 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.");

lib/ast.js

@@ -134,11 +134,10 @@ var AST_Debugger = DEFNODE("Debugger", null, {
     $documentation: "Represents a debugger statement",
 }, AST_Statement);
 
-var AST_Directive = DEFNODE("Directive", "value scope quote", {
+var AST_Directive = DEFNODE("Directive", "value quote", {
     $documentation: "Represents a directive, like \"use strict\";",
     $propdoc: {
         value: "[string] The value of this directive as a plain string (it's not an AST_String!)",
-        scope: "[AST_Scope/S] The scope that this directive affects",
         quote: "[string] the original quote character"
     },
 }, AST_Statement);
@@ -303,10 +302,9 @@ var AST_With = DEFNODE("With", "expression", {
 
 /* -----[ scope and functions ]----- */
 
-var AST_Scope = DEFNODE("Scope", "directives variables functions uses_with uses_eval parent_scope enclosed cname", {
+var AST_Scope = DEFNODE("Scope", "variables functions uses_with uses_eval parent_scope enclosed cname", {
     $documentation: "Base class for all statements introducing a lexical scope",
     $propdoc: {
-        directives: "[string*/S] an array of directives declared in this scope",
         variables: "[Object/S] a map of name -> SymbolDef for all variables/functions defined in this scope",
         functions: "[Object/S] like `variables`, but only lists function declarations",
         uses_with: "[boolean/S] tells whether this scope uses the `with` statement",
@@ -450,10 +448,8 @@ var AST_TemplateString = DEFNODE("TemplateString", "segments", {
     },
     _walk: function(visitor) {
         return visitor._visit(this, function(){
-            this.segments.forEach(function(seg, i){
-                if (i % 2 !== 0) {
-                    seg._walk(visitor);
-                }
+            this.segments.forEach(function(seg){
+                seg._walk(visitor);
             });
         });
     }
@@ -1044,7 +1040,7 @@ var AST_This = DEFNODE("This", null, {
 
 var AST_Super = DEFNODE("Super", null, {
     $documentation: "The `super` symbol",
-}, AST_Symbol);
+}, AST_This);
 
 var AST_Constant = DEFNODE("Constant", null, {
     $documentation: "Base class for all constants",

lib/minify.js

@@ -141,11 +141,9 @@ function minify(files, options) {
         if (options.wrap) {
             toplevel = toplevel.wrap_commonjs(options.wrap);
         }
-        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 (timings) timings.scope = Date.now();
         if (options.mangle) toplevel.figure_out_scope(options.mangle);
         if (timings) timings.mangle = Date.now();
         if (options.mangle) {
@@ -203,9 +201,9 @@ 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),
+                parse: 1e-3 * (timings.compress - timings.parse),
+                compress: 1e-3 * (timings.scope - timings.compress),
+                scope: 1e-3 * (timings.mangle - timings.scope),
                 mangle: 1e-3 * (timings.properties - timings.mangle),
                 properties: 1e-3 * (timings.output - timings.properties),
                 output: 1e-3 * (timings.end - timings.output),

lib/output.js

@@ -262,7 +262,7 @@ function OutputStream(options) {
         }
     } : noop;
 
-    var requireSemicolonChars = makePredicate("( [ + * / - , .");
+    var requireSemicolonChars = makePredicate("( [ + * / - , . `");
 
     function print(str) {
         str = String(str);
@@ -506,13 +506,17 @@ function OutputStream(options) {
         nodetype.DEFMETHOD("_codegen", generator);
     };
 
-    var use_asm = false;
     var in_directive = false;
+    var active_scope = null;
+    var use_asm = null;
 
     AST_Node.DEFMETHOD("print", function(stream, force_parens){
-        var self = this, generator = self._codegen, prev_use_asm = use_asm;
-        if (self instanceof AST_Directive && self.value == "use asm" && stream.parent() instanceof AST_Scope) {
-            use_asm = true;
+        var self = this, generator = self._codegen;
+        if (self instanceof AST_Scope) {
+            active_scope = self;
+        }
+        else if (!use_asm && self instanceof AST_Directive && self.value == "use asm") {
+            use_asm = active_scope;
         }
         function doit() {
             self.add_comments(stream);
@@ -526,8 +530,8 @@ function OutputStream(options) {
             doit();
         }
         stream.pop_node();
-        if (self instanceof AST_Scope) {
-            use_asm = prev_use_asm;
+        if (self === use_asm) {
+            use_asm = null;
         }
     });
     AST_Node.DEFMETHOD("_print", AST_Node.prototype.print);
@@ -1681,9 +1685,6 @@ function OutputStream(options) {
     DEFPRINT(AST_Symbol, function (self, output) {
         self._do_print(output);
     });
-    DEFPRINT(AST_SymbolDeclaration, function(self, output){
-        self._do_print(output);
-    });
     DEFPRINT(AST_Hole, noop);
     DEFPRINT(AST_This, function(self, output){
         output.print("this");

lib/parse.js

@@ -44,9 +44,9 @@
 
 "use strict";
 
-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 = 'break case catch class const continue debugger default delete do else export extends finally for function if in instanceof let new return switch throw try typeof var void while with';
 var KEYWORDS_ATOM = 'false null true';
-var RESERVED_WORDS = 'enum implements interface package private protected public static super this ' + KEYWORDS_ATOM + " " + KEYWORDS;
+var RESERVED_WORDS = 'enum implements import interface package private protected public static super this ' + KEYWORDS_ATOM + " " + KEYWORDS;
 var KEYWORDS_BEFORE_EXPRESSION = 'return new delete throw else case yield await';
 
 KEYWORDS = makePredicate(KEYWORDS);
@@ -1013,6 +1013,12 @@ function parse($TEXT, options) {
                 next();
                 return function_(AST_Defun, false, true);
             }
+            if (S.token.value == "import" && !is_token(peek(), "punc", "(")) {
+                next();
+                var node = import_();
+                semicolon();
+                return node;
+            }
             return is_token(peek(), "punc", ":")
                 ? labeled_statement()
                 : simple_statement();
@@ -1149,15 +1155,11 @@ function parse($TEXT, options) {
                     body       : statement()
                 });
 
-              case "import":
-                next();
-                var node = import_();
-                semicolon();
-                return node;
-
               case "export":
-                next();
-                return export_();
+                if (!is_token(peek(), "punc", "(")) {
+                    next();
+                    return export_();
+                }
             }
         }
         unexpected();
@@ -1320,6 +1322,9 @@ function parse($TEXT, options) {
         if (in_statement && !name)
             unexpected();
 
+        if (name && ctor !== AST_Accessor && !(name instanceof AST_SymbolDeclaration))
+            unexpected(prev());
+
         var args = parameters();
         var body = _function_body(true, is_generator || is_generator_property, is_async, name, args);
         return new ctor({
@@ -1875,7 +1880,8 @@ function parse($TEXT, options) {
                         : !no_in && kind === "const" && S.input.has_directive("use strict")
                             ? croak("Missing initializer in const declaration") : null,
                     end   : prev()
-                })
+                });
+                if (def.name.name == "import") croak("Unexpected token: import");
             }
             a.push(def);
             if (!is("punc", ","))
@@ -1994,9 +2000,6 @@ function parse($TEXT, options) {
                 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) {
@@ -2562,7 +2565,7 @@ function parse($TEXT, options) {
                 unexpected(tmp);
             }
           case "name":
-            if (tmp.value == "yield" && !is_token(peek(), "punc", ":")
+            if (tmp.value == "yield" && !is_token(peek(), "punc", ":") && !is_token(peek(), "punc", "(")
                 && S.input.has_directive("use strict") && !is_in_generator()) {
                 token_error(tmp, "Unexpected yield identifier inside strict mode");
             }

lib/scope.js

@@ -546,7 +546,7 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
         var mangle_with_block_scope =
             (!options.ie8 && node instanceof AST_SymbolCatch) ||
             node instanceof AST_SymbolBlockDeclaration;
-        if (mangle_with_block_scope) {
+        if (mangle_with_block_scope && options.reserved.indexOf(node.name) < 0) {
             to_mangle.push(node.definition());
             return;
         }

lib/transform.js

@@ -262,11 +262,7 @@ TreeTransformer.prototype = new TreeWalker;
     });
 
     _(AST_TemplateString, function(self, tw) {
-        for (var i = 0; i < self.segments.length; i++) {
-            if (!(self.segments[i] instanceof AST_TemplateSegment)) {
-                self.segments[i] = self.segments[i].transform(tw);
-            }
-        }
+        self.segments = do_list(self.segments, tw);
     });
 
     _(AST_PrefixedTemplateString, function(self, tw) {

package.json

@@ -4,7 +4,7 @@
   "homepage": "https://github.com/mishoo/UglifyJS2/tree/harmony",
   "author": "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)",
   "license": "BSD-2-Clause",
-  "version": "3.1.1",
+  "version": "3.1.8",
   "engines": {
     "node": ">=0.8.0"
   },
@@ -27,7 +27,7 @@
   ],
   "dependencies": {
     "commander": "~2.11.0",
-    "source-map": "~0.5.1"
+    "source-map": "~0.6.1"
   },
   "devDependencies": {
     "acorn": "~5.1.1",

test/compress/arrays.js

@@ -203,50 +203,110 @@ constant_join_3: {
 
 for_loop: {
     options = {
-        unsafe      : true,
-        unused      : true,
-        evaluate    : true,
-        reduce_vars : true
+        evaluate: true,
+        reduce_vars: true,
+        unsafe: true,
+        unused: true,
     };
     input: {
         function f0() {
             var a = [1, 2, 3];
-            for (var i = 0; i < a.length; i++) {
-                console.log(a[i]);
-            }
+            var b = 0;
+            for (var i = 0; i < a.length; i++)
+                b += a[i];
+            return b;
         }
-
         function f1() {
             var a = [1, 2, 3];
-            for (var i = 0, len = a.length; i < len; i++) {
-                console.log(a[i]);
-            }
+            var b = 0;
+            for (var i = 0, len = a.length; i < len; i++)
+                b += a[i];
+            return b;
         }
-
-        function f2() {
-            var a = [1, 2, 3];
-            for (var i = 0; i < a.length; i++) {
-                a[i]++;
-            }
-        }
-    }
-    expect: {
-        function f0() {
-            var a = [1, 2, 3];
-            for (var i = 0; i < 3; i++)
-                console.log(a[i]);
-        }
-
-        function f1() {
-            var a = [1, 2, 3];
-            for (var i = 0; i < 3; i++)
-                console.log(a[i]);
-        }
-
         function f2() {
             var a = [1, 2, 3];
             for (var i = 0; i < a.length; i++)
                 a[i]++;
+            return a[2];
         }
+        console.log(f0(), f1(), f2());
     }
+    expect: {
+        function f0() {
+            var a = [1, 2, 3];
+            var b = 0;
+            for (var i = 0; i < 3; i++)
+                b += a[i];
+            return b;
+        }
+        function f1() {
+            var a = [1, 2, 3];
+            var b = 0;
+            for (var i = 0; i < 3; i++)
+                b += a[i];
+            return b;
+        }
+        function f2() {
+            var a = [1, 2, 3];
+            for (var i = 0; i < a.length; i++)
+                a[i]++;
+            return a[2];
+        }
+        console.log(f0(), f1(), f2());
+    }
+    expect_stdout: "6 6 4"
+}
+
+index: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        var a = [ 1, 2 ];
+        console.log(a[0], a[1]);
+    }
+    expect: {
+        console.log(1, 2);
+    }
+    expect_stdout: "1 2"
+}
+
+length: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        var a = [ 1, 2 ];
+        console.log(a.length);
+    }
+    expect: {
+        console.log(2);
+    }
+    expect_stdout: "2"
+}
+
+index_length: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        var a = [ 1, 2 ];
+        console.log(a[0], a.length);
+    }
+    expect: {
+        console.log(1, 2);
+    }
+    expect_stdout: "1 2"
 }

test/compress/arrow.js

@@ -290,6 +290,7 @@ issue_2105_1: {
         passes: 3,
         reduce_vars: true,
         side_effects: true,
+        unsafe_methods: true,
         unused: true,
     }
     input: {
@@ -313,17 +314,12 @@ issue_2105_1: {
         });
     }
     expect: {
-        (() => {
-            var quux = () => {
+        ({
+            prop() {
+                console.log;
                 console.log("PASS");
-            };
-            return {
-                prop() {
-                    console.log;
-                    quux();
-                }
-            };
-        })().prop();
+            }
+        }).prop();
     }
     expect_stdout: "PASS"
     node_version: ">=4"
@@ -359,17 +355,12 @@ issue_2105_2: {
         });
     }
     expect: {
-        (() => {
-            var quux = () => {
+        ({
+            prop: () => {
+                console.log;
                 console.log("PASS");
-            };
-            return {
-                prop: () => {
-                    console.log;
-                    quux();
-                }
-            };
-        })().prop();
+            }
+        }).prop();
     }
     expect_stdout: "PASS"
     node_version: ">=6"
@@ -630,3 +621,31 @@ issue_2271: {
     }
     expect_stdout: "PASS"
 }
+
+concise_method_with_super: {
+    options = {
+        arrows: true,
+    }
+    input: {
+        var o = {
+            f: "FAIL",
+            g() {
+                return super.f;
+            }
+        }
+        Object.setPrototypeOf(o, { f: "PASS" });
+        console.log(o.g());
+    }
+    expect: {
+        var o = {
+            f: "FAIL",
+            g() {
+                return super.f;
+            }
+        }
+        Object.setPrototypeOf(o, { f: "PASS" });
+        console.log(o.g());
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}

test/compress/asm.js

@@ -104,3 +104,65 @@ asm_mixed: {
     }
 }
 
+asm_toplevel: {
+    options = {}
+    input: {
+        "use asm";
+        0.0;
+        function f() {
+            0.0;
+            (function(){
+                0.0;
+            });
+        }
+        0.0;
+    }
+    expect_exact: '"use asm";0.0;function f(){0.0;(function(){0.0})}0.0;'
+}
+
+asm_function_expression: {
+    options = {}
+    input: {
+        0.0;
+        var a = function() {
+            "use asm";
+            0.0;
+        }
+        function f() {
+            0.0;
+            return function(){
+                "use asm";
+                0.0;
+            }
+            0.0;
+        }
+        0.0;
+    }
+    expect_exact: '0;var a=function(){"use asm";0.0};function f(){0;return function(){"use asm";0.0};0}0;'
+}
+
+asm_nested_functions: {
+    options = {}
+    input: {
+        0.0;
+        function a() {
+            "use asm";
+            0.0;
+        }
+        0.0;
+        function b() {
+            0.0;
+            function c(){
+                "use asm";
+                0.0;
+            }
+            0.0;
+            function d(){
+                0.0;
+            }
+            0.0;
+        }
+        0.0;
+    }
+    expect_exact: '0;function a(){"use asm";0.0}0;function b(){0;function c(){"use asm";0.0}0;function d(){0}0}0;'
+}

test/compress/collapse_vars.js

@@ -1268,22 +1268,21 @@ collapse_vars_short_circuited_conditions: {
 
 collapse_vars_regexp: {
     options = {
-        collapse_vars: true,
-        loops:         false,
-        sequences:     true,
-        dead_code:     true,
-        conditionals:  true,
-        comparisons:   true,
-        evaluate:      true,
         booleans:      true,
-        unused:        true,
-        hoist_funs:    true,
-        keep_fargs:    true,
+        cascade:       true,
+        collapse_vars: true,
+        comparisons:   true,
+        conditionals:  true,
+        dead_code:     true,
+        evaluate:      true,
         if_return:     true,
         join_vars:     true,
-        cascade:       true,
-        side_effects:  true,
+        hoist_funs:    true,
+        keep_fargs:    true,
+        loops:         false,
         reduce_vars:   true,
+        side_effects:  true,
+        unused:        true,
     }
     input: {
         function f1() {
@@ -1292,12 +1291,12 @@ collapse_vars_regexp: {
             return [rx, k];
         }
         function f2() {
-            var rx = /[abc123]+/;
+            var rx = /ab*/g;
             return function(s) {
                 return rx.exec(s);
             };
         }
-        (function(){
+        (function() {
             var result;
             var s = 'acdabcdeabbb';
             var rx = /ab*/g;
@@ -1305,22 +1304,35 @@ collapse_vars_regexp: {
                 console.log(result[0]);
             }
         })();
+        (function() {
+            var result;
+            var s = 'acdabcdeabbb';
+            var rx = f2();
+            while (result = rx(s)) {
+                console.log(result[0]);
+            }
+        })();
     }
     expect: {
         function f1() {
             return [/[A-Z]+/, 9];
         }
         function f2() {
-            var rx = /[abc123]+/;
+            var rx = /ab*/g;
             return function(s) {
                 return rx.exec(s);
             };
         }
-        (function(){
+        (function() {
             var result, rx = /ab*/g;
             while (result = rx.exec("acdabcdeabbb"))
                 console.log(result[0]);
         })();
+        (function() {
+            var result, rx = f2();
+            while (result = rx("acdabcdeabbb"))
+                console.log(result[0]);
+        })();
     }
     expect_stdout: true
 }
@@ -1475,6 +1487,7 @@ issue_1605_1: {
     options = {
         collapse_vars: true,
         toplevel: false,
+        unused: true,
     }
     input: {
         function foo(x) {
@@ -1497,6 +1510,7 @@ issue_1605_2: {
     options = {
         collapse_vars: true,
         toplevel: "vars",
+        unused: true,
     }
     input: {
         function foo(x) {
@@ -1624,6 +1638,7 @@ issue_1631_3: {
 var_side_effects_1: {
     options = {
         collapse_vars: true,
+        unused: true,
     }
     input: {
         var print = console.log.bind(console);
@@ -1646,6 +1661,7 @@ var_side_effects_1: {
 var_side_effects_2: {
     options = {
         collapse_vars: true,
+        unused: true,
     }
     input: {
         var print = console.log.bind(console);
@@ -1671,6 +1687,7 @@ var_side_effects_3: {
         collapse_vars: true,
         pure_getters: true,
         unsafe: true,
+        unused: true,
     }
     input: {
         var print = console.log.bind(console);
@@ -1746,6 +1763,7 @@ iife_2: {
         }(foo);
     }
     expect: {
+        var foo;
         !function(x) {
             console.log(x);
         }(bar());
@@ -1933,9 +1951,9 @@ issue_1858: {
     }
     expect: {
         console.log(function(x) {
-            var a = {}, b = a.b = x;
+            var a = {}, b = a.b = 1;
             return a.b + b;
-        }(1));
+        }());
     }
     expect_stdout: "2"
 }
@@ -2032,6 +2050,7 @@ ref_scope: {
 chained_1: {
     options = {
         collapse_vars: true,
+        unused: true,
     }
     input: {
         var a = 2;
@@ -2048,6 +2067,7 @@ chained_1: {
 chained_2: {
     options = {
         collapse_vars: true,
+        unused: true,
     }
     input: {
         var a;
@@ -2138,7 +2158,7 @@ inner_lvalues: {
         console.log(null, a, b);
     }
     expect: {
-        var a, b = 10;
+        var b = 10;
         var a = (--b || a || 3).toString(), c = --b + -a;
         console.log(null, a, b);
     }
@@ -2148,6 +2168,7 @@ inner_lvalues: {
 double_def: {
     options = {
         collapse_vars: true,
+        unused: true,
     }
     input: {
         var a = x, a = a && y;
@@ -2162,6 +2183,7 @@ double_def: {
 toplevel_single_reference: {
     options = {
         collapse_vars: true,
+        unused: true,
     }
     input: {
         var a;
@@ -2171,9 +2193,10 @@ toplevel_single_reference: {
         }
     }
     expect: {
-        var a;
-        for (var b in x)
+        for (var b in x) {
+            var a;
             b(a = b);
+        }
     }
 }
 
@@ -2203,10 +2226,11 @@ unused_orig: {
     expect: {
         var a = 1;
         console.log(function(b) {
-            var a;
             var c = b;
-            for (var d in c)
+            for (var d in c) {
+                var a;
                 return --b + (a = c[0]);
+            }
             a && a.NaN;
         }([2]), a);
     }
@@ -2553,7 +2577,9 @@ issue_2250_1: {
     options = {
         collapse_vars: true,
         conditionals: true,
+        passes: 2,
         reduce_vars: true,
+        unused: true,
     }
     input: {
         function f(x) {
@@ -2595,6 +2621,7 @@ issue_2250_2: {
         reduce_vars: true,
         side_effects: true,
         toplevel: true,
+        unused: true,
     }
     input: {
         {
@@ -2725,3 +2752,606 @@ issue_2313_2: {
     }
     expect_stdout: "0"
 }
+
+issue_2319_1: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(a) {
+            return a;
+        }(!function() {
+            return this;
+        }()));
+    }
+    expect: {
+        console.log(function(a) {
+            return !function() {
+                return this;
+            }();
+        }());
+    }
+    expect_stdout: "false"
+}
+
+issue_2319_2: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(a) {
+            "use strict";
+            return a;
+        }(!function() {
+            return this;
+        }()));
+    }
+    expect: {
+        console.log(function(a) {
+            "use strict";
+            return a;
+        }(!function() {
+            return this;
+        }()));
+    }
+    expect_stdout: "false"
+}
+
+issue_2319_3: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        console.log(function(a) {
+            return a;
+        }(!function() {
+            return this;
+        }()));
+    }
+    expect: {
+        "use strict";
+        console.log(function(a) {
+            return !function() {
+                return this;
+            }();
+        }());
+    }
+    expect_stdout: "true"
+}
+
+issue_2365: {
+    options = {
+        collapse_vars: true,
+        pure_getters: true,
+    }
+    input: {
+        console.log(function(a) {
+            var b = a.f;
+            a.f++;
+            return b;
+        }({ f: 1 }));
+        console.log(function() {
+            var a = { f: 1 }, b = a.f;
+            a.f++;
+            return b;
+        }());
+        console.log({
+            f: 1,
+            g: function() {
+                var b = this.f;
+                this.f++;
+                return b;
+            }
+        }.g());
+    }
+    expect: {
+        console.log(function(a) {
+            var b = a.f;
+            a.f++;
+            return b;
+        }({ f: 1 }));
+        console.log(function() {
+            var a = { f: 1 }, b = a.f;
+            a.f++;
+            return b;
+        }());
+        console.log({
+            f: 1,
+            g: function() {
+                var b = this.f;
+                this.f++;
+                return b;
+            }
+        }.g());
+    }
+    expect_stdout: [
+        "1",
+        "1",
+        "1",
+    ]
+}
+
+issue_2364_1: {
+    options = {
+        collapse_vars: true,
+        pure_getters: true,
+    }
+    input: {
+        function inc(obj) {
+            return obj.count++;
+        }
+        function foo() {
+            var first = arguments[0];
+            var result = inc(first);
+            return foo.amount = first.count, result;
+        }
+        var data = {
+            count: 0,
+        };
+        var answer = foo(data);
+        console.log(foo.amount, answer);
+    }
+    expect: {
+        function inc(obj) {
+            return obj.count++;
+        }
+        function foo() {
+            var first = arguments[0];
+            var result = inc(first);
+            return foo.amount = first.count, result;
+        }
+        var data = {
+            count: 0
+        };
+        var answer = foo(data);
+        console.log(foo.amount, answer);
+    }
+    expect_stdout: "1 0"
+}
+
+issue_2364_2: {
+    options = {
+        collapse_vars: true,
+        pure_getters: true,
+    }
+    input: {
+        function callValidate() {
+            var validate = compilation.validate;
+            var result = validate.apply(null, arguments);
+            return callValidate.errors = validate.errors, result;
+        }
+    }
+    expect: {
+        function callValidate() {
+            var validate = compilation.validate;
+            var result = validate.apply(null, arguments);
+            return callValidate.errors = validate.errors, result;
+        }
+    }
+}
+
+issue_2364_3: {
+    options = {
+        collapse_vars: true,
+        pure_getters: true,
+    }
+    input: {
+        function inc(obj) {
+            return obj.count++;
+        }
+        function foo(bar) {
+            var result = inc(bar);
+            return foo.amount = bar.count, result;
+        }
+        var data = {
+            count: 0,
+        };
+        var answer = foo(data);
+        console.log(foo.amount, answer);
+    }
+    expect: {
+        function inc(obj) {
+            return obj.count++;
+        }
+        function foo(bar) {
+            var result = inc(bar);
+            return foo.amount = bar.count, result;
+        }
+        var data = {
+            count: 0,
+        };
+        var answer = foo(data);
+        console.log(foo.amount, answer);
+    }
+    expect_stdout: "1 0"
+}
+
+issue_2364_4: {
+    options = {
+        collapse_vars: true,
+        pure_getters: true,
+    }
+    input: {
+        function inc(obj) {
+            return obj.count++;
+        }
+        function foo(bar, baz) {
+            var result = inc(bar);
+            return foo.amount = baz.count, result;
+        }
+        var data = {
+            count: 0,
+        };
+        var answer = foo(data, data);
+        console.log(foo.amount, answer);
+    }
+    expect: {
+        function inc(obj) {
+            return obj.count++;
+        }
+        function foo(bar, baz) {
+            var result = inc(bar);
+            return foo.amount = baz.count, result;
+        }
+        var data = {
+            count: 0,
+        };
+        var answer = foo(data, data);
+        console.log(foo.amount, answer);
+    }
+    expect_stdout: "1 0"
+}
+
+issue_2364_5: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        pure_getters: true,
+        properties: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function f0(o, a, h) {
+            var b = 3 - a;
+            var obj = o;
+            var seven = 7;
+            var prop = 'run';
+            var t = obj[prop](b)[seven] = h;
+            return t;
+        }
+    }
+    expect: {
+        function f0(o, a, h) {
+            return o.run(3 - a)[7] = h;
+        }
+    }
+}
+
+issue_2364_6: {
+    options = {
+        collapse_vars: true,
+        pure_getters: true,
+    }
+    input: {
+        function f(a, b) {
+            var c = a.p;
+            b.p = "FAIL";
+            return c;
+        }
+        var o = {
+            p: "PASS"
+        }
+        console.log(f(o, o));
+    }
+    expect: {
+        function f(a, b) {
+            var c = a.p;
+            b.p = "FAIL";
+            return c;
+        }
+        var o = {
+            p: "PASS"
+        }
+        console.log(f(o, o));
+    }
+    expect_stdout: "PASS"
+}
+
+issue_2364_7: {
+    options = {
+        collapse_vars: true,
+        pure_getters: true,
+    }
+    input: {
+        function f(a, b) {
+            var c = a.p;
+            b.f();
+            return c;
+        }
+        var o = {
+            p: "PASS",
+            f: function() {
+                this.p = "FAIL";
+            }
+        }
+        console.log(f(o, o));
+    }
+    expect: {
+        function f(a, b) {
+            var c = a.p;
+            b.f();
+            return c;
+        }
+        var o = {
+            p: "PASS",
+            f: function() {
+                this.p = "FAIL";
+            }
+        }
+        console.log(f(o, o));
+    }
+    expect_stdout: "PASS"
+}
+
+issue_2364_8: {
+    options = {
+        collapse_vars: true,
+        pure_getters: true,
+    }
+    input: {
+        function f(a, b, c) {
+            var d = a[b.f = function() {
+                return "PASS";
+            }];
+            return c.f(d);
+        }
+        var o = {
+            f: function() {
+                return "FAIL";
+            }
+        };
+        console.log(f({}, o, o));
+    }
+    expect: {
+        function f(a, b, c) {
+            var d = a[b.f = function() {
+                return "PASS";
+            }];
+            return c.f(d);
+        }
+        var o = {
+            f: function() {
+                return "FAIL";
+            }
+        };
+        console.log(f({}, o, o));
+    }
+    expect_stdout: "PASS"
+}
+
+issue_2364_9: {
+    options = {
+        collapse_vars: true,
+        pure_getters: true,
+    }
+    input: {
+        function f(a, b) {
+            var d = a();
+            return b.f(d);
+        }
+        var o = {
+            f: function() {
+                return "FAIL";
+            }
+        };
+        console.log(f(function() {
+            o.f = function() {
+                return "PASS";
+            };
+        }, o));
+    }
+    expect: {
+        function f(a, b) {
+            var d = a();
+            return b.f(d);
+        }
+        var o = {
+            f: function() {
+                return "FAIL";
+            }
+        };
+        console.log(f(function() {
+            o.f = function() {
+                return "PASS";
+            };
+        }, o));
+    }
+    expect_stdout: "PASS"
+}
+
+pure_getters_chain: {
+    options = {
+        collapse_vars: true,
+        pure_getters: true,
+        unused: true,
+    }
+    input: {
+        function o(t, r) {
+            var a = t[1], s = t[2], o = t[3], i = t[5];
+            return a <= 23 && s <= 59 && o <= 59 && (!r || i);
+        }
+        console.log(o([ , 23, 59, 59, , 42], 1));
+    }
+    expect: {
+        function o(t, r) {
+            return t[1] <= 23 && t[2] <= 59 && t[3] <= 59 && (!r || t[5]);
+        }
+        console.log(o([ , 23, 59, 59, , 42], 1));
+    }
+    expect_stdout: "42"
+}
+
+conditional_1: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        function f(a, b) {
+            var c = "";
+            var d = b ? ">" : "<";
+            if (a) c += "=";
+            return c += d;
+        }
+        console.log(f(0, 0), f(0, 1), f(1, 0), f(1, 1));
+    }
+    expect: {
+        function f(a, b) {
+            var c = "";
+            if (a) c += "=";
+            return c += b ? ">" : "<";
+        }
+        console.log(f(0, 0), f(0, 1), f(1, 0), f(1, 1));
+    }
+    expect_stdout: "< > =< =>"
+}
+
+conditional_2: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        function f(a, b) {
+            var c = a + 1, d = a + 2;
+            return b ? c : d;
+        }
+        console.log(f(3, 0), f(4, 1));
+    }
+    expect: {
+        function f(a, b) {
+            return b ? a + 1 : a + 2;
+        }
+        console.log(f(3, 0), f(4, 1));
+    }
+    expect_stdout: "5 5"
+}
+
+issue_2425_1: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        var a = 8;
+        (function(b) {
+            b.toString();
+        })(--a, a |= 10);
+        console.log(a);
+    }
+    expect: {
+        var a = 8;
+        (function(b) {
+            b.toString();
+        })(--a, a |= 10);
+        console.log(a);
+    }
+    expect_stdout: "15"
+}
+
+issue_2425_2: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        var a = 8;
+        (function(b, c) {
+            b.toString();
+        })(--a, a |= 10);
+        console.log(a);
+    }
+    expect: {
+        var a = 8;
+        (function(b, c) {
+            b.toString();
+        })(--a, a |= 10);
+        console.log(a);
+    }
+    expect_stdout: "15"
+}
+
+issue_2425_3: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        var a = 8;
+        (function(b, b) {
+            b.toString();
+        })(--a, a |= 10);
+        console.log(a);
+    }
+    expect: {
+        var a = 8;
+        (function(b, b) {
+            (a |= 10).toString();
+        })(--a);
+        console.log(a);
+    }
+    expect_stdout: "15"
+}
+
+issue_2437: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        inline: true,
+        join_vars: true,
+        reduce_vars: true,
+        side_effects: true,
+        sequences: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function foo() {
+            bar();
+        }
+        function bar() {
+            if (xhrDesc) {
+                var req = new XMLHttpRequest();
+                var result = !!req.onreadystatechange;
+                Object.defineProperty(XMLHttpRequest.prototype, 'onreadystatechange', xhrDesc || {});
+                return result;
+            }
+            else {
+                var req = new XMLHttpRequest();
+                var detectFunc = function () { };
+                req.onreadystatechange = detectFunc;
+                var result = req[SYMBOL_FAKE_ONREADYSTATECHANGE_1] === detectFunc;
+                req.onreadystatechange = null;
+                return result;
+            }
+        }
+        foo();
+    }
+    expect: {
+        !function() {
+            if (xhrDesc)
+                return result = !!(req = new XMLHttpRequest()).onreadystatechange,
+                    Object.defineProperty(XMLHttpRequest.prototype, "onreadystatechange", xhrDesc || {}),
+                    result;
+            var req = new XMLHttpRequest(), detectFunc = function() {};
+            req.onreadystatechange = detectFunc;
+            var result = req[SYMBOL_FAKE_ONREADYSTATECHANGE_1] === detectFunc;
+            req.onreadystatechange = null;
+        }();
+    }
+}

test/compress/comparing.js

@@ -73,4 +73,41 @@ dont_change_in_or_instanceof_expressions: {
         1 instanceof 1;
         null instanceof null;
     }
-}
+}
+
+self_comparison_1: {
+    options = {
+        comparisons: true,
+    }
+    input: {
+        a === a;
+        a !== b;
+        b.c === a.c;
+        b.c !== b.c;
+    }
+    expect: {
+        a == a;
+        a !== b;
+        b.c === a.c;
+        b.c != b.c;
+    }
+}
+
+self_comparison_2: {
+    options = {
+        comparisons: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        function f() {}
+        var o = {};
+        console.log(f != f, o === o);
+    }
+    expect: {
+        function f() {}
+        var o = {};
+        console.log(false, true);
+    }
+    expect_stdout: "false true"
+}

test/compress/dead-code.js

@@ -560,3 +560,64 @@ global_fns: {
         "RangeError",
     ]
 }
+
+issue_2383_1: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+    }
+    input: {
+        if (0) {
+            var {x, y} = foo();
+        }
+    }
+    expect: {
+        var x, y;
+    }
+}
+
+issue_2383_2: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+    }
+    input: {
+        if (0) {
+            var {
+                x = 0,
+                y: [ w, , { z, p: q = 7 } ] = [ 1, 2, { z: 3 } ]
+            } = {};
+        }
+        console.log(x, q, w, z);
+    }
+    expect: {
+        var x, w, z, q;
+        console.log(x, q, w, z);
+    }
+    expect_stdout: "undefined undefined undefined undefined"
+    node_version: ">=6"
+}
+
+issue_2383_3: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+    }
+    input: {
+        var b = 7, y = 8;
+        if (0) {
+            var a = 1, [ x, y, z ] = [ 2, 3, 4 ], b = 5;
+        }
+        console.log(a, x, y, z, b);
+    }
+    expect: {
+        var b = 7, y = 8;
+        var a, x, y, z, b;
+        console.log(a, x, y, z, b);
+    }
+    expect_stdout: "undefined undefined 8 undefined 7"
+    node_version: ">=6"
+}

test/compress/drop-unused.js

@@ -863,12 +863,12 @@ issue_1583: {
     expect: {
         function m(t) {
             (function(e) {
-                t = e();
-            })(function() {
-                return (function(a) {
-                    return a;
-                })(function(a) {});
-            });
+                t = function() {
+                    return (function(a) {
+                        return function(a) {};
+                    })();
+                }();
+            })();
         }
     }
 }
@@ -1291,15 +1291,14 @@ issue_2063: {
     }
     expect: {
         var a;
-        var a;
     }
 }
 
-issue_2105: {
+issue_2105_1: {
     options = {
         collapse_vars: true,
         inline: true,
-        passes: 3,
+        passes: 2,
         reduce_vars: true,
         side_effects: true,
         unused: true,
@@ -1325,17 +1324,50 @@ issue_2105: {
         });
     }
     expect: {
-        (function() {
-            var quux = function() {
+        ({
+            prop: function() {
+                console.log;
                 console.log("PASS");
-            };
-            return {
-                prop: function() {
-                    console.log;
-                    quux();
+            }
+        }).prop();
+    }
+    expect_stdout: "PASS"
+}
+
+issue_2105_2: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        passes: 2,
+        properties: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+        unsafe: 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 };
                 }
-            };
-        })().prop();
+                return bar;
+            } );
+        });
+    }
+    expect: {
+        console.log("PASS");
     }
     expect_stdout: "PASS"
 }

test/compress/evaluate.js

@@ -480,10 +480,11 @@ unsafe_object_accessor: {
     }
 }
 
-unsafe_function: {
+prop_function: {
     options = {
-        evaluate  : true,
-        unsafe    : true
+        evaluate: true,
+        properties: true,
+        side_effects: true,
     }
     input: {
         console.log(
@@ -496,9 +497,9 @@ unsafe_function: {
     expect: {
         console.log(
             ({a:{b:1},b:function(){}}) + 1,
-            ({b:function(){}}, {b:1}) + 1,
-            ({a:{b:1}}, function(){}) + 1,
-            ({b:function(){}}, {b:1}).b + 1
+            ({b:1}) + 1,
+            function(){} + 1,
+            2
         );
     }
     expect_stdout: true
@@ -724,10 +725,11 @@ unsafe_string_bad_index: {
     expect_stdout: true
 }
 
-unsafe_prototype_function: {
+prototype_function: {
     options = {
-        evaluate  : true,
-        unsafe    : true
+        evaluate: true,
+        properties: true,
+        side_effects: true,
     }
     input: {
         var a = ({valueOf: 0}) < 1;
@@ -746,8 +748,8 @@ unsafe_prototype_function: {
         var d = ({toString: 0}) + "";
         var e = (({valueOf: 0}) + "")[2];
         var f = (({toString: 0}) + "")[2];
-        var g = ({}, 0)();
-        var h = ({}, 0)();
+        var g = 0();
+        var h = 0();
     }
 }
 
@@ -1114,6 +1116,7 @@ issue_1964_1: {
     input: {
         function f() {
             var long_variable_name = /\s/;
+            console.log(long_variable_name.source);
             return "a b c".split(long_variable_name)[1];
         }
         console.log(f());
@@ -1121,11 +1124,15 @@ issue_1964_1: {
     expect: {
         function f() {
             var long_variable_name = /\s/;
+            console.log(long_variable_name.source);
             return "a b c".split(long_variable_name)[1];
         }
         console.log(f());
     }
-    expect_stdout: "b"
+    expect_stdout: [
+        "\\s",
+        "b",
+    ]
 }
 
 issue_1964_2: {
@@ -1138,17 +1145,22 @@ issue_1964_2: {
     input: {
         function f() {
             var long_variable_name = /\s/;
+            console.log(long_variable_name.source);
             return "a b c".split(long_variable_name)[1];
         }
         console.log(f());
     }
     expect: {
         function f() {
+            console.log(/\s/.source);
             return "a b c".split(/\s/)[1];
         }
         console.log(f());
     }
-    expect_stdout: "b"
+    expect_stdout: [
+        "\\s",
+        "b",
+    ]
 }
 
 array_slice_index: {
@@ -1278,3 +1290,40 @@ issue_2231_2: {
     }
     expect_stdout: true
 }
+
+self_comparison_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        var o = { n: NaN };
+        console.log(o.n == o.n, o.n === o.n, o.n != o.n, o.n !== o.n, typeof o.n);
+    }
+    expect: {
+        console.log(false, false, true, true, "number");
+    }
+    expect_stdout: "false false true true 'number'"
+}
+
+self_comparison_2: {
+    options = {
+        evaluate: true,
+        hoist_props: true,
+        passes: 2,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = { n: NaN };
+        console.log(o.n == o.n, o.n === o.n, o.n != o.n, o.n !== o.n, typeof o.n);
+    }
+    expect: {
+        console.log(false, false, true, true, "number");
+    }
+    expect_stdout: "false false true true 'number'"
+}

test/compress/export.js

@@ -226,3 +226,27 @@ keyword_valid_3: {
         export { default as default } from "module.js";
     }
 }
+
+dynamic_import: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        import traditional from './traditional.js';
+        function imp(x) {
+            return import(x);
+        }
+        import("module_for_side_effects.js");
+        let dynamic = import("some/module.js");
+        dynamic.foo();
+    }
+    expect: {
+        import o from "./traditional.js";
+        function t(o) {
+            return import(o);
+        }
+        import("module_for_side_effects.js");
+        let r = import("some/module.js");
+        r.foo();
+    }
+}

test/compress/functions.js

@@ -151,13 +151,13 @@ issue_1841_2: {
 
 function_returning_constant_literal: {
     options = {
-        reduce_vars: true,
-        unsafe: true,
-        toplevel: true,
-        evaluate: true,
-        cascade: true,
-        unused: true,
         inline: true,
+        passes: 2,
+        properties: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
     }
     input: {
         function greeter() {
@@ -508,3 +508,41 @@ issue_2114_2: {
     }
     expect_stdout: "2"
 }
+
+issue_2428: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        passes: 2,
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        function bar(k) {
+            console.log(k);
+        }
+        function foo(x) {
+            return bar(x);
+        }
+        function baz(a) {
+            foo(a);
+        }
+        baz(42);
+        baz("PASS");
+    }
+    expect: {
+        function baz(a) {
+            console.log(a);
+        }
+        baz(42);
+        baz("PASS");
+    }
+    expect_stdout: [
+        "42",
+        "PASS",
+    ]
+}

test/compress/harmony.js

@@ -804,3 +804,134 @@ object_spread_of_sequence: {
         console.log({ ...o || o });
     }
 }
+
+// issue 2316
+class_name_can_be_preserved_with_reserved: {
+    mangle = {
+        reserved: [ "Foo" ],
+    }
+    input: {
+        function x() {
+            class Foo {}
+            Foo.bar;
+            class Bar {}
+            Bar.foo;
+        }
+        function y() {
+            var Foo = class Foo {};
+            Foo.bar;
+            var Bar = class Bar {};
+            Bar.bar;
+        }
+    }
+    expect: {
+        function x() {
+            class Foo {}
+            Foo.bar;
+            class a {}
+            a.foo;
+        }
+        function y() {
+            var Foo = class Foo {};
+            Foo.bar;
+            var a = class a {};
+            a.bar;
+        }
+    }
+}
+
+issue_2345: {
+    options = {
+        evaluate: true,
+        side_effects: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        console.log([...[3, 2, 1]].join("-"));
+        var a = [3, 2, 1];
+        console.log([...a].join("-"));
+    }
+    expect: {
+        console.log([...[3, 2, 1]].join("-"));
+        var a = [3, 2, 1];
+        console.log([...a].join("-"));
+    }
+    expect_stdout: [
+        "3-2-1",
+        "3-2-1",
+    ]
+    node_version: ">=6"
+}
+
+issue_2349: {
+    mangle = {}
+    input: {
+        function foo(boo, key) {
+            const value = boo.get();
+            return value.map(({[key]: bar}) => bar);
+        }
+        console.log(foo({
+            get: () => [ {
+                blah: 42
+            } ]
+        }, "blah"));
+    }
+    expect: {
+        function foo(o, n) {
+            const t = o.get();
+            return t.map(({[n]: o}) => o);
+        }
+        console.log(foo({
+            get: () => [ {
+                blah: 42
+            } ]
+        }, "blah"));
+    }
+    expect_stdout: [
+        "[ 42 ]",
+    ]
+    node_version: ">=7"
+}
+
+issue_2349b: {
+    options = {
+        arrows: true,
+        collapse_vars: true,
+        ecma: 6,
+        evaluate: true,
+        inline: true,
+        passes: 3,
+        properties: true,
+        reduce_vars: true,
+        toplevel: true,
+        side_effects: true,
+        unsafe_arrows: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        function foo(boo, key) {
+            const value = boo.get();
+            return value.map(function({[key]: bar}){ return bar; });
+        }
+        console.log(foo({
+            get: function() {
+                return  [ {
+                    blah: 42
+                } ];
+            }
+        }, "blah"));
+    }
+    expect: {
+        console.log([ {
+            blah: 42
+        } ].map(({["blah"]: l}) => l));
+    }
+    expect_stdout: [
+        "[ 42 ]",
+    ]
+    node_version: ">=7"
+}

test/compress/hoist_props.js

@@ -0,0 +1,513 @@
+issue_2377_1: {
+    options = {
+        evaluate: true,
+        inline: true,
+        hoist_props: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var obj = {
+            foo: 1,
+            bar: 2,
+            square: function(x) {
+                return x * x;
+            },
+            cube: function(x) {
+                return x * x * x;
+            },
+        };
+        console.log(obj.foo, obj.cube(3));
+    }
+    expect: {
+        var obj_foo = 1, obj_cube = function(x) {
+            return x * x * x;
+        };
+        console.log(obj_foo, obj_cube(3));
+    }
+    expect_stdout: "1 27"
+}
+
+issue_2377_2: {
+    options = {
+        evaluate: true,
+        inline: true,
+        hoist_props: true,
+        passes: 2,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var obj = {
+            foo: 1,
+            bar: 2,
+            square: function(x) {
+                return x * x;
+            },
+            cube: function(x) {
+                return x * x * x;
+            },
+        };
+        console.log(obj.foo, obj.cube(3));
+    }
+    expect: {
+        console.log(1, function(x) {
+            return x * x * x;
+        }(3));
+    }
+    expect_stdout: "1 27"
+}
+
+issue_2377_3: {
+    options = {
+        evaluate: true,
+        inline: true,
+        hoist_props: true,
+        passes: 3,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var obj = {
+            foo: 1,
+            bar: 2,
+            square: function(x) {
+                return x * x;
+            },
+            cube: function(x) {
+                return x * x * x;
+            },
+        };
+        console.log(obj.foo, obj.cube(3));
+    }
+    expect: {
+        console.log(1, 27);
+    }
+    expect_stdout: "1 27"
+}
+
+direct_access_1: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 0;
+        var obj = {
+            a: 1,
+            b: 2,
+        };
+        for (var k in obj) a++;
+        console.log(a, obj.a);
+    }
+    expect: {
+        var a = 0;
+        var obj = {
+            a: 1,
+            b: 2,
+        };
+        for (var k in obj) a++;
+        console.log(a, obj.a);
+    }
+    expect_stdout: "2 1"
+}
+
+direct_access_2: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = { a: 1 };
+        var f = function(k) {
+            if (o[k]) return "PASS";
+        };
+        console.log(f("a"));
+    }
+    expect: {
+        var o = { a: 1 };
+        console.log(function(k) {
+            if (o[k]) return "PASS";
+        }("a"));
+    }
+    expect_stdout: "PASS"
+}
+
+direct_access_3: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = { a: 1 };
+        o.b;
+        console.log(o.a);
+    }
+    expect: {
+        var o = { a: 1 };
+        o.b;
+        console.log(o.a);
+    }
+    expect_stdout: "1"
+}
+
+single_use: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var obj = {
+            bar: function() {
+                return 42;
+            },
+        };
+        console.log(obj.bar());
+    }
+    expect: {
+        console.log({
+            bar: function() {
+                return 42;
+            },
+        }.bar());
+    }
+}
+
+name_collision_1: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var obj_foo = 1;
+        var obj_bar = 2;
+        function f() {
+            var obj = {
+                foo: 3,
+                bar: 4,
+                "b-r": 5,
+                "b+r": 6,
+                "b!r": 7,
+            };
+            console.log(obj_foo, obj.foo, obj.bar, obj["b-r"], obj["b+r"], obj["b!r"]);
+        }
+        f();
+    }
+    expect: {
+        var obj_foo = 1;
+        var obj_bar = 2;
+        function f() {
+            var obj_foo$0 = 3,
+                obj_bar = 4,
+                obj_b_r = 5,
+                obj_b_r$0 = 6,
+                obj_b_r$1 = 7;
+            console.log(obj_foo, obj_foo$0, obj_bar, obj_b_r, obj_b_r$0, obj_b_r$1);
+        }
+        f();
+    }
+    expect_stdout: "1 3 4 5 6 7"
+}
+
+name_collision_2: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var o = {
+            p: 1,
+            0: function(x) {
+                return x;
+            },
+            1: function(x) {
+                return x + 1;
+            }
+        }, o__$0 = 2, o__$1 = 3;
+        console.log(o.p === o.p, o[0](4), o[1](5), o__$0, o__$1);
+    }
+    expect: {
+        var o_p = 1,
+            o__ = function(x) {
+                return x;
+            },
+            o__$2 = function(x) {
+                return x + 1;
+            },
+            o__$0 = 2,
+            o__$1 = 3;
+        console.log(o_p === o_p, o__(4), o__$2(5), o__$0, o__$1);
+    }
+    expect_stdout: "true 4 6 2 3"
+}
+
+name_collision_3: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var o = {
+            p: 1,
+            0: function(x) {
+                return x;
+            },
+            1: function(x) {
+                return x + 1;
+            }
+        }, o__$0 = 2, o__$1 = 3;
+        console.log(o.p === o.p, o[0](4), o[1](5));
+    }
+    expect: {
+        var o_p = 1,
+            o__ = function(x) {
+                return x;
+            },
+            o__$2 = function(x) {
+                return x + 1;
+            },
+            o__$0 = 2,
+            o__$1 = 3;
+        console.log(o_p === o_p, o__(4), o__$2(5));
+    }
+    expect_stdout: "true 4 6"
+}
+
+contains_this_1: {
+    options = {
+        evaluate: true,
+        hoist_props: true,
+        inline: true,
+        passes: 2,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = {
+            u: function() {
+                return this === this;
+            },
+            p: 1
+        };
+        console.log(o.p, o.p);
+    }
+    expect: {
+        console.log(1, 1);
+    }
+    expect_stdout: "1 1"
+}
+
+contains_this_2: {
+    options = {
+        evaluate: true,
+        hoist_props: true,
+        inline: true,
+        passes: 2,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = {
+            u: function() {
+                return this === this;
+            },
+            p: 1
+        };
+        console.log(o.p, o.p, o.u);
+    }
+    expect: {
+        console.log(1, 1, function() {
+            return this === this;
+        });
+    }
+    expect_stdout: true
+}
+
+contains_this_3: {
+    options = {
+        evaluate: true,
+        hoist_props: true,
+        inline: true,
+        passes: 2,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = {
+            u: function() {
+                return this === this;
+            },
+            p: 1
+        };
+        console.log(o.p, o.p, o.u());
+    }
+    expect: {
+        var o = {
+            u: function() {
+                return this === this;
+            },
+            p: 1
+        };
+        console.log(o.p, o.p, o.u());
+    }
+    expect_stdout: "1 1 true"
+}
+
+hoist_class: {
+    options = {
+        comparisons: true,
+        evaluate: true,
+        hoist_props: true,
+        inline: true,
+        keep_fnames: true,
+        passes: 2,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function run(c, v) {
+            return new c(v).value;
+        }
+        var o = {
+            p: class Foo {
+                constructor(value) {
+                    this.value = value * 10;
+                }
+            },
+            x: 1,
+            y: 2,
+        };
+        console.log(o.p.name, o.p === o.p, run(o.p, o.x), run(o.p, o.y));
+    }
+    expect: {
+        function run(c, v) {
+            return new c(v).value;
+        }
+        var o_p = class Foo {
+            constructor(value) {
+                this.value = 10 * value;
+            }
+        };
+        console.log(o_p.name, true, run(o_p, 1), run(o_p, 2));
+    }
+    node_version: ">=6"
+    expect_stdout: "Foo true 10 20"
+}
+
+hoist_class_with_new: {
+    options = {
+        comparisons: true,
+        evaluate: true,
+        hoist_props: true,
+        inline: true,
+        keep_fnames: true,
+        passes: 2,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = {
+            p: class Foo {
+                constructor(value) {
+                    this.value = value * 10;
+                }
+            },
+            x: 1,
+            y: 2,
+        };
+        console.log(o.p.name, o.p === o.p, new o.p(o.x).value, new o.p(o.y).value);
+    }
+    expect: {
+        // FIXME: class `o.p` not hoisted due to `new`
+        var o = {
+            p: class Foo {
+                constructor(value) {
+                    this.value = 10 * value;
+                }
+            },
+            x: 1,
+            y: 2
+        };
+        console.log(o.p.name, o.p == o.p, new o.p(o.x).value, new o.p(o.y).value);
+    }
+    node_version: ">=6"
+    expect_stdout: "Foo true 10 20"
+}
+
+hoist_function_with_call: {
+    options = {
+        comparisons: true,
+        evaluate: true,
+        hoist_props: true,
+        inline: true,
+        keep_fnames: true,
+        passes: 2,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = {
+            p: function Foo(value) {
+                return 10 * value;
+            },
+            x: 1,
+            y: 2
+        };
+        console.log(o.p.name, o.p === o.p, o.p(o.x), o.p(o.y));
+    }
+    expect: {
+        var o_p = function Foo(value){
+            return 10 * value
+        };
+        console.log(o_p.name, true, o_p(1), o_p(2));
+    }
+    expect_stdout: "Foo true 10 20"
+}
+
+new_this: {
+    options = {
+        evaluate: true,
+        hoist_props: true,
+        inline: true,
+        passes: 2,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = {
+            a: 1,
+            b: 2,
+            f: function(a) {
+                this.b = a;
+            }
+        };
+        console.log(new o.f(o.a).b, o.b);
+    }
+    expect: {
+        console.log(new function(a) {
+            this.b = a;
+        }(1).b, 2);
+    }
+    expect_stdout: "1 2"
+}

test/compress/issue-2001.js

@@ -177,6 +177,7 @@ export_mangle_2: {
 export_mangle_3: {
     options = {
         collapse_vars: true,
+        unused: true,
     }
     mangle = {
         toplevel: true,
@@ -195,6 +196,7 @@ export_mangle_3: {
 export_mangle_4: {
     options = {
         collapse_vars: true,
+        unused: true,
     }
     mangle = {
         toplevel: true,

test/compress/issue-973.js

@@ -51,6 +51,7 @@ this_binding_collapse_vars: {
     options = {
         collapse_vars: true,
         toplevel: true,
+        unused: true,
     };
     input: {
         var c = a; c();

test/compress/object.js

@@ -126,6 +126,67 @@ computed_property_names: {
     expect_exact: 'obj({["x"+"x"]:6});'
 }
 
+convert_computed_props_to_regular_ones: {
+    options = {
+        booleans: true,
+        computed_props: true,
+        evaluate: true,
+    }
+    input: {
+        var o = {
+            ["hi"]: 0,
+            ["A" + 1]: 1,
+            [/B/]: 2,
+            [100 + 23]: 3,
+            [1 + .5]: 4,
+            [Math.PI]: 5,
+            [undefined]: 6,
+            [true]: 7,
+            [false]: 8,
+            [null]: 9,
+            [Infinity]: 10,
+            [NaN]: 11,
+        };
+        for (var k in o) {
+            console.log(k, o[k]);
+        }
+    }
+    expect: {
+        var o = {
+            hi: 0,
+            A1: 1,
+            [/B/]: 2,
+            123: 3,
+            1.5: 4,
+            [Math.PI]: 5,
+
+            // leave these problematic cases as is
+            [void 0]: 6,
+            [!0]: 7,
+            [!1]: 8,
+            [null]: 9,
+            [1 / 0]: 10,
+            [NaN]: 11
+        };
+        for (var k in o) console.log(k, o[k]);
+    }
+    expect_stdout: [
+        "123 3",
+        "hi 0",
+        "A1 1",
+        "/B/ 2",
+        "1.5 4",
+        "3.141592653589793 5",
+        "undefined 6",
+        "true 7",
+        "false 8",
+        "null 9",
+        "Infinity 10",
+        "NaN 11",
+    ]
+    node_version: ">=6"
+}
+
 computed_property_names_evaluated_1: {
     options = {
         evaluate: true
@@ -516,6 +577,7 @@ variable_as_computed_property: {
 prop_func_to_concise_method: {
     options = {
         ecma: 6,
+        unsafe_methods: true,
     }
     input: {
         ({
@@ -544,6 +606,7 @@ prop_func_to_concise_method: {
 prop_arrow_to_concise_method: {
     options = {
         ecma: 6,
+        unsafe_methods: true,
     }
     input: {
         ({
@@ -592,6 +655,7 @@ concise_method_to_prop_arrow: {
 prop_func_to_async_concise_method: {
     options = {
         ecma: 8,
+        unsafe_methods: true,
     }
     input: {
         ({
@@ -614,6 +678,7 @@ prop_func_to_async_concise_method: {
 prop_func_to_concise_method_various: {
     options = {
         ecma: 6,
+        unsafe_methods: true,
     }
     input: {
         ({
@@ -646,6 +711,7 @@ prop_func_to_concise_method_various: {
 prop_arrows_to_concise_method_various: {
     options = {
         ecma: 6,
+        unsafe_methods: true,
     }
     input: {
         ({
@@ -674,6 +740,7 @@ prop_arrows_to_concise_method_various: {
 prop_arrow_with_this: {
     options = {
         ecma: 6,
+        unsafe_methods: true,
     }
     input: {
         function run(arg) {
@@ -711,6 +778,7 @@ prop_arrow_with_this: {
 prop_arrow_with_nested_this: {
     options = {
         ecma: 6,
+        unsafe_methods: true,
     }
     input: {
         function run(arg) {

test/compress/properties.js

@@ -1,7 +1,8 @@
 keep_properties: {
     options = {
-        properties: false
-    };
+        evaluate: true,
+        properties: false,
+    }
     input: {
         a["foo"] = "bar";
     }
@@ -12,6 +13,7 @@ keep_properties: {
 
 dot_properties: {
     options = {
+        evaluate: true,
         properties: true,
     }
     beautify = {
@@ -37,6 +39,7 @@ dot_properties: {
 
 dot_properties_es5: {
     options = {
+        evaluate: true,
         properties: true,
     }
     beautify = {
@@ -61,8 +64,8 @@ dot_properties_es5: {
 sub_properties: {
     options = {
         evaluate: true,
-        properties: true
-    };
+        properties: true,
+    }
     input: {
         a[0] = 0;
         a["0"] = 1;
@@ -81,18 +84,18 @@ sub_properties: {
         a[3.14] = 3;
         a.if = 4;
         a["foo bar"] = 5;
-        a[NaN] = 6;
-        a[null] = 7;
+        a.NaN = 6;
+        a.null = 7;
         a[void 0] = 8;
     }
 }
 
 evaluate_array_length: {
     options = {
+        evaluate: true,
         properties: true,
         unsafe: true,
-        evaluate: true
-    };
+    }
     input: {
         a = [1, 2, 3].length;
         a = [1, 2, 3].join()["len" + "gth"];
@@ -109,10 +112,10 @@ evaluate_array_length: {
 
 evaluate_string_length: {
     options = {
+        evaluate: true,
         properties: true,
         unsafe: true,
-        evaluate: true
-    };
+    }
     input: {
         a = "foo".length;
         a = ("foo" + "bar")["len" + "gth"];
@@ -151,7 +154,8 @@ mangle_properties: {
 
 mangle_unquoted_properties: {
     options = {
-        properties: false
+        evaluate: true,
+        properties: false,
     }
     mangle = {
         properties: {
@@ -250,7 +254,8 @@ mangle_debug_suffix: {
 
 mangle_debug_suffix_keep_quoted: {
     options = {
-        properties: false
+        evaluate: true,
+        properties: false,
     }
     mangle = {
         properties: {
@@ -679,8 +684,8 @@ accessor_this: {
 issue_2208_1: {
     options = {
         inline: true,
+        properties: true,
         side_effects: true,
-        unsafe: true,
     }
     input: {
         console.log({
@@ -698,8 +703,8 @@ issue_2208_1: {
 issue_2208_2: {
     options = {
         inline: true,
+        properties: true,
         side_effects: true,
-        unsafe: true,
     }
     input: {
         console.log({
@@ -723,8 +728,8 @@ issue_2208_2: {
 issue_2208_3: {
     options = {
         inline: true,
+        properties: true,
         side_effects: true,
-        unsafe: true,
     }
     input: {
         a = 42;
@@ -748,8 +753,8 @@ issue_2208_3: {
 issue_2208_4: {
     options = {
         inline: true,
+        properties: true,
         side_effects: true,
-        unsafe: true,
     }
     input: {
         function foo() {}
@@ -772,8 +777,8 @@ issue_2208_4: {
 issue_2208_5: {
     options = {
         inline: true,
+        properties: true,
         side_effects: true,
-        unsafe: true,
     }
     input: {
         console.log({
@@ -792,8 +797,8 @@ issue_2208_5: {
 issue_2208_6: {
     options = {
         inline: true,
+        properties: true,
         side_effects: true,
-        unsafe: true,
     }
     input: {
         console.log({
@@ -809,9 +814,11 @@ issue_2208_6: {
 
 issue_2208_7: {
     options = {
+        ecma: 6,
         inline: true,
+        properties: true,
         side_effects: true,
-        unsafe: true,
+        unsafe_arrows: true,
     }
     input: {
         console.log({
@@ -829,9 +836,11 @@ issue_2208_7: {
 
 issue_2208_8: {
     options = {
+        ecma: 6,
         inline: true,
+        properties: true,
         side_effects: true,
-        unsafe: true,
+        unsafe_arrows: true,
     }
     input: {
         console.log({
@@ -851,17 +860,17 @@ issue_2208_8: {
                 return x();
             }
         }.p());
-        console.log(async function() {
+        console.log((async () => {
             return await x();
-        }());
+        })());
     }
 }
 
 issue_2208_9: {
     options = {
         inline: true,
+        properties: true,
         side_effects: true,
-        unsafe: true,
     }
     input: {
         a = 42;
@@ -887,6 +896,7 @@ methods_keep_quoted_true: {
     options = {
         arrows: true,
         ecma: 6,
+        unsafe_methods: true,
     }
     mangle = {
         properties: {
@@ -906,6 +916,7 @@ methods_keep_quoted_false: {
     options = {
         arrows: true,
         ecma: 6,
+        unsafe_methods: true,
     }
     mangle = {
         properties: {
@@ -931,6 +942,7 @@ methods_keep_quoted_from_dead_code: {
         evaluate: true,
         reduce_vars: true,
         side_effects: true,
+        unsafe_methods: true,
     }
     mangle = {
         properties: {
@@ -964,3 +976,328 @@ issue_2256: {
         g.keep = g.g;
     }
 }
+
+issue_2321: {
+    options = {
+        ecma: 6,
+        unsafe_methods: false,
+    }
+    input: {
+        var f = {
+            foo: function(){ console.log("foo") },
+            bar() { console.log("bar") }
+        };
+        var foo = new f.foo();
+        var bar =     f.bar();
+    }
+    expect: {
+        var f = {
+            foo: function() {
+                console.log("foo");
+            },
+            bar() {
+                console.log("bar");
+            }
+        };
+        var foo = new f.foo();
+        var bar = f.bar();
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+    node_version: ">=6"
+}
+
+unsafe_methods_regex: {
+    options = {
+        ecma: 6,
+        unsafe_methods: /^[A-Z1]/,
+    }
+    input: {
+        var f = {
+            123: function(){ console.log("123") },
+            foo: function(){ console.log("foo") },
+            bar() { console.log("bar") },
+            Baz: function(){ console.log("baz") },
+            BOO: function(){ console.log("boo") },
+            null: function(){ console.log("null") },
+            undefined: function(){ console.log("undefined") },
+        };
+        f[123]();
+        new f.foo();
+        f.bar();
+        f.Baz();
+        f.BOO();
+        new f.null();
+        new f.undefined();
+    }
+    expect: {
+        var f = {
+            123() { console.log("123") },
+            foo: function(){ console.log("foo") },
+            bar() { console.log("bar"); },
+            Baz() { console.log("baz") },
+            BOO() { console.log("boo") },
+            null: function(){ console.log("null") },
+            undefined: function(){ console.log("undefined") },
+        };
+        f[123]();
+        new f.foo();
+        f.bar();
+        f.Baz();
+        f.BOO();
+        new f.null();
+        new f.undefined();
+    }
+    expect_stdout: [
+        "123",
+        "foo",
+        "bar",
+        "baz",
+        "boo",
+        "null",
+        "undefined",
+    ]
+    node_version: ">=6"
+}
+
+lhs_prop_1: {
+    options = {
+        evaluate: true,
+        properties: true,
+    }
+    input: {
+        console.log(++{
+            a: 1
+        }.a);
+    }
+    expect: {
+        console.log(++{
+            a: 1
+        }.a);
+    }
+    expect_stdout: "2"
+}
+
+lhs_prop_2: {
+    options = {
+        evaluate: true,
+        inline: true,
+        properties: true,
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        [1][0] = 42;
+        (function(a) {
+            a.b = "g";
+        })("abc");
+        (function(a) {
+            a[2] = "g";
+        })("def");
+        (function(a) {
+            a[""] = "g";
+        })("ghi");
+    }
+    expect: {
+        [1][0] = 42;
+        "abc".b = "g";
+        "def"[2] = "g";
+        "ghi"[""] = "g";
+    }
+}
+
+literal_duplicate_key_side_effects: {
+    options = {
+        properties: true,
+        side_effects: true,
+    }
+    input: {
+        console.log({
+            a: "FAIL",
+            a: console.log ? "PASS" : "FAIL"
+        }.a);
+    }
+    expect: {
+        console.log(console.log ? "PASS" : "FAIL");
+    }
+    expect_stdout: "PASS"
+}
+
+prop_side_effects_1: {
+    options = {
+        evaluate: true,
+        inline: true,
+        properties: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var C = 1;
+        console.log(C);
+        var obj = {
+            bar: function() {
+                return C + C;
+            }
+        };
+        console.log(obj.bar());
+    }
+    expect: {
+        console.log(1);
+        var obj = {
+            bar: function() {
+                return 2;
+            }
+        };
+        console.log(obj.bar());
+    }
+    expect_stdout: [
+        "1",
+        "2",
+    ]
+}
+
+prop_side_effects_2: {
+    options = {
+        evaluate: true,
+        inline: true,
+        passes: 2,
+        properties: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var C = 1;
+        console.log(C);
+        var obj = {
+            "": function() {
+                return C + C;
+            }
+        };
+        console.log(obj[""]());
+    }
+    expect: {
+        console.log(1);
+        console.log(2);
+    }
+    expect_stdout: [
+        "1",
+        "2",
+    ]
+}
+
+accessor_1: {
+    options = {
+        properties: true,
+    }
+    input: {
+        console.log({
+            a: "FAIL",
+            get a() {
+                return "PASS";
+            }
+        }.a);
+    }
+    expect: {
+        console.log({
+            a: "FAIL",
+            get a() {
+                return "PASS";
+            }
+        }.a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+accessor_2: {
+    options = {
+        properties: true,
+    }
+    input: {
+        console.log({
+            get a() {
+                return "PASS";
+            },
+            set a(v) {},
+            a: "FAIL"
+        }.a);
+    }
+    expect: {
+        console.log({
+            get a() {
+                return "PASS";
+            },
+            set a(v) {},
+            a: "FAIL"
+        }.a);
+    }
+    expect_stdout: true
+}
+
+array_hole: {
+    options = {
+        properties: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(
+            [ 1, 2, , 3][1],
+            [ 1, 2, , 3][2],
+            [ 1, 2, , 3][3]
+        );
+    }
+    expect: {
+        console.log(2, void 0, 3);
+    }
+    expect_stdout: "2 undefined 3"
+}
+
+computed_property: {
+    options = {
+        properties: true,
+        side_effects: true,
+    }
+    input: {
+        console.log({
+            a: "bar",
+            [console.log("foo")]: 42,
+        }.a);
+    }
+    expect: {
+        console.log([
+            "bar",
+            console.log("foo")
+        ][0]);
+    }
+    expect_stdout: [
+        "foo",
+        "bar"
+    ]
+    node_version: ">=4"
+}
+
+new_this: {
+    options = {
+        properties: true,
+        side_effects: true,
+    }
+    input: {
+        new {
+            f: function(a) {
+                this.a = a;
+            }
+        }.f(42);
+    }
+    expect: {
+        new function(a) {
+            this.a = a;
+        }(42);
+    }
+}

test/compress/template-string.js

@@ -59,7 +59,7 @@ template_string_with_constant_expression: {
         var foo = `${4 + 4} equals 4 + 4`;
     }
     expect: {
-        var foo = `8 equals 4 + 4`;
+        var foo = "8 equals 4 + 4";
     }
 }
 
@@ -89,21 +89,21 @@ template_string_with_predefined_constants: {
         var c = `${4**14}`; // 8 in template vs 9 chars - 268435456
     }
     expect: {
-        var foo = `This is undefined`;
-        var bar = `This is NaN`;
-        var baz = `This is null`;
+        var foo = "This is undefined";
+        var bar = "This is NaN";
+        var baz = "This is null";
         var foofoo = `This is ${1/0}`;
         var foobar = "This is ${1/0}";
         var foobaz = 'This is ${1/0}';
         var barfoo = "This is ${NaN}";
         var bazfoo = "This is ${null}";
         var bazbaz = `This is ${1/0}`;
-        var barbar = `This is NaN`;
+        var barbar = "This is NaN";
         var barbar = "This is ${0/0}";
         var barber = 'This is ${0/0}';
 
-        var a = `4194304`;
-        var b = `16777216`; // Potential for further concatentation
+        var a = "4194304";
+        var b = "16777216"; // Potential for further concatentation
         var c = `${4**14}`; // Not worth converting
     }
 }
@@ -123,7 +123,7 @@ template_string_evaluate_with_many_segments: {
     }
     expect: {
         var foo = `Hello ${guest()}, welcome to ${location()}.`;
-        var bar = `1234567890`;
+        var bar = "1234567890";
         var baz = `${foobar()}${foobar()}${foobar()}${foobar()}`;
         var buzz = `1${foobar()}2${foobar()}3${foobar()}`;
     }
@@ -159,7 +159,7 @@ template_string_to_normal_string: {
         var bar = "Decimals " + `${1}${2}${3}${4}${5}${6}${7}${8}${9}${0}`;
     }
     expect: {
-        var foo = `This is undefined`;
+        var foo = "This is undefined";
         var bar = "Decimals 1234567890";
     }
 }
@@ -192,7 +192,7 @@ evaluate_nested_templates: {
         var baz = `${`${`${`foo`}`}`}`;
     }
     expect: {
-        var baz = `foo`;
+        var baz = "foo";
     }
 }
 
@@ -241,8 +241,8 @@ enforce_double_quotes_and_evaluate: {
         var baz = `Hello ${world()}`;
     }
     expect: {
-        var foo = `Hello world`;
-        var bar = `Hello world`;
+        var foo = "Hello world";
+        var bar = "Hello world";
         var baz = `Hello ${world()}`;
     }
 }
@@ -260,8 +260,8 @@ enforce_single_quotes_and_evaluate: {
         var baz = `Hello ${world()}`;
     }
     expect: {
-        var foo = `Hello world`;
-        var bar = `Hello world`;
+        var foo = "Hello world";
+        var bar = "Hello world";
         var baz = `Hello ${world()}`;
     }
 }
@@ -339,7 +339,7 @@ escape_dollar_curly: {
         console.log(`${1-0}\${2-0}$\{3-0}${4-0}`)
         console.log(`$${""}{not an expression}`)
     }
-    expect_exact: "console.log(`\\${ beep }`);console.log(`1\\${2-0}\\${3-0}4`);console.log(`\\${not an expression}`);"
+    expect_exact: 'console.log("${ beep }");console.log("1${2-0}${3-0}4");console.log("${not an expression}");'
 }
 
 template_starting_with_newline: {
@@ -400,3 +400,61 @@ issue_1856_ascii_only: {
     }
     expect_exact: "console.log(`\\\\n\\\\r\\\\u2028\\\\u2029\\n\\r\\u2028\\u2029`);"
 }
+
+side_effects: {
+    options = {
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        `t1`;
+        tag`t2`;
+        `t${3}`;
+        tag`t${4}`;
+        console.log(`
+t${5}`);
+        function f(a) {
+            `t6${a}`;
+            a = `t7${a}` & a;
+            a = `t8${b}` | a;
+            a = f`t9${a}` ^ a;
+        }
+    }
+    expect: {
+        tag`t2`;
+        tag`t${4}`;
+        console.log("\nt5");
+        function f(a) {
+            a &= `t7${a}`;
+            a = `t8${b}` | a;
+            a = f`t9${a}` ^ a;
+        }
+    }
+}
+
+simple_string: {
+    options = {
+        computed_props: true,
+        evaluate: true,
+        properties: true,
+    }
+    input: {
+        console.log({[`foo`]: 1}[`foo`], `hi` == "hi", `world`);
+    }
+    expect: {
+        console.log([ 1 ][0], true, "world");
+    }
+    expect_stdout: "1 true 'world'"
+    node_version: ">=4"
+}
+
+semicolons: {
+    beautify = {
+        semicolons: false,
+    }
+    input: {
+        foo;
+        `bar`;
+    }
+    expect_exact: "foo;`bar`\n"
+}

test/mocha/export.js

@@ -1,7 +1,7 @@
 var assert = require("assert");
 var uglify = require("../node");
 
-describe("Export", function() {
+describe("Export/Import", function() {
     it("Should parse export directives", function() {
         var inputs = [
             ['export * from "a.js"', ['*'], "a.js"],
@@ -36,4 +36,22 @@ describe("Export", function() {
             assert.equal(st.module_name.value, filename);
         }
     });
+
+    it("Should not parse invalid uses of export", function() {
+        assert.equal(uglify.minify("export").error.message, "Unexpected token: eof (undefined)");
+        assert.equal(uglify.minify("export;").error.message, "Unexpected token: punc (;)");
+        assert.equal(uglify.minify("export();").error.message, "Unexpected token: keyword (export)");
+        assert.equal(uglify.minify("export(1);").error.message, "Unexpected token: keyword (export)");
+        assert.equal(uglify.minify("var export;").error.message, "Name expected");
+        assert.equal(uglify.minify("var export = 1;").error.message, "Name expected");
+        assert.equal(uglify.minify("function f(export){}").error.message, "Invalid function parameter");
+    });
+
+    it("Should not parse invalid uses of import", function() {
+        assert.equal(uglify.minify("import").error.message, "Unexpected token: eof (undefined)");
+        assert.equal(uglify.minify("import;").error.message, "Unexpected token: punc (;)");
+        assert.equal(uglify.minify("var import;").error.message, "Unexpected token: import");
+        assert.equal(uglify.minify("var import = 1;").error.message, "Unexpected token: import");
+        assert.equal(uglify.minify("function f(import){}").error.message, "Unexpected token: name (import)");
+    });
 });

test/mocha/minify.js

@@ -73,6 +73,13 @@ describe("minify", function() {
         assert.strictEqual(run_code(compressed), run_code(original));
     });
 
+    it("should not parse invalid use of reserved words", function() {
+        assert.strictEqual(Uglify.minify("function enum(){}").error, undefined);
+        assert.strictEqual(Uglify.minify("function static(){}").error, undefined);
+        assert.strictEqual(Uglify.minify("function super(){}").error.message, "Unexpected token: name (super)");
+        assert.strictEqual(Uglify.minify("function this(){}").error.message, "Unexpected token: name (this)");
+    });
+
     describe("keep_quoted_props", function() {
         it("Should preserve quotes in object literals", function() {
             var js = 'var foo = {"x": 1, y: 2, \'z\': 3};';

test/mocha/yield.js

@@ -102,4 +102,15 @@ describe("Yield", function() {
             assert.throws(test(tests[i]), fail, tests[i]);
         }
     });
+
+    it("Should allow yield to be used as class/object property name", function() {
+        var input = [
+            '"use strict";',
+            "({yield:42});",
+            "({yield(){}});",
+            "(class{yield(){}});",
+            "class C{yield(){}}",
+        ].join("");
+        assert.strictEqual(UglifyJS.minify(input, { compress: false }).code, input);
+    });
 });

test/ufuzz.js

@@ -162,6 +162,7 @@ var VALUES = [
     '"object"',
     '"number"',
     '"function"',
+    'this',
 ];
 
 var BINARY_OPS_NO_COMMA = [
@@ -349,10 +350,10 @@ function createParams() {
     return params.join(', ');
 }
 
-function createArgs() {
+function createArgs(recurmax, stmtDepth, canThrow) {
     var args = [];
     for (var n = rng(4); --n >= 0;) {
-        args.push(createValue());
+        args.push(rng(2) ? createValue() : createExpression(recurmax - 1, COMMA_OK, stmtDepth, canThrow));
     }
     return args.join(', ');
 }
@@ -390,9 +391,10 @@ function createFunction(recurmax, inGlobal, noDecl, canThrow, stmtDepth) {
 
     VAR_NAMES.length = namesLenBefore;
 
-    if (noDecl) s = 'var ' + createVarName(MANDATORY) + ' = ' + s + '(' + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + ');';
+    if (noDecl) s = 'var ' + createVarName(MANDATORY) + ' = ' + s;
     // avoid "function statements" (decl inside statements)
-    else if (inGlobal || rng(10) > 0) s += 'var ' + createVarName(MANDATORY) + ' = ' + name + '(' + createArgs() + ');';
+    else if (inGlobal || rng(10) > 0) s += 'var ' + createVarName(MANDATORY) + ' = ' + name;
+    s += '(' + createArgs(recurmax, stmtDepth, canThrow) + ');';
 
     return s;
 }
@@ -626,6 +628,9 @@ function _createExpression(recurmax, noComma, stmtDepth, canThrow) {
       case p++:
       case p++:
         return createValue();
+      case p++:
+      case p++:
+        return getVarName();
       case p++:
         return createExpression(recurmax, COMMA_OK, stmtDepth, canThrow);
       case p++:

test/ufuzz.json

@@ -16,11 +16,9 @@
     {},
     {
         "compress": {
-            "toplevel": true
+            "hoist_props": true
         },
-        "mangle": {
-            "toplevel": true
-        }
+        "toplevel": true
     },
     {
         "compress": {