fix: loops

Author: kermanx

crates/tree_shaker/src/nodes/stmt/do_while_statement.rs

@@ -14,7 +14,7 @@ pub struct Data {
 
 impl<'a> Analyzer<'a> {
   pub fn exec_do_while_statement(&mut self, node: &'a DoWhileStatement<'a>) {
-    self.push_cf_scope(CfScopeKind::Loop, Some(false));
+    self.push_cf_scope(CfScopeKind::LoopBreak, Some(false));
 
     // Execute the first round.
     self.exec_statement(&node.body);
@@ -38,7 +38,7 @@ impl<'a> Analyzer<'a> {
     data.need_loop = true;
 
     self.exec_loop(move |analyzer| {
-      analyzer.push_cf_scope(CfScopeKind::Loop, None);
+      analyzer.push_cf_scope(CfScopeKind::LoopContinue, None);
 
       analyzer.exec_statement(&node.body);
       analyzer.exec_expression(&node.test).consume(analyzer);

crates/tree_shaker/src/nodes/stmt/for_in_statement.rs

@@ -11,10 +11,11 @@ impl<'a> Analyzer<'a> {
     if let Some(keys) = right.get_own_keys(self) {
       let dep =
         right.get_destructable(self, self.factory.consumable(AstKind2::ForInStatement(node)));
+      self.push_cf_scope_with_deps(CfScopeKind::LoopBreak, vec![dep], Some(false));
       for (definite, key) in keys {
         self.push_cf_scope_with_deps(
-          CfScopeKind::Loop,
-          vec![dep, self.factory.always_mangable_dep(key)],
+          CfScopeKind::LoopContinue,
+          vec![self.factory.always_mangable_dep(key)],
           if definite { Some(false) } else { None },
         );
         self.push_variable_scope();
@@ -26,11 +27,17 @@ impl<'a> Analyzer<'a> {
 
         self.pop_variable_scope();
         self.pop_cf_scope();
+
+        if self.cf_scope().must_exited() {
+          break;
+        }
       }
+      self.pop_cf_scope();
     } else {
       let dep = self.consumable((AstKind2::ForInStatement(node), right));
+      self.push_cf_scope_with_deps(CfScopeKind::LoopBreak, vec![dep], Some(false));
       self.exec_loop(move |analyzer| {
-        analyzer.push_cf_scope_with_deps(CfScopeKind::Loop, vec![dep], None);
+        analyzer.push_cf_scope_with_deps(CfScopeKind::LoopContinue, vec![], None);
         analyzer.push_variable_scope();
 
         analyzer.declare_for_statement_left(&node.left);
@@ -41,6 +48,7 @@ impl<'a> Analyzer<'a> {
         analyzer.pop_variable_scope();
         analyzer.pop_cf_scope();
       });
+      self.pop_cf_scope();
     }
   }
 }

crates/tree_shaker/src/nodes/stmt/for_of_statement.rs

@@ -25,12 +25,12 @@ impl<'a> Analyzer<'a> {
 
     let dep = self.consumable((AstKind2::ForOfStatement(node), right));
 
-    self.push_cf_scope_with_deps(CfScopeKind::Loop, vec![dep], Some(false));
+    self.push_cf_scope_with_deps(CfScopeKind::LoopBreak, vec![dep], Some(false));
     self.exec_loop(move |analyzer| {
       analyzer.declare_for_statement_left(&node.left);
       analyzer.init_for_statement_left(&node.left, iterated);
 
-      analyzer.push_cf_scope(CfScopeKind::Loop, None);
+      analyzer.push_cf_scope(CfScopeKind::LoopContinue, None);
       analyzer.exec_statement(&node.body);
       analyzer.pop_cf_scope();
     });

crates/tree_shaker/src/nodes/stmt/for_statement.rs

@@ -28,13 +28,13 @@ impl<'a> Analyzer<'a> {
       self.consumable(AstKind2::ForStatement(node))
     };
 
-    self.push_cf_scope_with_deps(CfScopeKind::Loop, vec![dep], Some(false));
+    self.push_cf_scope_with_deps(CfScopeKind::LoopBreak, vec![dep], Some(false));
     self.exec_loop(move |analyzer| {
       if analyzer.cf_scope().must_exited() {
         return;
       }
 
-      analyzer.push_cf_scope(CfScopeKind::Loop, None);
+      analyzer.push_cf_scope(CfScopeKind::LoopContinue, None);
       analyzer.exec_statement(&node.body);
       if let Some(update) = &node.update {
         analyzer.exec_expression(update);

crates/tree_shaker/src/nodes/stmt/while_statement.rs

@@ -17,9 +17,9 @@ impl<'a> Analyzer<'a> {
 
     let dep = self.consumable((AstKind2::WhileStatement(node), test));
 
-    self.push_cf_scope_with_deps(CfScopeKind::Loop, vec![dep], Some(false));
+    self.push_cf_scope_with_deps(CfScopeKind::LoopBreak, vec![dep], Some(false));
     self.exec_loop(move |analyzer| {
-      analyzer.push_cf_scope(CfScopeKind::Loop, None);
+      analyzer.push_cf_scope(CfScopeKind::LoopContinue, None);
 
       analyzer.exec_statement(&node.body);
       analyzer.exec_expression(&node.test).consume(analyzer);

crates/tree_shaker/src/scope/cf_scope.rs

@@ -26,7 +26,8 @@ pub enum CfScopeKind<'a> {
   Module,
   Labeled(&'a LabeledStatement<'a>),
   Function,
-  Loop,
+  LoopBreak,
+  LoopContinue,
   Switch,
 
   Dependent,
@@ -41,11 +42,11 @@ impl<'a> CfScopeKind<'a> {
   }
 
   pub fn is_breakable_without_label(&self) -> bool {
-    matches!(self, CfScopeKind::Loop | CfScopeKind::Switch)
+    matches!(self, CfScopeKind::LoopBreak | CfScopeKind::Switch)
   }
 
   pub fn is_continuable(&self) -> bool {
-    matches!(self, CfScopeKind::Loop)
+    matches!(self, CfScopeKind::LoopContinue)
   }
 
   pub fn matches_label(&self, label: &'a Atom<'a>) -> Option<&'a LabeledStatement<'a>> {