terser 5.18.0 → 5.18.2

package/CHANGELOG.md

@@ -1,6 +1,12 @@
 # Changelog
 
-## v7.18.0
+## v5.18.2
+ - Stop using recursion in hoisted defuns fix.
+
+## v5.18.1
+ - Fix major performance issue caused by hoisted defuns' scopes bugfix.
+
+## v5.18.0
  - Add new `/*@__MANGLE_PROP__*/` annotation, to mark properties that should be mangled.
 
 ## v5.17.7

package/README.md

@@ -52,7 +52,9 @@ From NPM for programmatic use:
 
 <!-- CLI_USAGE:START -->
 
-    terser [input files] [options]
+```
+terser [input files] [options]
+```
 
 Terser can take multiple input files.  It's recommended that you pass the
 input files first, then pass the options.  Terser will parse input files
@@ -674,6 +676,10 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
 
 If you happen to need the source map as a raw object, set `sourceMap.asObject` to `true`.
 
+<!-- API_REFERENCE:END -->
+
+<!-- OPTIONS:START -->
+
 ## Parse options
 
 - `bare_returns` (default `false`) -- support top level `return` statements
@@ -1062,8 +1068,14 @@ as "output options".
   function expressions that are passed as arguments, in parenthesis. See
   [OptimizeJS](https://github.com/nolanlawson/optimize-js) for more details.
 
+
+<!-- OPTIONS:END -->
+
+
 # Miscellaneous
 
+<!-- MISCELLANEOUS:START -->
+
 ### Keeping copyright notices or other comments
 
 You can pass `--comments` to retain certain comments in the output.  By
@@ -1328,19 +1340,27 @@ $ rm -rf node_modules yarn.lock
 $ yarn
 ```
 
-<!-- API_REFERENCE:END -->
+<!-- MISCELLANEOUS:END -->
 
 # Reporting issues
 
-In the terser CLI we use [source-map-support](https://npmjs.com/source-map-support) to produce good error stacks. In your own app, you're expected to enable source-map-support (read their docs) to have nice stack traces that will help you write good issues.
+<!-- REPORTING_ISSUES:START -->
+
+## A minimal, reproducible example
+
+You're expected to provide a [minimal reproducible example] of input code that will demonstrate your issue.
+
+To get to this example, you can remove bits of your code and stop if your issue ceases to reproduce.
 
 ## Obtaining the source code given to Terser
 
-Because users often don't control the call to `await minify()` or its arguments, Terser provides a `TERSER_DEBUG_DIR` environment variable to make terser output some debug logs. If you're using a bundler or a project that includes a bundler and are not sure what went wrong with your code, pass that variable like so:
+Because users often don't control the call to `await minify()` or its arguments, Terser provides a `TERSER_DEBUG_DIR` environment variable to make terser output some debug logs.
 
-```
-$ TERSER_DEBUG_DIR=/path/to/logs command-that-uses-terser
-$ ls /path/to/logs
+These logs will contain the input code and options of each `minify()` call.
+
+```bash
+TERSER_DEBUG_DIR=/tmp/terser-log-dir command-that-uses-terser
+ls /tmp/terser-log-dir
 terser-debug-123456.log
 ```
 
@@ -1350,6 +1370,12 @@ If you're not sure how to set an environment variable on your shell (the above e
 > npx cross-env TERSER_DEBUG_DIR=/path/to/logs command-that-uses-terser
 ```
 
+## Stack traces
+
+In the terser CLI we use [source-map-support](https://npmjs.com/source-map-support) to produce good error stacks. In your own app, you're expected to enable source-map-support (read their docs) to have nice stack traces that will help you write good issues.
+
+<!-- REPORTING_ISSUES:END -->
+
 # README.md Patrons:
 
 *note*: <s>You can support this project on patreon: [link]</s> **The Terser Patreon is shutting down in favor of opencollective**. Check out [PATRONS.md](https://github.com/terser/terser/blob/master/PATRONS.md) for our first-tier patrons.

package/dist/bundle.min.js

@@ -15934,6 +15934,10 @@ function handle_defined_after_hoist(parent) {
         ) return true;
     });
 
+    const symbols_of_interest = new Set();
+    const defuns_of_interest = new Set();
+    const potential_conflicts = [];
+
     for (const defun of defuns) {
         const fname_def = defun.name.definition();
         const found_self_ref_in_other_defuns = defuns.some(
@@ -15963,35 +15967,79 @@ function handle_defined_after_hoist(parent) {
                 continue;
             }
 
-            // Detect `call_defun(); var used_in_defun = X`
-            // Because `used_in_defun` is not certainly X when it's defined after.
-            let found_defun_ref = false;
-            let found_def_after_defun = false;
-            walk_parent(parent, (node, info) => {
-                if (node === defun) return true;
+            // for the slower checks below this loop
+            potential_conflicts.push({ defun, def, fname_def });
+            symbols_of_interest.add(def.id);
+            symbols_of_interest.add(fname_def.id);
+            defuns_of_interest.add(defun);
+        }
+    }
 
-                // Step 1: find `call_defun()` or other refs to the defun
-                if (
-                    !found_defun_ref
-                    && node.thedef === fname_def
-                    && node instanceof AST_Symbol
-                ) {
-                    found_defun_ref = true;
+    // linearize all symbols, and locate defs that are read after the defun
+    if (potential_conflicts.length) {
+        // All "symbols of interest", that is, defuns or defs, that we found.
+        // These are placed in order so we can check which is after which.
+        const found_symbols = [];
+        // Indices of `found_symbols` which are writes
+        const found_symbol_writes = new Set();
+        // Defun ranges are recorded because we don't care if a function uses the def internally
+        const defun_ranges = new Map();
+
+        let tw;
+        parent.walk((tw = new TreeWalker((node, descend) => {
+            if (node instanceof AST_Defun && defuns_of_interest.has(node)) {
+                const start = found_symbols.length;
+                descend();
+                const end = found_symbols.length;
+
+                defun_ranges.set(node, { start, end });
+                return true;
+            }
+            // if we found a defun on the list, mark IN_DEFUN=id and descend
+
+            if (node instanceof AST_Symbol && node.thedef) {
+                const id = node.definition().id;
+                if (symbols_of_interest.has(id)) {
+                    if (node instanceof AST_SymbolDeclaration || is_lhs(node, tw)) {
+                        found_symbol_writes.add(found_symbols.length);
+                    }
+                    found_symbols.push(id);
                 }
+            }
+        })));
 
-                // Step 2: if Step 1 occurred, find a var the defun uses
-                if (
-                    found_defun_ref
-                    && node.thedef === def
-                    && (node instanceof AST_SymbolDeclaration
-                        || is_lhs(node, info))
-                ) {
-                    found_def_after_defun = true;
-                    return walk_abort;
+        for (const { def, defun, fname_def } of potential_conflicts) {
+            const defun_range = defun_ranges.get(defun);
+
+            // find the index in `found_symbols`, with some special rules:
+            const find = (sym_id, starting_at = 0, must_be_write = false) => {
+                let index = starting_at;
+
+                for (;;) {
+                    index = found_symbols.indexOf(sym_id, index);
+
+                    if (index === -1) {
+                        break;
+                    } else if (index >= defun_range.start && index < defun_range.end) {
+                        index = defun_range.end;
+                        continue;
+                    } else if (must_be_write && !found_symbol_writes.has(index)) {
+                        index++;
+                        continue;
+                    } else {
+                        break;
+                    }
                 }
-            });
 
-            if (found_def_after_defun) {
+                return index;
+            };
+
+            const read_defun_at = find(fname_def.id);
+            const wrote_def_at = find(def.id, read_defun_at + 1, true);
+
+            const wrote_def_after_reading_defun = read_defun_at != -1 && wrote_def_at != -1 && wrote_def_at > read_defun_at;
+
+            if (wrote_def_after_reading_defun) {
                 def.fixed = false;
             }
         }

package/lib/compress/reduce-vars.js

@@ -93,10 +93,10 @@ import {
     AST_Yield,
 
     walk,
-    walk_parent,
-    walk_abort,
     walk_body,
 
+    TreeWalker,
+
     _INLINE,
     _NOINLINE,
     _PURE
@@ -513,6 +513,10 @@ function handle_defined_after_hoist(parent) {
         ) return true;
     });
 
+    const symbols_of_interest = new Set();
+    const defuns_of_interest = new Set();
+    const potential_conflicts = [];
+
     for (const defun of defuns) {
         const fname_def = defun.name.definition();
         const found_self_ref_in_other_defuns = defuns.some(
@@ -542,35 +546,79 @@ function handle_defined_after_hoist(parent) {
                 continue;
             }
 
-            // Detect `call_defun(); var used_in_defun = X`
-            // Because `used_in_defun` is not certainly X when it's defined after.
-            let found_defun_ref = false;
-            let found_def_after_defun = false;
-            walk_parent(parent, (node, info) => {
-                if (node === defun) return true;
-
-                // Step 1: find `call_defun()` or other refs to the defun
-                if (
-                    !found_defun_ref
-                    && node.thedef === fname_def
-                    && node instanceof AST_Symbol
-                ) {
-                    found_defun_ref = true;
-                }
+            // for the slower checks below this loop
+            potential_conflicts.push({ defun, def, fname_def });
+            symbols_of_interest.add(def.id);
+            symbols_of_interest.add(fname_def.id);
+            defuns_of_interest.add(defun);
+        }
+    }
 
-                // Step 2: if Step 1 occurred, find a var the defun uses
-                if (
-                    found_defun_ref
-                    && node.thedef === def
-                    && (node instanceof AST_SymbolDeclaration
-                        || is_lhs(node, info))
-                ) {
-                    found_def_after_defun = true;
-                    return walk_abort;
+    // linearize all symbols, and locate defs that are read after the defun
+    if (potential_conflicts.length) {
+        // All "symbols of interest", that is, defuns or defs, that we found.
+        // These are placed in order so we can check which is after which.
+        const found_symbols = [];
+        // Indices of `found_symbols` which are writes
+        const found_symbol_writes = new Set();
+        // Defun ranges are recorded because we don't care if a function uses the def internally
+        const defun_ranges = new Map();
+
+        let tw;
+        parent.walk((tw = new TreeWalker((node, descend) => {
+            if (node instanceof AST_Defun && defuns_of_interest.has(node)) {
+                const start = found_symbols.length;
+                descend();
+                const end = found_symbols.length;
+
+                defun_ranges.set(node, { start, end });
+                return true;
+            }
+            // if we found a defun on the list, mark IN_DEFUN=id and descend
+
+            if (node instanceof AST_Symbol && node.thedef) {
+                const id = node.definition().id;
+                if (symbols_of_interest.has(id)) {
+                    if (node instanceof AST_SymbolDeclaration || is_lhs(node, tw)) {
+                        found_symbol_writes.add(found_symbols.length);
+                    }
+                    found_symbols.push(id);
                 }
-            });
+            }
+        })));
+
+        for (const { def, defun, fname_def } of potential_conflicts) {
+            const defun_range = defun_ranges.get(defun);
+
+            // find the index in `found_symbols`, with some special rules:
+            const find = (sym_id, starting_at = 0, must_be_write = false) => {
+                let index = starting_at;
+
+                for (;;) {
+                    index = found_symbols.indexOf(sym_id, index);
+
+                    if (index === -1) {
+                        break;
+                    } else if (index >= defun_range.start && index < defun_range.end) {
+                        index = defun_range.end;
+                        continue;
+                    } else if (must_be_write && !found_symbol_writes.has(index)) {
+                        index++;
+                        continue;
+                    } else {
+                        break;
+                    }
+                }
+
+                return index;
+            };
+
+            const read_defun_at = find(fname_def.id);
+            const wrote_def_at = find(def.id, read_defun_at + 1, true);
+
+            const wrote_def_after_reading_defun = read_defun_at != -1 && wrote_def_at != -1 && wrote_def_at > read_defun_at;
 
-            if (found_def_after_defun) {
+            if (wrote_def_after_reading_defun) {
                 def.fixed = false;
             }
         }

package/package.json

@@ -4,7 +4,7 @@
   "homepage": "https://terser.org",
   "author": "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)",
   "license": "BSD-2-Clause",
-  "version": "5.18.0",
+  "version": "5.18.2",
   "engines": {
     "node": ">=10"
   },