fix some format bug

Co-authored-by: Copilot <copilot@github.com>

Author: CppCXY

crates/emmylua_formatter/src/formatter/expr.rs

@@ -137,6 +137,21 @@ fn format_binary_expr(
         return docs;
     }
 
+    if should_attach_short_binary_tail(op_token.get_op(), &right, &right_docs)
+        && should_attach_after_multiline_left_expr(&left)
+    {
+        let mut docs = left_docs;
+        if force_space_before {
+            docs.push(ir::space());
+        } else {
+            docs.push(space_rule.to_ir());
+        }
+        docs.push(ir::source_token(op_token.syntax().clone()));
+        docs.push(space_rule.to_ir());
+        docs.extend(right_docs);
+        return docs;
+    }
+
     vec![ir::group(vec![
         ir::list(left_docs),
         ir::indent(vec![
@@ -238,6 +253,18 @@ fn should_attach_short_binary_tail(
     }
 }
 
+fn should_attach_after_multiline_left_expr(left: &LuaExpr) -> bool {
+    left.syntax().text().contains_char('\n')
+        && matches!(
+            left,
+            LuaExpr::CallExpr(_)
+                | LuaExpr::ParenExpr(_)
+                | LuaExpr::IndexExpr(_)
+                | LuaExpr::TableExpr(_)
+                | LuaExpr::ClosureExpr(_)
+        )
+}
+
 fn format_unary_expr(
     ctx: &FormatContext,
     plan: &RootFormatPlan,
@@ -2477,7 +2504,7 @@ fn format_call_suffix_ir(
         return docs;
     }
 
-    let docs = if !args_list.syntax().text().contains_char('\n') {
+    if !args_list.syntax().text().contains_char('\n') {
         match format_compact_call_arg_list(ctx, plan, &args_list, &args) {
             CompactCallArgListAttempt::Formatted(docs) => docs,
             CompactCallArgListAttempt::ReuseDocs(arg_docs) => {
@@ -2497,23 +2524,6 @@ fn format_call_suffix_ir(
         }
     } else {
         format_call_arg_list(ctx, plan, &args_list)
-    };
-
-    let is_single_multiline_table_payload = args.len() == 1
-        && matches!(args.first(), Some(LuaExpr::TableExpr(table)) if table.syntax().text().contains_char('\n'));
-
-    let has_multiline_block_payload = args.iter().any(|arg| {
-        matches!(arg, LuaExpr::ClosureExpr(_) | LuaExpr::TableExpr(_))
-            && arg.syntax().text().contains_char('\n')
-    });
-
-    if ir::ir_has_forced_line_break(&docs)
-        && !is_single_multiline_table_payload
-        && !has_multiline_block_payload
-    {
-        vec![ir::indent(docs)]
-    } else {
-        docs
     }
 }
 

crates/emmylua_formatter/src/formatter/render/mod.rs

@@ -1775,6 +1775,15 @@ fn normalize_single_normal_comment_line(
         }
     });
     let body = body_with_gap.trim_start();
+    if prefix.trim_end() == "--"
+        && body_with_gap
+            .chars()
+            .next()
+            .is_some_and(char::is_whitespace)
+        && body.starts_with('[')
+    {
+        return format!("-- {body}");
+    }
     if body.is_empty() {
         prefix.trim_end().to_string()
     } else {

crates/emmylua_formatter/src/formatter/spacing.rs

@@ -364,6 +364,10 @@ fn apply_comment_start_spacing(
     token: &LuaSyntaxToken,
     syntax_id: LuaSyntaxId,
 ) {
+    if comment_start_looks_like_spaced_long_comment(token) {
+        return;
+    }
+
     if let Some(replacement) = normalized_comment_prefix(ctx, token.text()) {
         spacing.add_token_replace(syntax_id, replacement);
         spacing.add_token_right_expected(syntax_id, TokenSpacingExpected::Space(0));
@@ -457,6 +461,27 @@ fn get_prev_sibling_token_without_space(token: &LuaSyntaxToken) -> Option<LuaSyn
     None
 }
 
+fn comment_start_looks_like_spaced_long_comment(token: &LuaSyntaxToken) -> bool {
+    if token.kind().to_token() != LuaTokenKind::TkNormalStart || token.text() != "--" {
+        return false;
+    }
+
+    let mut current = token.next_token();
+    let mut saw_whitespace = false;
+    while let Some(next) = current {
+        match next.kind().to_token() {
+            LuaTokenKind::TkWhitespace => {
+                saw_whitespace = true;
+                current = next.next_token();
+            }
+            LuaTokenKind::TkEndOfLine => return false,
+            _ => return saw_whitespace && next.text().starts_with('['),
+        }
+    }
+
+    false
+}
+
 fn normalized_comment_prefix(ctx: &FormatContext, prefix_text: &str) -> Option<String> {
     match dash_prefix_len(prefix_text) {
         2 => Some(if ctx.config.comments.space_after_comment_dash {
@@ -652,6 +677,22 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_spacing_does_not_normalize_spaced_long_comment_prefix() {
+        let config = LuaFormatConfig::default();
+        let tree = LuaParser::parse(
+            "-- [[ not a long comment ]]\n",
+            ParserConfig::with_level(LuaLanguageLevel::Lua54),
+        );
+        let chunk = tree.get_chunk_node();
+        let spacing = analyze_root_spacing(&FormatContext::new(&config), &chunk).spacing;
+        let start = find_token(&chunk, LuaTokenKind::TkNormalStart);
+        let start_id = LuaSyntaxId::from_token(&start);
+
+        assert_eq!(spacing.token_replace(start_id), None);
+        assert_eq!(spacing.right_expected(start_id), None);
+    }
+
     #[test]
     fn test_spacing_collects_doc_prefix_replacement() {
         let config = LuaFormatConfig::default();

crates/emmylua_formatter/src/test/comment_tests.rs

@@ -2098,6 +2098,18 @@ local a = 1
 "#,
             r#"--[[ some content ]]
 local a = 1
+"#
+        );
+    }
+
+    #[test]
+    fn test_spaced_long_comment_prefix_preserved_as_normal_comment() {
+        assert_format!(
+            r#"-- [[ some content ]]
+local a = 1
+"#,
+            r#"-- [[ some content ]]
+local a = 1
 "#
         );
     }

crates/emmylua_formatter/src/test/expression_tests.rs

@@ -3,9 +3,11 @@ mod tests {
     // ========== unary / binary / concat ==========
 
     use crate::{
-        assert_format, assert_format_with_config,
+        SourceText, assert_format, assert_format_with_config,
         config::{LayoutConfig, LuaFormatConfig},
+        reformat_lua_code,
     };
+    use emmylua_parser::LuaLanguageLevel;
 
     #[test]
     fn test_unary_expr() {
@@ -763,6 +765,120 @@ end)
         );
     }
 
+    #[test]
+    fn test_chained_call_suffix_does_not_double_indent_multiline_args() {
+        assert_format!(
+            r#"a.a = function()
+    return function(l)
+        a.Add(
+                aaaa,
+                bbbb,
+                cccc,
+                dddd,
+                eeee,
+                nil,
+                nil,
+                nil,
+                aafafa -- comment
+            )()
+    end
+end
+"#,
+            r#"a.a = function()
+    return function(l)
+        a.Add(
+            aaaa,
+            bbbb,
+            cccc,
+            dddd,
+            eeee,
+            nil,
+            nil,
+            nil,
+            aafafa -- comment
+        )()
+    end
+end
+"#
+        );
+    }
+
+    #[test]
+    fn test_chained_index_after_multiline_call_does_not_double_indent_args() {
+        assert_format!(
+            r#"a.a = function()
+    return function(l)
+        return a.Add(
+                aaaa,
+                bbbb,
+                cccc,
+                dddd,
+                eeee,
+                nil,
+                nil,
+                nil,
+                aafafa -- comment
+            )[1]
+    end
+end
+"#,
+            r#"a.a = function()
+    return function(l)
+        return a.Add(
+            aaaa,
+            bbbb,
+            cccc,
+            dddd,
+            eeee,
+            nil,
+            nil,
+            nil,
+            aafafa -- comment
+        )[1]
+    end
+end
+"#
+        );
+    }
+
+    #[test]
+    fn test_chained_method_after_multiline_call_does_not_double_indent_args() {
+        assert_format!(
+            r#"a.a = function()
+    return function(l)
+        return a.Add(
+                aaaa,
+                bbbb,
+                cccc,
+                dddd,
+                eeee,
+                nil,
+                nil,
+                nil,
+                aafafa -- comment
+            ):next()
+    end
+end
+"#,
+            r#"a.a = function()
+    return function(l)
+        return a.Add(
+            aaaa,
+            bbbb,
+            cccc,
+            dddd,
+            eeee,
+            nil,
+            nil,
+            nil,
+            aafafa -- comment
+        ):next()
+    end
+end
+"#
+        );
+    }
+
     #[test]
     fn test_multiline_call_comparison_keeps_short_rhs_on_closing_line() {
         let config = LuaFormatConfig {
@@ -787,6 +903,41 @@ end, 'LOADTRUE', 'RETURN1') == "hiho")
         );
     }
 
+    #[test]
+    fn test_user_multiline_assert_comparison_keeps_eq_on_call_closing_line() {
+        let input = r#"assert(
+        T.checkpanic(
+            [[
+            pushstring "return {__close = function () Y = 'ho'; end}"
+      newtable
+      loadstring -2
+      call 0 1
+      setmetatable -2
+      toclose -1
+            pushstring "hi"
+      error
+    ]], [[
+      getglobal Y
+      concat 2         # concat original error with global Y
+    ]]
+        )
+                        == "hiho"
+    )
+"#;
+        let result = reformat_lua_code(
+            &SourceText {
+                text: input,
+                level: LuaLanguageLevel::default(),
+            },
+            &LuaFormatConfig::default(),
+        );
+
+        assert!(
+            result.contains(") == \"hiho\"") || result.contains(") == \"hiho\""),
+            "expected comparison tail to stay on the call closing line, got:\n{result}"
+        );
+    }
+
     #[test]
     fn test_table_auto_without_alignment_uses_progressive_fill() {
         let config = LuaFormatConfig {