basic work for safe nav

Author: CppCXY

crates/emmylua_formatter/src/formatter/spacing.rs

@@ -52,7 +52,8 @@ pub(crate) fn space_around_binary_op(op: BinaryOperator, config: &LuaFormatConfi
         | BinaryOperator::OpBXor
         | BinaryOperator::OpShl
         | BinaryOperator::OpShr
-        | BinaryOperator::OpNop => SpaceRule::Space,
+        | BinaryOperator::OpNop
+        | BinaryOperator::OpNilCoalescing => SpaceRule::Space,
         BinaryOperator::OpConcat => {
             if config.spacing.space_around_concat_operator {
                 SpaceRule::Space

crates/emmylua_parser/src/grammar/lua/expr.rs

@@ -36,8 +36,47 @@ fn parse_sub_expr(p: &mut LuaParser, limit: i32) -> ParseResult {
         parse_simple_expr(p)?
     };
 
-    let mut bop = LuaOpKind::to_binary_operator(p.current_token());
-    while bop != BinaryOperator::OpNop && bop.get_priority().left > limit {
+    const TERNARY_LEFT: i32 = 1;
+
+    loop {
+        if p.current_token() == LuaTokenKind::TkTernary && TERNARY_LEFT > limit {
+            let m = cm.precede(p, LuaSyntaxKind::TernaryExpr);
+            p.bump(); // consume '?'
+            match parse_sub_expr(p, 0) {
+                Ok(_) => {}
+                Err(_) => {
+                    p.push_error(LuaParseError::syntax_error_from(
+                        &t!("expected expression after '?'"),
+                        p.current_token_range(),
+                    ));
+                }
+            }
+            match expect_token(p, LuaTokenKind::TkColon) {
+                Ok(_) => {}
+                Err(_) => {
+                    p.push_error(LuaParseError::syntax_error_from(
+                        &t!("expected ':' in ternary expression"),
+                        p.current_token_range(),
+                    ));
+                }
+            }
+            match parse_sub_expr(p, 0) {
+                Ok(_) => {}
+                Err(_) => {
+                    p.push_error(LuaParseError::syntax_error_from(
+                        &t!("expected expression after ':'"),
+                        p.current_token_range(),
+                    ));
+                }
+            }
+            cm = m.complete(p);
+            continue;
+        }
+
+        let bop = LuaOpKind::to_binary_operator(p.current_token());
+        if bop == BinaryOperator::OpNop || bop.get_priority().left <= limit {
+            break;
+        }
         let op_range = p.current_token_range();
         let op_token = p.current_token();
         let m = cm.precede(p, LuaSyntaxKind::BinaryExpr);
@@ -58,7 +97,6 @@ fn parse_sub_expr(p: &mut LuaParser, limit: i32) -> ParseResult {
         }
 
         cm = m.complete(p);
-        bop = LuaOpKind::to_binary_operator(p.current_token());
     }
 
     Ok(cm)
@@ -526,6 +564,15 @@ fn parse_suffixed_expr(p: &mut LuaParser) -> ParseResult {
                 }
                 cm = m.complete(p);
             }
+            LuaTokenKind::TkSafeNavigation => {
+                let m = cm.precede(p, LuaSyntaxKind::SafeIndexExpr);
+                p.bump(); // consume '?.'
+                if let Err(err) = parse_safe_index_struct(p) {
+                    m.complete(p);
+                    return Err(err);
+                }
+                cm = m.complete(p);
+            }
             LuaTokenKind::TkLeftParen
             | LuaTokenKind::TkLongString
             | LuaTokenKind::TkString
@@ -660,6 +707,87 @@ fn parse_index_struct(p: &mut LuaParser) -> Result<(), ParseFailReason> {
     Ok(())
 }
 
+/// Parses a safe index structure, which is used in safe navigation expressions (e.g., `?.`).
+/// like `?.[expr]`, `?.name`, or `?.:method()`.
+/// call like `?.(`, `?. ""`, or `?. {}`.
+fn parse_safe_index_struct(p: &mut LuaParser) -> Result<(), ParseFailReason> {
+    let index_op_range = p.current_token_range();
+    match p.current_token() {
+        LuaTokenKind::TkLeftBracket => {
+            p.bump();
+            match parse_expr(p) {
+                Ok(_) => {}
+                Err(err) => {
+                    p.push_error(LuaParseError::syntax_error_from(
+                        &t!("expected expression inside table index brackets"),
+                        index_op_range,
+                    ));
+                    return Err(err);
+                }
+            }
+            match expect_token(p, LuaTokenKind::TkRightBracket) {
+                Ok(_) => {}
+                Err(err) => {
+                    p.push_error(LuaParseError::syntax_error_from(
+                        &t!("expected ']' to close table index"),
+                        index_op_range,
+                    ));
+                    return Err(err);
+                }
+            }
+        }
+        LuaTokenKind::TkName => {
+            p.bump();
+        }
+        LuaTokenKind::TkColon => {
+            p.bump();
+            let name_token_range = p.current_token_range();
+            match expect_token(p, LuaTokenKind::TkName) {
+                Ok(_) => {}
+                Err(err) => {
+                    p.push_error(LuaParseError::syntax_error_from(
+                        &t!("expected method name after ':'"),
+                        index_op_range,
+                    ));
+                    return Err(err);
+                }
+            }
+            if !matches!(
+                p.current_token(),
+                LuaTokenKind::TkLeftParen
+                    | LuaTokenKind::TkLeftBrace
+                    | LuaTokenKind::TkString
+                    | LuaTokenKind::TkLongString
+            ) {
+                p.push_error(LuaParseError::syntax_error_from(
+                    &t!(
+                        "colon accessor must be followed by a function call or table constructor or string literal"
+                    ),
+                    name_token_range,
+                ));
+
+                return Err(ParseFailReason::UnexpectedToken);
+            }
+        }
+        LuaTokenKind::TkString
+        | LuaTokenKind::TkLongString
+        | LuaTokenKind::TkLeftParen
+        | LuaTokenKind::TkLeftBrace => {
+            // allow these tokens to be part of a safe navigation call expression
+        }
+        _ => {
+            p.push_error(LuaParseError::syntax_error_from(
+                &t!("expect safe index struct after '?.'"),
+                p.current_token_range(),
+            ));
+
+            return Err(ParseFailReason::UnexpectedToken);
+        }
+    }
+
+    Ok(())
+}
+
 fn parse_args(p: &mut LuaParser) -> ParseResult {
     let m = p.mark(LuaSyntaxKind::CallArgList);
     match p.current_token() {

crates/emmylua_parser/src/kind/lua_operator_kind.rs

@@ -32,10 +32,11 @@ pub enum BinaryOperator {
     OpNe,     // ~=
     OpAnd,    // and
     OpOr,     // or
+    OpNilCoalescing, // ??
     OpNop,    // (empty)
 }
 
-pub const PRIORITY: [PriorityTable; 21] = [
+pub const PRIORITY: [PriorityTable; 23] = [
     PriorityTable {
         left: 10,
         right: 10,
@@ -78,6 +79,8 @@ pub const PRIORITY: [PriorityTable; 21] = [
     PriorityTable { left: 3, right: 3 }, // OPR_GE
     PriorityTable { left: 2, right: 2 }, // OPR_AND
     PriorityTable { left: 1, right: 1 }, // OPR_OR
+    PriorityTable { left: 1, right: 1 }, // OPR_NIL_COALESCING
+    PriorityTable { left: 0, right: 0 }, // OPR_NOP (unreachable)
 ];
 
 impl BinaryOperator {

crates/emmylua_parser/src/kind/lua_syntax_kind.rs

@@ -47,6 +47,9 @@ pub enum LuaSyntaxKind {
     SetmetatableCallExpr, // setmetatable(a, b)
     IndexExpr,
     NameExpr,
+    TernaryExpr,
+    SafeIndexExpr,
+    NilCoalescingExpr,
 
     // other
     LocalName,

crates/emmylua_parser/src/kind/mod.rs

@@ -174,6 +174,7 @@ impl LuaOpKind {
             LuaTokenKind::TkNe => BinaryOperator::OpNe,
             LuaTokenKind::TkAnd => BinaryOperator::OpAnd,
             LuaTokenKind::TkOr => BinaryOperator::OpOr,
+            LuaTokenKind::TkNilCoalescing => BinaryOperator::OpNilCoalescing,
             _ => BinaryOperator::OpNop,
         }
     }