update

CppCXY · CppCXY · commit e9ca3b707d7a · 2025-06-10T20:45:25.000+08:00
diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/exprs/bind_call_expr.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/exprs/bind_call_expr.rs
@@ -1,6 +1,6 @@
 use emmylua_parser::{LuaAst, LuaCallExpr};
 
-use crate::compilation::analyzer::flow::{bind_analyze::bind_each_child, binder::FlowBinder, flow_node::{FlowId, FlowNodeType}};
+use crate::compilation::analyzer::flow::{bind_analyze::bind_each_child, binder::FlowBinder, flow_node::{FlowId, FlowNodeKind}};
 
 
 pub fn bind_call_expr(binder: &mut FlowBinder, call_expr: LuaCallExpr) -> Option<FlowId> {
diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/exprs/mod.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/exprs/mod.rs
@@ -6,7 +6,7 @@ use crate::{
     compilation::analyzer::flow::{
         bind_analyze::{bind_each_child, exprs::bind_call_expr::bind_call_expr},
         binder::FlowBinder,
-        flow_node::{FlowId, FlowNodeType, LuaFlowCondition},
+        flow_node::{FlowId, FlowNodeKind, FlowCondition},
     },
     LuaVarRefId,
 };
@@ -40,8 +40,8 @@ fn bind_name_expr(binder: &mut FlowBinder, name_expr: LuaNameExpr) -> Option<Flo
         None => LuaVarRefId::Name(name_text.into()),
     };
 
-    let flow_id = binder.create_node(FlowNodeType::Condition(
-        LuaFlowCondition::Exist(var_ref_id).into(),
+    let flow_id = binder.create_node(FlowNodeKind::Condition(
+        FlowCondition::Truthy(var_ref_id).into(),
     ));
 
     Some(flow_id)
diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/mod.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/mod.rs
@@ -5,7 +5,7 @@ mod stats;
 use emmylua_parser::{LuaAst, LuaAstNode, LuaBlock, LuaChunk};
 
 use crate::compilation::analyzer::flow::{
-    bind_analyze::{comment::bind_comment, stats::{bind_assign_stat, bind_call_expr_stat, bind_local_stat}},
+    bind_analyze::{comment::bind_comment, stats::{bind_assign_stat, bind_call_expr_stat, bind_do_stat, bind_goto_stat, bind_if_stat, bind_label_stat, bind_local_stat, bind_repeat_stat, bind_while_stat}},
     binder::FlowBinder,
 };
 
@@ -33,13 +33,13 @@ fn bind_node(binder: &mut FlowBinder, node: LuaAst) -> Option<()> {
         LuaAst::LuaAssignStat(assign_stat) => bind_assign_stat(binder, assign_stat),
         LuaAst::LuaLocalStat(local_stat) => bind_local_stat(binder, local_stat),
         LuaAst::LuaCallExprStat(call_expr_stat) => bind_call_expr_stat(binder, call_expr_stat),
-        LuaAst::LuaLabelStat(_) => Some(()),
+        LuaAst::LuaLabelStat(label_stat) => bind_label_stat(binder, label_stat),
         LuaAst::LuaBreakStat(break_stat) => todo!(),
-        LuaAst::LuaGotoStat(goto_stat) => todo!(),
-        LuaAst::LuaDoStat(do_stat) => todo!(),
-        LuaAst::LuaWhileStat(while_stat) => todo!(),
-        LuaAst::LuaRepeatStat(repeat_stat) => todo!(),
-        LuaAst::LuaIfStat(if_stat) => todo!(),
+        LuaAst::LuaGotoStat(goto_stat) => bind_goto_stat(binder, goto_stat),
+        LuaAst::LuaDoStat(do_stat) => bind_do_stat(binder, do_stat),
+        LuaAst::LuaWhileStat(while_stat) => bind_while_stat(binder, while_stat),
+        LuaAst::LuaRepeatStat(repeat_stat) => bind_repeat_stat(binder, repeat_stat),
+        LuaAst::LuaIfStat(if_stat) => bind_if_stat(binder, if_stat),
         LuaAst::LuaForStat(for_stat) => todo!(),
         LuaAst::LuaForRangeStat(for_range_stat) => todo!(),
         LuaAst::LuaFuncStat(func_stat) => todo!(),
diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/stats.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/stats.rs
@@ -1,14 +1,14 @@
 use emmylua_parser::{
-    LuaAssignStat, LuaAst, LuaAstNode, LuaCallExprStat, LuaLabelStat, LuaLocalStat, LuaVarExpr, PathTrait
+    LuaAssignStat, LuaAst, LuaAstNode, LuaBreakStat, LuaCallExprStat, LuaDoStat, LuaGotoStat, LuaIfStat, LuaLabelStat, LuaLocalStat, LuaRepeatStat, LuaVarExpr, LuaWhileStat, PathTrait
 };
 
 use crate::{
     compilation::analyzer::flow::{
-        bind_analyze::{bind_each_child, exprs::bind_condition_expr},
+        bind_analyze::{bind_block, bind_each_child, exprs::{bind_condition_expr, bind_expr}},
         binder::FlowBinder,
-        flow_node::{FlowNodeType, LuaFlowAssignment},
+        flow_node::{FlowAssignment, FlowNodeKind},
     },
-    LuaDeclId, LuaVarRefId,
+    LuaClosureId, LuaDeclId, LuaVarRefId,
 };
 
 pub fn bind_local_stat(binder: &mut FlowBinder, local_stat: LuaLocalStat) -> Option<()> {
@@ -53,16 +53,14 @@ pub fn bind_assign_stat(binder: &mut FlowBinder, assign_stat: LuaAssignStat) ->
 
         if let Some(var_ref_id) = get_var_ref_id(binder, var.clone()) {
             // Create a flow node for the assignment
-            let flow_id = binder.create_node(
-                FlowNodeType::Assignment(
-                    LuaFlowAssignment {
-                        var_ref_id,
-                        expr,
-                        idx: idx as u32,
-                    }
-                    .into(),
-                ),
-            );
+            let flow_id = binder.create_node(FlowNodeKind::Assignment(
+                FlowAssignment {
+                    var_ref_id,
+                    expr,
+                    idx: idx as u32,
+                }
+                .into(),
+            ));
 
             binder.add_antecedent(flow_id, binder.current);
             binder.current = flow_id;
@@ -114,8 +112,157 @@ pub fn bind_call_expr_stat(binder: &mut FlowBinder, call_expr_stat: LuaCallExprS
 pub fn bind_label_stat(binder: &mut FlowBinder, label_stat: LuaLabelStat) -> Option<()> {
     let label_name_token = label_stat.get_label_name_token()?;
     let label_name = label_name_token.get_name_text();
-    
+    let closure_id = LuaClosureId::from_node(label_stat.syntax());
+    let name_label = binder.create_name_label(label_name, closure_id);
+    binder.add_antecedent(name_label, binder.current);
+    binder.current = name_label;
+
+    Some(())
+}
+
+pub fn bind_break_stat(binder: &mut FlowBinder, break_stat: LuaBreakStat) -> Option<()> {
+    // let 
+    // binder.add_antecedent(loop_label, current);
+    // binder.current = loop_label;
+
+    Some(())
+}
+
+pub fn bind_goto_stat(binder: &mut FlowBinder, goto_stat: LuaGotoStat) -> Option<()> {
+    // Goto statements are handled separately in the flow analysis
+    // They will be processed when we analyze the labels
+    // For now, we just return None to indicate no flow node is created
+    let closure_id = LuaClosureId::from_node(goto_stat.syntax());
+    binder.add_goto_stat(goto_stat, closure_id);
+
+    Some(())
+}
+
+pub fn bind_do_stat(binder: &mut FlowBinder, do_stat: LuaDoStat) -> Option<()> {
+    // Do statements are typically used for blocks of code
+    // We can treat them as a block and bind their contents
+    bind_each_child(binder, LuaAst::cast(do_stat.syntax().clone())?);
+
+    Some(())
+}
+
+pub fn bind_while_stat(binder: &mut FlowBinder, while_stat: LuaWhileStat) -> Option<()> {
+    // While statements are typically used for loops
+    // We can treat them as a loop and bind their contents
+    // For now, we just return None to indicate no flow node is created
+    let current = binder.current;
+    let old_loop_label = binder.loop_label;
+    let loop_label = binder.create_loop_label();
+    binder.add_antecedent(loop_label, current);
+
+    binder.loop_label = loop_label;
+    binder.current = loop_label;
+    let condition_expr = while_stat.get_condition_expr()?;
+    if let Some(condition_flow_id) = bind_condition_expr(binder, condition_expr) {
+        binder.add_antecedent(condition_flow_id, loop_label);
+        binder.current = condition_flow_id;
+        binder.loop_label = loop_label;
+    } else {
+        binder.current = loop_label;
+        binder.loop_label = current;
+    }
 
+    if let Some(while_block) = while_stat.get_block() {
+        bind_block(binder, while_block);
+    }
+
+    binder.current = current;
+    binder.loop_label = old_loop_label;
 
+    Some(())
+}
+
+
+pub fn bind_repeat_stat(binder: &mut FlowBinder, repeat_stat: LuaRepeatStat) -> Option<()> {    
+    let current = binder.current;
+    let old_loop_label = binder.loop_label;
+    
+    // Create a loop label for the repeat statement
+    let loop_label = binder.create_loop_label();
+    binder.add_antecedent(loop_label, current);
+    
+    binder.loop_label = loop_label;
+    binder.current = loop_label;
+    
+    // Bind the block first (repeat-until executes the block at least once)
+    if let Some(repeat_block) = repeat_stat.get_block() {
+        bind_block(binder, repeat_block);
+    }
+    
+    let current = binder.current;
+    bind_expr(binder, repeat_stat.get_condition_expr()?);
+    
+    // Restore previous state
+    binder.current = current;
+    binder.loop_label = old_loop_label;
+    
+    Some(())
+}
+
+pub fn bind_if_stat(binder: &mut FlowBinder, if_stat: LuaIfStat) -> Option<()> {
+    // let current = binder.current;
+    // let mut branch_endings = Vec::new();
+    
+    // // Process the main if condition
+    // let condition = if_stat.get_condition_expr()?;
+    // if let Some(condition_flow_id) = bind_condition_expr(binder, condition) {
+    //     binder.add_antecedent(condition_flow_id, current);
+    //     binder.current = condition_flow_id;
+    // } else {
+    //     binder.current = current;
+    // }
+    
+    // // Process the if block (true branch)
+    // if let Some(if_block) = if_stat.get_block() {
+    //     bind_block(binder, if_block);
+    //     branch_endings.push(binder.current);
+    // }
+    
+    // // Process elseif clauses
+    // for elseif_clause in if_stat.get_else_if_clause_list() {
+    //     binder.current = current; // Reset to the beginning for each elseif
+        
+    //     if let Some(elseif_condition) = elseif_clause.get_condition_expr() {
+    //         if let Some(condition_flow_id) = bind_condition_expr(binder, elseif_condition) {
+    //             binder.add_antecedent(condition_flow_id, current);
+    //             binder.current = condition_flow_id;
+    //         }
+    //     }
+        
+    //     if let Some(elseif_block) = elseif_clause.get_block() {
+    //         bind_block(binder, elseif_block);
+    //         branch_endings.push(binder.current);
+    //     }
+    // }
+    
+    // // Process else clause if it exists
+    // if let Some(else_clause) = if_stat.get_else_clause() {
+    //     binder.current = current; // Reset to the beginning for else
+        
+    //     if let Some(else_block) = else_clause.get_block() {
+    //         bind_block(binder, else_block);
+    //         branch_endings.push(binder.current);
+    //     }
+    // } else {
+    //     // If there's no else clause, the original flow continues
+    //     branch_endings.push(current);
+    // }
+    
+    // // Create a branch label to merge all branches
+    // if !branch_endings.is_empty() {
+    //     let branch_label = binder.create_branch_label();
+    //     for ending in branch_endings {
+    //         binder.add_antecedent(branch_label, ending);
+    //     }
+    //     binder.current = branch_label;
+    // } else {
+    //     binder.current = current;
+    // }
+    
     Some(())
 }
diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/binder.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/flow/binder.rs
@@ -1,26 +1,28 @@
 use std::collections::HashMap;
 
+use emmylua_parser::{LuaGotoStat, LuaSyntaxId};
 use internment::ArcIntern;
 use smol_str::SmolStr;
 
 use crate::{
-    compilation::analyzer::flow::flow_node::{FlowAntecedent, FlowId, FlowNode, FlowNodeType},
-    DbIndex, FileId, LuaDeclId, LuaClosureId,
+    compilation::analyzer::flow::flow_node::{FlowAntecedent, FlowId, FlowNode, FlowNodeKind},
+    DbIndex, FileId, LuaClosureId, LuaDeclId,
 };
 
 #[derive(Debug)]
 pub struct FlowBinder<'a> {
     pub db: &'a DbIndex,
     pub file_id: FileId,
-    flow_nodes: Vec<FlowNode>,
-    multiple_antecedents: Vec<Vec<FlowId>>,
-    labels: HashMap<LuaClosureId, HashMap<SmolStr, FlowId>>,
     pub decl_bind_flow_ref: HashMap<LuaDeclId, FlowId>,
-    pub none_label: FlowId,
     pub start: FlowId,
     pub unreachable: FlowId,
     pub loop_label: FlowId,
     pub current: FlowId,
+    flow_nodes: Vec<FlowNode>,
+    multiple_antecedents: Vec<Vec<FlowId>>,
+    labels: HashMap<LuaClosureId, HashMap<SmolStr, FlowId>>,
+    goto_stats: Vec<(LuaGotoStat, LuaClosureId)>,
+    bindings: HashMap<LuaSyntaxId, FlowId>,
 }
 
 impl<'a> FlowBinder<'a> {
@@ -33,22 +35,22 @@ impl<'a> FlowBinder<'a> {
             decl_bind_flow_ref: HashMap::new(),
             labels: HashMap::new(),
             start: FlowId::default(),
-            none_label: FlowId::default(),
             unreachable: FlowId::default(),
             loop_label: FlowId::default(),
             current: FlowId::default(),
+            bindings: HashMap::new(),
+            goto_stats: Vec::new(),
         };
 
-        binder.none_label = binder.create_node(FlowNodeType::None);
         binder.start = binder.create_start();
         binder.unreachable = binder.create_unreachable();
-        binder.loop_label = binder.none_label;
+        binder.loop_label = binder.unreachable;
         binder.current = binder.start;
 
         binder
     }
 
-    pub fn create_node(&mut self, kind: FlowNodeType) -> FlowId {
+    pub fn create_node(&mut self, kind: FlowNodeKind) -> FlowId {
         let id = FlowId(self.flow_nodes.len() as u32);
         let flow_node = FlowNode {
             id,
@@ -58,31 +60,39 @@ impl<'a> FlowBinder<'a> {
         self.flow_nodes.push(flow_node);
         id
     }
-    
+
     pub fn create_branch_label(&mut self) -> FlowId {
-        self.create_node(FlowNodeType::BranchLabel)
+        self.create_node(FlowNodeKind::BranchLabel)
     }
 
     pub fn create_loop_label(&mut self) -> FlowId {
-        self.create_node(FlowNodeType::LoopLabel)
+        self.create_node(FlowNodeKind::LoopLabel)
     }
 
-    pub fn create_name_label(&mut self, name: String) -> FlowId {
-        self.create_node(FlowNodeType::NameLabel(ArcIntern::from(SmolStr::new(name))))
+    pub fn create_name_label(&mut self, name: &str, closure_id: LuaClosureId) -> FlowId {
+        let label_id = self.create_node(FlowNodeKind::NamedLabel(ArcIntern::from(SmolStr::new(
+            name,
+        ))));
+        self.labels
+            .entry(closure_id)
+            .or_default()
+            .insert(SmolStr::new(name), label_id);
+
+        label_id
     }
 
     pub fn create_start(&mut self) -> FlowId {
-        self.create_node(FlowNodeType::Start)
+        self.create_node(FlowNodeKind::Start)
     }
 
     pub fn create_unreachable(&mut self) -> FlowId {
-        self.create_node(FlowNodeType::Unreachable)
+        self.create_node(FlowNodeKind::Unreachable)
     }
 
     pub fn add_antecedent(&mut self, node_id: FlowId, antecedent: FlowId) {
         if let Some(existing) = self.flow_nodes.get_mut(node_id.0 as usize) {
             match existing.antecedent {
-                Some(FlowAntecedent::Node(existing_id)) => {
+                Some(FlowAntecedent::Single(existing_id)) => {
                     // If the existing antecedent is a single node, convert it to multiple
                     if existing_id == antecedent {
                         return; // No change needed if it's the same antecedent
@@ -103,9 +113,17 @@ impl<'a> FlowBinder<'a> {
                 }
                 _ => {
                     // Set new antecedent
-                    existing.antecedent = Some(FlowAntecedent::Node(antecedent));
+                    existing.antecedent = Some(FlowAntecedent::Single(antecedent));
                 }
             };
         }
     }
+
+    pub fn bind_syntax_node(&mut self, syntax_id: LuaSyntaxId, flow_id: FlowId) {
+        self.bindings.insert(syntax_id, flow_id);
+    }
+
+    pub fn add_goto_stat(&mut self, goto_stat: LuaGotoStat, closure_id: LuaClosureId) {
+        self.goto_stats.push((goto_stat, closure_id));
+    }
 }
diff --git a/crates/emmylua_code_analysis/src/compilation/analyzer/flow/flow_node.rs b/crates/emmylua_code_analysis/src/compilation/analyzer/flow/flow_node.rs
