ensure let, const, class, have braces in if, for, while statements. closes #917

fabiosantoscode · fabiosantoscode · commit c14d5120ebd3 · 2023-01-27T11:13:50.000Z
diff --git a/lib/compress/common.js b/lib/compress/common.js
@@ -241,9 +241,10 @@ export function is_func_expr(node) {
     return node instanceof AST_Arrow || node instanceof AST_Function;
 }
 
+/**
+ * Used to determine whether the node can benefit from negation.
+ * Not the case with arrow functions (you need an extra set of parens). */
 export function is_iife_call(node) {
-    // Used to determine whether the node can benefit from negation.
-    // Not the case with arrow functions (you need an extra set of parens).
     if (node.TYPE != "Call") return false;
     return node.expression instanceof AST_Function || is_iife_call(node.expression);
 }
diff --git a/lib/output.js b/lib/output.js
@@ -1225,7 +1225,7 @@ function OutputStream(options) {
     }
 
     AST_StatementWithBody.DEFMETHOD("_do_print_body", function(output) {
-        force_statement(this.body, output);
+        print_maybe_braced_body(this.body, output);
     });
 
     DEFPRINT(AST_Statement, function(self, output) {
@@ -1554,7 +1554,7 @@ function OutputStream(options) {
                 b = b.body;
             } else break;
         }
-        force_statement(self.body, output);
+        print_maybe_braced_body(self.body, output);
     }
     DEFPRINT(AST_If, function(self, output) {
         output.print("if");
@@ -1571,7 +1571,7 @@ function OutputStream(options) {
             if (self.alternative instanceof AST_If)
                 self.alternative.print(output);
             else
-                force_statement(self.alternative, output);
+                print_maybe_braced_body(self.alternative, output);
         } else {
             self._do_print_body(output);
         }
@@ -2266,12 +2266,15 @@ function OutputStream(options) {
         }
     });
 
-    function force_statement(stat, output) {
+    /** if, for, while, may or may not have braces surrounding its body */
+    function print_maybe_braced_body(stat, output) {
         if (output.option("braces")) {
             make_block(stat, output);
         } else {
             if (!stat || stat instanceof AST_EmptyStatement)
                 output.force_semicolon();
+            else if (stat instanceof AST_Let || stat instanceof AST_Const || stat instanceof AST_Class)
+                make_block(stat, output);
             else
                 stat.print(output);
         }
diff --git a/lib/parse.js b/lib/parse.js
@@ -2089,14 +2089,20 @@ function parse($TEXT, options) {
         });
     }
 
+    /**
+     * var
+     *   vardef1 = 2,
+     *   vardef2 = 3;
+     */
     function vardefs(no_in, kind) {
-        var a = [];
+        var var_defs = [];
         var def;
         for (;;) {
             var sym_type =
                 kind === "var" ? AST_SymbolVar :
                 kind === "const" ? AST_SymbolConst :
                 kind === "let" ? AST_SymbolLet : null;
+            // var { a } = b
             if (is("punc", "{") || is("punc", "[")) {
                 def = new AST_VarDef({
                     start: S.token,
@@ -2116,12 +2122,12 @@ function parse($TEXT, options) {
                 });
                 if (def.name.name == "import") croak("Unexpected token: import");
             }
-            a.push(def);
+            var_defs.push(def);
             if (!is("punc", ","))
                 break;
             next();
         }
-        return a;
+        return var_defs;
     }
 
     var var_ = function(no_in) {

Original file line number	Diff line number	Diff line change
`@@ -241,9 +241,10 @@ export function is_func_expr(node) {`
`241`	`241`	`return node instanceof AST_Arrow \|\| node instanceof AST_Function;`
`242`	`242`	`}`
`243`	`243`
	`244`	`+/**`
	`245`	`+ * Used to determine whether the node can benefit from negation.`
	`246`	`+ * Not the case with arrow functions (you need an extra set of parens). */`
`244`	`247`	`export function is_iife_call(node) {`
`245`		`- // Used to determine whether the node can benefit from negation.`
`246`		`- // Not the case with arrow functions (you need an extra set of parens).`
`247`	`248`	`if (node.TYPE != "Call") return false;`
`248`	`249`	`return node.expression instanceof AST_Function \|\| is_iife_call(node.expression);`
`249`	`250`	`}`