Merge remote-tracking branch 'EmmyLuaLs/main' into update

Author: xuhuanzy

CONTRIBUTING.md

@@ -15,6 +15,8 @@ Our project is organized into several crates:
 | [🧹 **emmylua_formatter**](./crates/emmylua_formatter)         | [![emmylua_formatter](https://img.shields.io/crates/v/emmylua_formatter.svg?style=flat-square)](https://crates.io/crates/emmylua_formatter)             | The Lua formatter used by the EmmyLua Analyzer Rust workspace. |
 
 
+Note: We don't accept PRs that change formatting output, but you can report formatting bugs via issues — I'll verify and fix them myself. This is because most people aren't fully aware of the complexities involved in formatting
+
 ## Testing
 
 We use the standard Rust testing harness, along with assert macros from [`googletest-rust`]:

Cargo.lock

@@ -55,7 +55,7 @@ mimalloc = { version = "0.1.50" }
 googletest = "0.14.2"
 ntest = "0.9.5"
 unicode-general-category = "1.0.0"
-luars = { version = "0.26.0", features = ["serde", "sandbox"] }
+luars = { version = "0.26.1", features = ["serde", "sandbox"] }
 # request's default-tls feature pulls in a dependency on aws-lc-rs,
 # which causes a linking error on Windows
 reqwest = { version = "0.13.1", default-features = false, features = [

Cargo.toml

@@ -198,7 +198,6 @@ emmylua_doc_cli ./src --output ./docs
 - [**Configuration**](./docs/config/emmyrc_json_EN.md) - Advanced configuration options
 - [**Formatter Guide**](./docs/emmylua_formatter/README_EN.md) - Formatter behavior, options, and usage guide
 - [**Annotations Reference**](./docs/emmylua_doc/annotations_EN/README.md) - Detailed annotation documentation
-- [**Old Formatter**](https://github.com/CppCXY/EmmyLuaCodeStyle/blob/master/README_EN.md) - Formatting and style guidelines
 - [**External Formatter Integration**](./docs/external_format/external_formatter_options_EN.md) - Using external formatters
 
 ---

README.md

@@ -828,6 +828,13 @@
     },
     "EmmyrcLuaVersion": {
       "oneOf": [
+        {
+          "type": "string",
+          "enum": [
+            "LuaJIT-Ext",
+            "LuaJIT3"
+          ]
+        },
         {
           "description": "Lua 5.1",
           "type": "string",

crates/emmylua_code_analysis/resources/schema.json

@@ -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();
@@ -312,6 +317,11 @@ pub fn analyze_func_stat(analyzer: &mut DeclAnalyzer, stat: LuaFuncStat) -> Opti
 pub fn analyze_local_func_stat(analyzer: &mut DeclAnalyzer, stat: LuaLocalFuncStat) -> Option<()> {
     let local_name = stat.get_local_name()?;
     let name_token = local_name.get_name_token()?;
+    let is_const = if stat.is_const() {
+        Some(LocalAttribute::Const)
+    } else {
+        None
+    };
     let name = name_token.get_name_text();
     let range = local_name.get_range();
     let file_id = analyzer.get_file_id();
@@ -321,7 +331,7 @@ pub fn analyze_local_func_stat(analyzer: &mut DeclAnalyzer, stat: LuaLocalFuncSt
         range,
         LuaDeclExtra::Local {
             kind: local_name.syntax().kind(),
-            attrib: None,
+            attrib: is_const,
         },
         None,
     );

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

@@ -18,6 +18,7 @@ pub fn bind_binary_expr(
     match op_token.get_op() {
         BinaryOperator::OpAnd => bind_and_expr(binder, binary_expr, current),
         BinaryOperator::OpOr => bind_or_expr(binder, binary_expr, current),
+        BinaryOperator::OpNilCoalescing => bind_or_expr(binder, binary_expr, current),
         _ => {
             bind_each_child(binder, LuaAst::LuaBinaryExpr(binary_expr.clone()), current);
             Some(())
@@ -74,7 +75,7 @@ pub fn is_binary_logical(expr: &LuaExpr) -> bool {
 
             return matches!(
                 op_token.get_op(),
-                BinaryOperator::OpAnd | BinaryOperator::OpOr
+                BinaryOperator::OpAnd | BinaryOperator::OpOr | BinaryOperator::OpNilCoalescing
             );
         }
         LuaExpr::ParenExpr(paren_expr) => {

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

@@ -2,13 +2,15 @@ mod bind_binary_expr;
 
 use emmylua_parser::{
     LuaAst, LuaAstNode, LuaCallExpr, LuaClosureExpr, LuaExpr, LuaIndexExpr, LuaNameExpr,
-    LuaTableExpr, LuaUnaryExpr, UnaryOperator,
+    LuaTableExpr, LuaTernaryExpr, LuaUnaryExpr, UnaryOperator,
 };
 
 use crate::{
     FlowId, FlowNodeKind,
     compilation::analyzer::flow::{
-        bind_analyze::{bind_each_child, exprs::bind_binary_expr::is_binary_logical},
+        bind_analyze::{
+            bind_each_child, exprs::bind_binary_expr::is_binary_logical, finish_flow_label,
+        },
         binder::FlowBinder,
     },
 };
@@ -54,6 +56,7 @@ pub fn bind_expr(binder: &mut FlowBinder, expr: LuaExpr, current: FlowId) -> Flo
         LuaExpr::IndexExpr(index_expr) => bind_index_expr(binder, index_expr, current),
         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),
     };
 
     current
@@ -92,10 +95,34 @@ pub fn bind_index_expr(
     current: FlowId,
 ) -> Option<()> {
     binder.bind_syntax_node(index_expr.get_syntax_id(), current);
+    if index_expr.is_safe_index() {
+        return bind_safe_index_expr(binder, index_expr, current);
+    }
     bind_each_child(binder, LuaAst::LuaIndexExpr(index_expr.clone()), current);
     Some(())
 }
 
+fn bind_safe_index_expr(
+    binder: &mut FlowBinder,
+    index_expr: LuaIndexExpr,
+    current: FlowId,
+) -> Option<()> {
+    let prefix_expr = index_expr.get_prefix_expr()?;
+
+    let pre_access = binder.create_branch_label();
+    bind_condition_expr(
+        binder,
+        prefix_expr,
+        current,
+        pre_access,
+        binder.false_target,
+    );
+    let current = finish_flow_label(binder, pre_access, current);
+
+    bind_each_child(binder, LuaAst::LuaIndexExpr(index_expr), current);
+    Some(())
+}
+
 pub fn bind_paren_expr(
     binder: &mut FlowBinder,
     paren_expr: emmylua_parser::LuaParenExpr,
@@ -143,3 +170,32 @@ pub fn bind_call_expr(
     bind_each_child(binder, LuaAst::LuaCallExpr(call_expr.clone()), current);
     Some(())
 }
+
+fn bind_ternary_expr(
+    binder: &mut FlowBinder,
+    ternary_expr: LuaTernaryExpr,
+    current: FlowId,
+) -> Option<()> {
+    let condition = ternary_expr.get_condition_expr()?;
+    let (true_expr, false_expr) = ternary_expr.get_true_false_exprs()?;
+
+    let pre_false = binder.create_branch_label();
+    bind_condition_expr(binder, condition, current, binder.true_target, pre_false);
+    let current = finish_flow_label(binder, pre_false, current);
+    bind_condition_expr(
+        binder,
+        true_expr,
+        current,
+        binder.true_target,
+        binder.false_target,
+    );
+    bind_condition_expr(
+        binder,
+        false_expr,
+        current,
+        binder.true_target,
+        binder.false_target,
+    );
+
+    Some(())
+}

crates/emmylua_code_analysis/src/compilation/analyzer/flow/bind_analyze/exprs/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/mod.rs

@@ -1,8 +1,9 @@
 use emmylua_parser::{
     BinaryOperator, LuaAssignStat, LuaAst, LuaAstNode, LuaAstToken, LuaBlock, LuaBreakStat,
-    LuaCallArgList, LuaCallExprStat, LuaDoStat, LuaExpr, LuaForRangeStat, LuaForStat, LuaFuncStat,
-    LuaGotoStat, LuaIfStat, LuaLabelStat, LuaLiteralToken, LuaLocalName, LuaLocalStat,
-    LuaRepeatStat, LuaReturnStat, LuaVarExpr, LuaWhileStat, NumberResult, UnaryOperator,
+    LuaCallArgList, LuaCallExprStat, LuaContinueStat, LuaDoStat, LuaExpr, LuaForRangeStat,
+    LuaForStat, LuaFuncStat, LuaGotoStat, LuaIfStat, LuaLabelStat, LuaLiteralToken, LuaLocalName,
+    LuaLocalStat, LuaRepeatStat, LuaReturnStat, LuaVarExpr, LuaWhileStat, NumberResult,
+    UnaryOperator,
 };
 
 use crate::{
@@ -261,6 +262,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