support luajit conitnue and const stat

Author: CppCXY

crates/emmylua_code_analysis/src/compilation/analyzer/decl/stats.rs

@@ -16,6 +16,11 @@ use super::{DeclAnalyzer, members::find_index_owner};
 pub fn analyze_local_stat(analyzer: &mut DeclAnalyzer, stat: LuaLocalStat) -> Option<()> {
     let local_name_list = stat.get_local_name_list().collect::<Vec<_>>();
     let value_expr_list = stat.get_value_exprs().collect::<Vec<_>>();
+    let is_const = if stat.is_const() {
+        Some(LocalAttribute::Const)
+    } else {
+        None
+    };
 
     for (index, local_name) in local_name_list.iter().enumerate() {
         let name = if let Some(name_token) = local_name.get_name_token() {
@@ -29,10 +34,10 @@ pub fn analyze_local_stat(analyzer: &mut DeclAnalyzer, stat: LuaLocalStat) -> Op
             } else if attrib.is_close() {
                 Some(LocalAttribute::Close)
             } else {
-                None
+                is_const.clone()
             }
         } else {
-            None
+            is_const.clone()
         };
 
         let file_id = analyzer.get_file_id();

crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/exprs/mod.rs

@@ -2,7 +2,7 @@ mod bind_binary_expr;
 
 use emmylua_parser::{
     LuaAst, LuaAstNode, LuaCallExpr, LuaClosureExpr, LuaExpr, LuaIndexExpr, LuaNameExpr,
-    LuaNilCoalescingExpr, LuaTableExpr, LuaTernaryExpr, LuaUnaryExpr,
+    LuaTableExpr, LuaTernaryExpr, LuaUnaryExpr,
 };
 
 use crate::{
@@ -57,9 +57,6 @@ pub fn bind_expr(binder: &mut FlowBinder, expr: LuaExpr, current: FlowId) -> Flo
         LuaExpr::BinaryExpr(binary_expr) => bind_binary_expr(binder, binary_expr, current),
         LuaExpr::UnaryExpr(unary_expr) => bind_unary_expr(binder, unary_expr, current),
         LuaExpr::TernaryExpr(ternary_expr) => bind_ternary_expr(binder, ternary_expr, current),
-        LuaExpr::NilCoalescingExpr(nil_coalescing_expr) => {
-            bind_nil_coalescing_expr(binder, nil_coalescing_expr, current)
-        }
     };
 
     current
@@ -160,24 +157,3 @@ fn bind_ternary_expr(
 
     Some(())
 }
-
-fn bind_nil_coalescing_expr(
-    binder: &mut FlowBinder,
-    nil_coalescing_expr: LuaNilCoalescingExpr,
-    current: FlowId,
-) -> Option<()> {
-    let (left, right) = nil_coalescing_expr.get_left_right_exprs()?;
-
-    let pre_right = binder.create_branch_label();
-    bind_condition_expr(binder, left, current, binder.true_target, pre_right);
-    let current = finish_flow_label(binder, pre_right, current);
-    bind_condition_expr(
-        binder,
-        right,
-        current,
-        binder.true_target,
-        binder.false_target,
-    );
-
-    Some(())
-}

crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/mod.rs

@@ -12,10 +12,10 @@ use crate::{
             comment::bind_comment,
             exprs::bind_expr,
             stats::{
-                bind_assign_stat, bind_break_stat, bind_call_expr_stat, bind_do_stat,
-                bind_for_range_stat, bind_for_stat, bind_func_stat, bind_goto_stat, bind_if_stat,
-                bind_label_stat, bind_local_func_stat, bind_local_stat, bind_repeat_stat,
-                bind_return_stat, bind_while_stat,
+                bind_assign_stat, bind_break_stat, bind_call_expr_stat, bind_continue_stat,
+                bind_do_stat, bind_for_range_stat, bind_for_stat, bind_func_stat, bind_goto_stat,
+                bind_if_stat, bind_label_stat, bind_local_func_stat, bind_local_stat,
+                bind_repeat_stat, bind_return_stat, bind_while_stat,
             },
         },
         binder::FlowBinder,
@@ -41,7 +41,7 @@ fn bind_block(binder: &mut FlowBinder, block: LuaBlock, current: FlowId) -> Flow
 
         if let Some(flow_node) = binder.get_flow(return_flow_id) {
             match &flow_node.kind {
-                FlowNodeKind::Return | FlowNodeKind::Break => {
+                FlowNodeKind::Return | FlowNodeKind::Break | FlowNodeKind::Continue => {
                     return_flow_id = binder.unreachable;
                     can_change_flow = false;
                 }
@@ -72,6 +72,9 @@ fn bind_node(binder: &mut FlowBinder, node: LuaAst, current: FlowId) -> FlowId {
         }
         LuaAst::LuaLabelStat(label_stat) => bind_label_stat(binder, label_stat, current),
         LuaAst::LuaBreakStat(break_stat) => bind_break_stat(binder, break_stat, current),
+        LuaAst::LuaContinueStat(continue_stat) => {
+            bind_continue_stat(binder, continue_stat, current)
+        }
         LuaAst::LuaGotoStat(goto_stat) => bind_goto_stat(binder, goto_stat, current),
         LuaAst::LuaReturnStat(return_stat) => bind_return_stat(binder, return_stat, current),
         LuaAst::LuaDoStat(do_stat) => bind_do_stat(binder, do_stat, current),

crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/stats.rs

@@ -1,8 +1,8 @@
 use emmylua_parser::{
     BinaryOperator, LuaAssignStat, LuaAst, LuaAstNode, LuaBlock, LuaBreakStat, LuaCallArgList,
-    LuaCallExprStat, LuaDoStat, LuaExpr, LuaForRangeStat, LuaForStat, LuaFuncStat, LuaGotoStat,
-    LuaIfStat, LuaLabelStat, LuaLocalName, LuaLocalStat, LuaRepeatStat, LuaReturnStat, LuaVarExpr,
-    LuaWhileStat,
+    LuaCallExprStat, LuaContinueStat, LuaDoStat, LuaExpr, LuaForRangeStat, LuaForStat, LuaFuncStat,
+    LuaGotoStat, LuaIfStat, LuaLabelStat, LuaLocalName, LuaLocalStat, LuaRepeatStat, LuaReturnStat,
+    LuaVarExpr, LuaWhileStat,
 };
 
 use crate::{
@@ -255,6 +255,29 @@ pub fn bind_break_stat(
     break_flow_id
 }
 
+pub fn bind_continue_stat(
+    binder: &mut FlowBinder,
+    continue_stat: LuaContinueStat,
+    current: FlowId,
+) -> FlowId {
+    let continue_flow_id = binder.create_continue();
+    if let Some(loop_flow) = binder.get_flow(binder.loop_label)
+        && loop_flow.kind.is_unreachable()
+    {
+        // report a error if we are trying to continue outside a loop
+        binder.report_error(AnalyzeError::new(
+            DiagnosticCode::SyntaxError,
+            &t!("Continue outside loop"),
+            continue_stat.get_range(),
+        ));
+        return current;
+    }
+
+    binder.add_antecedent(continue_flow_id, current);
+    binder.add_antecedent(binder.loop_label, continue_flow_id);
+    continue_flow_id
+}
+
 pub fn bind_goto_stat(binder: &mut FlowBinder, goto_stat: LuaGotoStat, current: FlowId) -> FlowId {
     // Goto statements are handled separately in the flow analysis
     // They will be processed when we analyze the labels

crates/emmylua_code_analysis/src/compilation/analyzer/flow/binder.rs

@@ -108,6 +108,10 @@ impl<'a> FlowBinder<'a> {
         self.create_node(FlowNodeKind::Break)
     }
 
+    pub fn create_continue(&mut self) -> FlowId {
+        self.create_node(FlowNodeKind::Continue)
+    }
+
     pub fn create_return(&mut self) -> FlowId {
         self.create_node(FlowNodeKind::Return)
     }

crates/emmylua_code_analysis/src/db_index/flow/flow_node.rs

@@ -56,6 +56,8 @@ pub enum FlowNodeKind {
     TagCast(LuaAstPtr<LuaDocTagCast>),
     /// Break statement
     Break,
+    /// Continue statement
+    Continue,
     /// Return statement
     Return,
 }
@@ -75,7 +77,10 @@ impl FlowNodeKind {
     }
 
     pub fn is_change_flow(&self) -> bool {
-        matches!(self, FlowNodeKind::Break | FlowNodeKind::Return)
+        matches!(
+            self,
+            FlowNodeKind::Break | FlowNodeKind::Return | FlowNodeKind::Continue
+        )
     }
 
     pub fn is_assignment(&self) -> bool {

crates/emmylua_code_analysis/src/semantic/infer/infer_index/mod.rs

@@ -1,8 +1,7 @@
 mod infer_array;
 
 use emmylua_parser::{
-    LuaExpr, LuaIndexExpr, LuaIndexKey, LuaIndexMemberExpr, LuaNilCoalescingExpr, LuaTernaryExpr,
-    NumberResult, PathTrait,
+    LuaExpr, LuaIndexExpr, LuaIndexKey, LuaIndexMemberExpr, LuaTernaryExpr, NumberResult, PathTrait,
 };
 use hashbrown::HashSet;
 use internment::ArcIntern;
@@ -108,19 +107,6 @@ pub fn infer_ternary_expr(
     Ok(TypeOps::Union.apply(db, &true_type, &false_type))
 }
 
-pub fn infer_nil_coalescing_expr(
-    db: &DbIndex,
-    cache: &mut LuaInferCache,
-    nil_coalescing_expr: LuaNilCoalescingExpr,
-) -> InferResult {
-    let Some((left_expr, right_expr)) = nil_coalescing_expr.get_left_right_exprs() else {
-        return Err(InferFailReason::None);
-    };
-    let left_type = infer_expr(db, cache, left_expr)?;
-    let right_type = infer_expr(db, cache, right_expr)?;
-    Ok(TypeOps::Union.apply(db, &left_type, &right_type))
-}
-
 fn infer_member_type_pass_flow(
     db: &DbIndex,
     cache: &mut LuaInferCache,

crates/emmylua_code_analysis/src/semantic/infer/mod.rs

@@ -36,7 +36,7 @@ use smol_str::SmolStr;
 use crate::{
     InFiled, InferGuard, LuaMemberKey, VariadicType,
     db_index::{DbIndex, LuaOperator, LuaOperatorMetaMethod, LuaSignatureId, LuaType},
-    semantic::infer::infer_index::{infer_nil_coalescing_expr, infer_ternary_expr},
+    semantic::infer::infer_index::infer_ternary_expr,
 };
 
 use super::{CacheEntry, LuaInferCache, member::infer_raw_member_type};
@@ -134,9 +134,6 @@ pub fn infer_expr(db: &DbIndex, cache: &mut LuaInferCache, expr: LuaExpr) -> Inf
         LuaExpr::NameExpr(name_expr) => infer_name_expr(db, cache, name_expr),
         LuaExpr::IndexExpr(index_expr) => infer_index_expr(db, cache, index_expr, !no_flow),
         LuaExpr::TernaryExpr(ternary_expr) => infer_ternary_expr(db, cache, ternary_expr),
-        LuaExpr::NilCoalescingExpr(nil_coalescing_expr) => {
-            infer_nil_coalescing_expr(db, cache, nil_coalescing_expr)
-        }
     };
 
     match &result_type {

crates/emmylua_code_analysis/src/semantic/infer/narrow/get_type_at_flow.rs

@@ -1353,6 +1353,7 @@ impl<'a> FlowTypeEngine<'a> {
                 }
                 FlowNodeKind::LoopLabel
                 | FlowNodeKind::Break
+                | FlowNodeKind::Continue
                 | FlowNodeKind::Return
                 | FlowNodeKind::ForIStat(_) => {
                     walk.antecedent_flow_id = get_single_antecedent(flow_node)?;

crates/emmylua_formatter/src/formatter/expr.rs

@@ -1,9 +1,9 @@
 use emmylua_parser::{
     BinaryOperator, LuaAssignStat, LuaAstNode, LuaAstToken, LuaBinaryExpr, LuaCallArgList,
     LuaCallExpr, LuaClosureExpr, LuaComment, LuaExpr, LuaIndexExpr, LuaIndexKey, LuaKind,
-    LuaLiteralExpr, LuaLiteralToken, LuaLocalStat, LuaNameExpr, LuaNilCoalescingExpr, LuaParamList,
-    LuaParenExpr, LuaSingleArgExpr, LuaStat, LuaSyntaxId, LuaSyntaxKind, LuaSyntaxNode,
-    LuaSyntaxToken, LuaTableExpr, LuaTableField, LuaTernaryExpr, LuaTokenKind, LuaUnaryExpr,
+    LuaLiteralExpr, LuaLiteralToken, LuaLocalStat, LuaNameExpr, LuaParamList, LuaParenExpr,
+    LuaSingleArgExpr, LuaStat, LuaSyntaxId, LuaSyntaxKind, LuaSyntaxNode, LuaSyntaxToken,
+    LuaTableExpr, LuaTableField, LuaTernaryExpr, LuaTokenKind, LuaUnaryExpr,
 };
 use rowan::TextRange;
 
@@ -61,7 +61,6 @@ pub fn format_expr_with_options(
         LuaExpr::TableExpr(expr) => format_table_expr(ctx, plan, expr),
         LuaExpr::ClosureExpr(expr) => format_closure_expr(ctx, plan, expr),
         LuaExpr::TernaryExpr(expr) => format_ternary_expr(ctx, plan, expr),
-        LuaExpr::NilCoalescingExpr(expr) => format_nil_coalescing_expr(ctx, plan, expr),
     }
 }
 
@@ -2366,22 +2365,6 @@ fn format_ternary_expr(
     docs
 }
 
-fn format_nil_coalescing_expr(
-    ctx: &FormatContext,
-    plan: &FormatPlan,
-    expr: &LuaNilCoalescingExpr,
-) -> Vec<DocIR> {
-    let Some((left_expr, right_expr)) = expr.get_left_right_exprs() else {
-        return vec![ir::source_node(expr.syntax().clone())];
-    };
-    let mut docs = format_expr(ctx, plan, &left_expr);
-    docs.push(ir::space());
-    docs.push(ir::syntax_token(LuaTokenKind::TkNilCoalescing));
-    docs.push(ir::space());
-    docs.extend(format_expr(ctx, plan, &right_expr));
-    docs
-}
-
 fn try_format_simple_inline_closure_expr(
     ctx: &FormatContext,
     plan: &FormatPlan,