refactor: cf scope

crates/tree_shaker/src/analyzer.rs

@@ -15,12 +15,12 @@ use crate::{
 use line_index::LineIndex;
 use oxc::{
   allocator::Allocator,
-  ast::ast::{LabeledStatement, Program},
+  ast::ast::Program,
   semantic::{Semantic, SymbolId},
   span::{GetSpan, Span},
 };
 use rustc_hash::FxHashSet;
-use std::{mem, rc::Rc};
+use std::mem;
 
 pub struct Analyzer<'a> {
   pub tree_shaker: TreeShaker<'a>,
@@ -38,7 +38,6 @@ pub struct Analyzer<'a> {
   pub named_exports: Vec<SymbolId>,
   pub default_export: Option<Entity<'a>>,
   pub scope_context: ScopeContext<'a>,
-  pub pending_labels: Vec<&'a LabeledStatement<'a>>,
   pub pending_deps: FxHashSet<ExhaustiveCallback<'a>>,
   pub builtins: Builtins<'a>,
   pub entity_op: EntityOpHost<'a>,
@@ -68,7 +67,6 @@ impl<'a> Analyzer<'a> {
       named_exports: Vec::new(),
       default_export: None,
       scope_context: ScopeContext::new(factory),
-      pending_labels: Vec::new(),
       pending_deps: Default::default(),
       builtins: Builtins::new(config, factory),
       entity_op: EntityOpHost::new(allocator),
@@ -152,15 +150,6 @@ impl<'a> Analyzer<'a> {
     self.get_data_or_insert_with(key, Default::default)
   }
 
-  #[allow(clippy::rc_buffer)]
-  pub fn take_labels(&mut self) -> Option<Rc<Vec<&'a LabeledStatement<'a>>>> {
-    if self.pending_labels.is_empty() {
-      None
-    } else {
-      Some(Rc::new(mem::take(&mut self.pending_labels)))
-    }
-  }
-
   pub fn current_span(&self) -> Span {
     *self.span_stack.last().unwrap()
   }

crates/tree_shaker/src/builtins/react/dependencies.rs

@@ -2,6 +2,7 @@ use crate::{
   analyzer::Analyzer,
   consumable::{Consumable, ConsumableCollector},
   entity::Entity,
+  scope::CfScopeKind,
 };
 use oxc::span::Span;
 use rustc_hash::FxHashMap;
@@ -114,10 +115,10 @@ pub fn check_dependencies<'a>(
 
   if require_rerun {
     for depth in 0..analyzer.scope_context.cf.stack.len() {
-      if let Some(exhaustive_data) =
-        &mut analyzer.scope_context.cf.get_mut_from_depth(depth).exhaustive_data
+      if let CfScopeKind::Exhaustive(exhaustive_data) =
+        &mut analyzer.scope_context.cf.get_mut_from_depth(depth).kind
       {
-        exhaustive_data.dirty = true;
+        exhaustive_data.clean = false;
         break;
       }
     }

crates/tree_shaker/src/entity/object/enumerate.rs

@@ -18,7 +18,7 @@ impl<'a> ObjectEntity<'a> {
     }
 
     analyzer.mark_object_property_exhaustive_read(self.cf_scope, self.object_id);
-    analyzer.push_cf_scope_with_deps(CfScopeKind::Dependent, None, vec![dep], None);
+    analyzer.push_cf_scope_with_deps(CfScopeKind::Dependent, vec![dep], None);
 
     let mut result = vec![];
     let mut non_existent = vec![];

crates/tree_shaker/src/entity/object/get.rs

@@ -96,7 +96,6 @@ impl<'a> ObjectEntity<'a> {
     if !getters.is_empty() {
       analyzer.push_cf_scope_with_deps(
         CfScopeKind::Dependent,
-        None,
         vec![if mangable { dep } else { analyzer.consumable((dep, key)) }],
         if indeterminate_getter { None } else { Some(false) },
       );

crates/tree_shaker/src/entity/object/set.rs

@@ -116,7 +116,6 @@ impl<'a> ObjectEntity<'a> {
       let indeterminate = indeterminate || setters.len() > 1 || setters[0].0;
       analyzer.push_cf_scope_with_deps(
         CfScopeKind::Dependent,
-        None,
         vec![analyzer.consumable((dep, key))],
         if indeterminate { None } else { Some(false) },
       );

crates/tree_shaker/src/entity/union.rs

@@ -96,12 +96,7 @@ impl<'a, V: UnionLike<'a, Entity<'a>> + Debug + 'a> EntityTrait<'a> for UnionEnt
     this: Entity<'a>,
     args: Entity<'a>,
   ) -> Entity<'a> {
-    analyzer.push_cf_scope_with_deps(
-      CfScopeKind::Dependent,
-      None,
-      vec![analyzer.consumable(self)],
-      None,
-    );
+    analyzer.push_cf_scope_with_deps(CfScopeKind::Dependent, vec![analyzer.consumable(self)], None);
     let values = self.values.map(|v| v.call(analyzer, dep, this, args));
     analyzer.pop_cf_scope();
     analyzer.factory.union(values)

crates/tree_shaker/src/nodes/expr/conditional_expression.rs

@@ -17,7 +17,7 @@ impl<'a> Analyzer<'a> {
     let exec_consequent = move |analyzer: &mut Analyzer<'a>| {
       let conditional_dep = analyzer.push_if_like_branch_cf_scope(
         AstKind2::ConditionalExpression(node),
-        CfScopeKind::ConditionalExprBranch,
+        CfScopeKind::Indeterminate,
         test,
         maybe_true,
         maybe_false,
@@ -32,7 +32,7 @@ impl<'a> Analyzer<'a> {
     let exec_alternate = move |analyzer: &mut Analyzer<'a>| {
       let conditional_dep = analyzer.push_if_like_branch_cf_scope(
         AstKind2::ConditionalExpression(node),
-        CfScopeKind::ConditionalExprBranch,
+        CfScopeKind::Indeterminate,
         test,
         maybe_true,
         maybe_false,

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

@@ -1,17 +1,11 @@
-use crate::{
-  analyzer::Analyzer, ast::AstKind2, scope::CfScopeKind, transformer::Transformer,
-  utils::StatementVecData,
-};
+use crate::{analyzer::Analyzer, ast::AstKind2, transformer::Transformer, utils::StatementVecData};
 use oxc::{allocator, ast::ast::BlockStatement};
 
 impl<'a> Analyzer<'a> {
   pub fn exec_block_statement(&mut self, node: &'a BlockStatement) {
-    let labels = self.take_labels();
     let data = self.load_data::<StatementVecData>(AstKind2::BlockStatement(node));
 
-    self.push_cf_scope(CfScopeKind::Block, labels, Some(false));
     self.exec_statement_vec(data, &node.body);
-    self.pop_cf_scope();
   }
 }
 

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

@@ -3,7 +3,7 @@ use oxc::ast::ast::{BreakStatement, Statement};
 
 impl<'a> Analyzer<'a> {
   pub fn exec_break_statement(&mut self, node: &'a BreakStatement<'a>) {
-    let label = node.label.as_ref().map(|label| label.name.as_str());
+    let label = node.label.as_ref().map(|label| &label.name);
     if self.break_to_label(label) {
       self.consume(AstKind2::BreakStatement(node));
     }

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

@@ -3,7 +3,7 @@ use oxc::ast::ast::{ContinueStatement, Statement};
 
 impl<'a> Analyzer<'a> {
   pub fn exec_continue_statement(&mut self, node: &'a ContinueStatement<'a>) {
-    let label = node.label.as_ref().map(|label| label.name.as_str());
+    let label = node.label.as_ref().map(|label| &label.name);
     if self.continue_to_label(label) {
       self.consume(AstKind2::ContinueStatement(node));
     }

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

@@ -14,13 +14,10 @@ pub struct Data {
 
 impl<'a> Analyzer<'a> {
   pub fn exec_do_while_statement(&mut self, node: &'a DoWhileStatement<'a>) {
-    let labels = self.take_labels();
-    self.push_cf_scope(CfScopeKind::BreakableWithoutLabel, labels.clone(), Some(false));
+    self.push_cf_scope(CfScopeKind::Loop, Some(false));
 
     // Execute the first round.
-    self.push_cf_scope(CfScopeKind::Continuable, labels.clone(), Some(false));
     self.exec_statement(&node.body);
-    self.pop_cf_scope();
 
     if self.cf_scope().must_exited() {
       self.pop_cf_scope();
@@ -41,7 +38,7 @@ impl<'a> Analyzer<'a> {
     data.need_loop = true;
 
     self.exec_loop(move |analyzer| {
-      analyzer.push_cf_scope(CfScopeKind::Continuable, labels.clone(), None);
+      analyzer.push_cf_scope(CfScopeKind::Loop, None);
 
       analyzer.exec_statement(&node.body);
       analyzer.exec_expression(&node.test).consume(analyzer);

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

@@ -9,7 +9,6 @@ use oxc::{
 
 impl<'a> Analyzer<'a> {
   pub fn exec_for_in_statement(&mut self, node: &'a ForInStatement<'a>) {
-    let labels = self.take_labels();
     let right = self.exec_expression(&node.right);
 
     // FIXME: enumerate keys!
@@ -32,17 +31,12 @@ impl<'a> Analyzer<'a> {
 
     let dep = self.consumable((AstKind2::ForInStatement(node), right));
 
-    self.push_cf_scope_with_deps(
-      CfScopeKind::BreakableWithoutLabel,
-      labels.clone(),
-      vec![dep],
-      Some(false),
-    );
+    self.push_cf_scope_with_deps(CfScopeKind::Loop, vec![dep], Some(false));
     self.exec_loop(move |analyzer| {
       analyzer.declare_for_statement_left(&node.left);
       analyzer.init_for_statement_left(&node.left, analyzer.factory.unknown_string);
 
-      analyzer.push_cf_scope(CfScopeKind::Continuable, labels.clone(), None);
+      analyzer.push_cf_scope(CfScopeKind::Loop, None);
       analyzer.exec_statement(&node.body);
       analyzer.pop_cf_scope();
     });

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

@@ -6,8 +6,6 @@ use oxc::{
 
 impl<'a> Analyzer<'a> {
   pub fn exec_for_of_statement(&mut self, node: &'a ForOfStatement<'a>) {
-    let labels = self.take_labels();
-
     let right = self.exec_expression(&node.right);
     let right = if node.r#await {
       right.consume(self);
@@ -27,17 +25,12 @@ impl<'a> Analyzer<'a> {
 
     let dep = self.consumable((AstKind2::ForOfStatement(node), right));
 
-    self.push_cf_scope_with_deps(
-      CfScopeKind::BreakableWithoutLabel,
-      labels.clone(),
-      vec![dep],
-      Some(false),
-    );
+    self.push_cf_scope_with_deps(CfScopeKind::Loop, 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::Continuable, labels.clone(), None);
+      analyzer.push_cf_scope(CfScopeKind::Loop, None);
       analyzer.exec_statement(&node.body);
       analyzer.pop_cf_scope();
     });

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

@@ -6,8 +6,6 @@ use oxc::{
 
 impl<'a> Analyzer<'a> {
   pub fn exec_for_statement(&mut self, node: &'a ForStatement<'a>) {
-    let labels = self.take_labels();
-
     if let Some(init) = &node.init {
       match init {
         ForStatementInit::VariableDeclaration(node) => {
@@ -30,18 +28,13 @@ impl<'a> Analyzer<'a> {
       self.consumable(AstKind2::ForStatement(node))
     };
 
-    self.push_cf_scope_with_deps(
-      CfScopeKind::BreakableWithoutLabel,
-      labels.clone(),
-      vec![dep],
-      Some(false),
-    );
+    self.push_cf_scope_with_deps(CfScopeKind::Loop, vec![dep], Some(false));
     self.exec_loop(move |analyzer| {
       if analyzer.cf_scope().must_exited() {
         return;
       }
 
-      analyzer.push_cf_scope(CfScopeKind::Continuable, labels.clone(), None);
+      analyzer.push_cf_scope(CfScopeKind::Loop, None);
       analyzer.exec_statement(&node.body);
       if let Some(update) = &node.update {
         analyzer.exec_expression(update);

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

@@ -8,8 +8,6 @@ impl<'a> Analyzer<'a> {
   pub fn exec_if_statement(&mut self, node: &'a IfStatement) {
     let factory = self.factory;
 
-    let labels = self.take_labels();
-
     let test = self.exec_expression(&node.test).get_to_boolean(self);
 
     let (maybe_consequent, maybe_alternate) = match test.test_truthy() {
@@ -27,20 +25,18 @@ impl<'a> Analyzer<'a> {
     if maybe_consequent {
       self.push_if_like_branch_cf_scope(
         AstKind2::IfStatement(node),
-        CfScopeKind::IfBranch,
+        CfScopeKind::ExitBlocker(None),
         test,
         maybe_consequent,
         maybe_alternate,
         true,
         node.alternate.is_some(),
       );
-      self.push_cf_scope(CfScopeKind::Labeled, labels.clone(), Some(false));
       self.exec_statement(&node.consequent);
-      self.pop_cf_scope();
       let conditional_scope = self.pop_cf_scope_and_get_mut();
-      if let Some(stopped_exit) = conditional_scope.blocked_exit {
-        exit_target_inner = exit_target_inner.max(stopped_exit);
-        exit_target_outer = exit_target_outer.min(stopped_exit);
+      if let CfScopeKind::ExitBlocker(Some(stopped_exit)) = &conditional_scope.kind {
+        exit_target_inner = exit_target_inner.max(*stopped_exit);
+        exit_target_outer = exit_target_outer.min(*stopped_exit);
       } else {
         both_exit = false;
       }
@@ -49,21 +45,19 @@ impl<'a> Analyzer<'a> {
     if maybe_alternate {
       self.push_if_like_branch_cf_scope(
         AstKind2::IfStatement(node),
-        CfScopeKind::IfBranch,
+        CfScopeKind::ExitBlocker(None),
         test,
         maybe_consequent,
         maybe_alternate,
         false,
         true,
       );
       if let Some(alternate) = &node.alternate {
-        self.push_cf_scope(CfScopeKind::Labeled, labels.clone(), Some(false));
         self.exec_statement(alternate);
-        self.pop_cf_scope();
         let conditional_scope = self.pop_cf_scope_and_get_mut();
-        if let Some(stopped_exit) = conditional_scope.blocked_exit {
-          exit_target_inner = exit_target_inner.max(stopped_exit);
-          exit_target_outer = exit_target_outer.min(stopped_exit);
+        if let CfScopeKind::ExitBlocker(Some(stopped_exit)) = &conditional_scope.kind {
+          exit_target_inner = exit_target_inner.max(*stopped_exit);
+          exit_target_outer = exit_target_outer.min(*stopped_exit);
         } else {
           both_exit = false;
         }

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

@@ -1,4 +1,4 @@
-use crate::{analyzer::Analyzer, ast::AstKind2, transformer::Transformer};
+use crate::{analyzer::Analyzer, ast::AstKind2, scope::CfScopeKind, transformer::Transformer};
 use oxc::ast::ast::{LabeledStatement, Statement};
 
 impl<'a> Analyzer<'a> {
@@ -7,8 +7,9 @@ impl<'a> Analyzer<'a> {
   }
 
   pub fn exec_labeled_statement(&mut self, node: &'a LabeledStatement<'a>) {
-    self.pending_labels.push(node);
+    self.push_cf_scope(CfScopeKind::Labeled(node), Some(false));
     self.exec_statement(&node.body);
+    self.pop_cf_scope();
   }
 }
 

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

@@ -45,21 +45,6 @@ impl<'a> Analyzer<'a> {
 
   pub fn init_statement(&mut self, node: &'a Statement) {
     self.push_span(node);
-    if !matches!(
-      node,
-      Statement::BlockStatement(_)
-        | Statement::IfStatement(_)
-        | Statement::WhileStatement(_)
-        | Statement::DoWhileStatement(_)
-        | Statement::ForStatement(_)
-        | Statement::ForInStatement(_)
-        | Statement::ForOfStatement(_)
-        | Statement::SwitchStatement(_)
-        | Statement::LabeledStatement(_)
-        | Statement::TryStatement(_),
-    ) {
-      self.pending_labels.clear();
-    }
     match node {
       match_declaration!(Statement) => {
         let node = node.to_declaration();

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

@@ -16,7 +16,6 @@ pub struct Data {
 
 impl<'a> Analyzer<'a> {
   pub fn exec_switch_statement(&mut self, node: &'a SwitchStatement<'a>) {
-    let labels = self.take_labels();
     let data = self.load_data::<Data>(AstKind2::SwitchStatement(node));
 
     // 1. discriminant
@@ -77,7 +76,7 @@ impl<'a> Analyzer<'a> {
     }
 
     // 3. consequent
-    self.push_cf_scope(CfScopeKind::BreakableWithoutLabel, labels, Some(false));
+    self.push_cf_scope(CfScopeKind::Switch, Some(false));
     let mut entered = Some(false);
     for (index, case) in node.cases.iter().enumerate() {
       if self.cf_scope().must_exited() {