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

Author: xuhuanzy

CHANGELOG.md

@@ -6,7 +6,7 @@
 
 ### ✨ Added
 
-- **Support LuaJIT-Ext**: Added support for LuaJIT‑Ext syntax, including compound assignment operators, null‑safe navigation, the null‑coalescing operator, constant variables, and the continue statement.
+- **Support LuaJIT-Ext**: Added support for LuaJIT‑Ext syntax, including compound assignment operators, null‑safe navigation, the null‑coalescing operator, constant variables statement, the continue statement, the underscore number, and the short function syntax.
 
 - **Support LuaJIT3**: Besides LuaJIT‑Ext syntax, named variadic arguments and integer division are also supported.
 

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

@@ -1,9 +1,6 @@
+use crate::formatter::render::comments_ast::render_comment_via_ast;
 use rowan::TextRange;
 
-use super::doc_comments::{
-    normalize_doc_comment_block, normalize_mixed_comment_block,
-    should_preserve_doc_comment_block_raw,
-};
 use super::*;
 
 pub(crate) type RenderedTrailingComment = (Vec<DocIR>, TextRange, bool);
@@ -191,212 +188,11 @@ pub(crate) fn render_comment_with_spacing(
     comment: &LuaComment,
     plan: &FormatPlan,
 ) -> Vec<DocIR> {
-    if should_preserve_comment_raw(comment) || should_preserve_doc_comment_block_raw(comment) {
+    if should_preserve_comment_raw(comment) {
         return vec![ir::source_node_trimmed(comment.syntax().clone())];
     }
 
-    let raw = trim_end_comment_text(comment.syntax().text().to_string());
-    let prefix_replacements = collect_comment_line_prefix_replacements(comment, plan);
-    let normalized_lines = collect_comment_line_spacing_normalized_texts(comment, plan);
-    let lines = if is_pure_doc_comment_block(&raw) {
-        normalize_doc_comment_block(
-            ctx,
-            comment,
-            &raw,
-            &prefix_replacements,
-            normalized_lines.as_slice(),
-        )
-    } else if contains_doc_comment_line(&raw) {
-        normalize_mixed_comment_block(
-            ctx,
-            comment,
-            &raw,
-            &prefix_replacements,
-            normalized_lines.as_slice(),
-        )
-    } else {
-        normalize_normal_comment_block(ctx, &raw, &prefix_replacements, normalized_lines.as_slice())
-    };
-    lines
-        .into_iter()
-        .enumerate()
-        .flat_map(|(index, line)| {
-            let mut docs = Vec::new();
-            if index > 0 {
-                docs.push(ir::hard_line());
-            }
-            if !line.is_empty() {
-                docs.push(ir::text(line));
-            }
-            docs
-        })
-        .collect()
-}
-
-fn trim_end_comment_text(mut text: String) -> String {
-    while matches!(text.chars().last(), Some(' ' | '\t' | '\r' | '\n')) {
-        text.pop();
-    }
-    text
-}
-
-fn is_pure_doc_comment_block(raw: &str) -> bool {
-    raw.lines()
-        .filter(|line| !line.trim().is_empty())
-        .all(|line| line.trim_start().starts_with("---"))
-}
-
-fn contains_doc_comment_line(raw: &str) -> bool {
-    raw.lines()
-        .filter(|line| !line.trim().is_empty())
-        .any(|line| line.trim_start().starts_with("---"))
-}
-
-fn collect_comment_line_prefix_replacements(
-    comment: &LuaComment,
-    plan: &FormatPlan,
-) -> Vec<Option<String>> {
-    let mut line_prefixes = Vec::new();
-    let mut current_prefix = None;
-    let mut saw_token_on_line = false;
-
-    for element in comment.syntax().descendants_with_tokens() {
-        let Some(token) = element.into_token() else {
-            continue;
-        };
-
-        match token.kind().to_token() {
-            LuaTokenKind::TkWhitespace => {}
-            LuaTokenKind::TkEndOfLine => {
-                line_prefixes.push(current_prefix.take());
-                saw_token_on_line = false;
-            }
-            _ => {
-                if !saw_token_on_line {
-                    current_prefix = comment_prefix_replacement_for_token(plan, &token);
-                    saw_token_on_line = true;
-                }
-            }
-        }
-    }
-
-    if saw_token_on_line || current_prefix.is_some() {
-        line_prefixes.push(current_prefix);
-    }
-
-    line_prefixes
-}
-
-fn comment_prefix_replacement_for_token(
-    plan: &FormatPlan,
-    token: &LuaSyntaxToken,
-) -> Option<String> {
-    match token.kind().to_token() {
-        LuaTokenKind::TkNormalStart
-        | LuaTokenKind::TkDocStart
-        | LuaTokenKind::TkDocContinue
-        | LuaTokenKind::TkDocContinueOr => Some(
-            plan.spacing
-                .token_replace(LuaSyntaxId::from_token(token))
-                .unwrap_or(token.text())
-                .to_string(),
-        ),
-        _ => None,
-    }
-}
-
-fn normalize_normal_comment_block(
-    ctx: &FormatContext,
-    raw: &str,
-    prefix_replacements: &[Option<String>],
-    normalized_lines: &[Option<String>],
-) -> Vec<String> {
-    let lines: Vec<_> = raw.lines().collect();
-    if lines.len() <= 1 {
-        return vec![normalize_single_normal_comment_line(
-            ctx,
-            raw,
-            prefix_replacements
-                .first()
-                .and_then(|prefix| prefix.as_deref()),
-            normalized_lines.first().and_then(|line| line.as_deref()),
-            false,
-        )];
-    }
-    lines
-        .into_iter()
-        .enumerate()
-        .map(|(index, line)| {
-            let trimmed = line.trim_start();
-            if trimmed.is_empty() {
-                String::new()
-            } else {
-                normalize_single_normal_comment_line(
-                    ctx,
-                    trimmed,
-                    prefix_replacements
-                        .get(index)
-                        .and_then(|prefix| prefix.as_deref()),
-                    normalized_lines.get(index).and_then(|line| line.as_deref()),
-                    true,
-                )
-            }
-        })
-        .collect()
-}
-
-pub(crate) fn normalize_single_normal_comment_line(
-    ctx: &FormatContext,
-    line: &str,
-    prefix_override: Option<&str>,
-    _normalized_line: Option<&str>,
-    preserve_extra_gap: bool,
-) -> String {
-    let trimmed = line.trim_start();
-    if !trimmed.starts_with("--") || trimmed.starts_with("---") {
-        return trimmed.to_string();
-    }
-    let body_with_gap = &trimmed[2..];
-    let preserved_gap = preserved_dash_gap(body_with_gap);
-    let prefix = prefix_override.map(str::to_string).unwrap_or_else(|| {
-        if ctx.config.comments.space_after_comment_dash {
-            "-- ".to_string()
-        } else {
-            "--".to_string()
-        }
-    });
-    let body = preserved_gap
-        .as_ref()
-        .map(|gap| &body_with_gap[gap.len()..])
-        .unwrap_or_else(|| body_with_gap.trim_start());
-    if preserve_extra_gap && let Some(gap) = preserved_gap {
-        return if body.is_empty() {
-            "--".to_string()
-        } else {
-            format!("--{gap}{body}")
-        };
-    }
-    if let Some(_gap) = preserved_gap {
-        return if body.is_empty() {
-            "--".to_string()
-        } else {
-            format!("{prefix}{body}")
-        };
-    }
-    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 {
-        format!("{prefix}{body}")
-    }
+    render_comment_via_ast(ctx, comment, plan)
 }
 
 pub(crate) fn render_direct_body_comment(
@@ -433,155 +229,16 @@ pub(crate) fn comment_is_inline_after_anchor(
     !text[start..end].chars().any(|ch| matches!(ch, '\n' | '\r'))
 }
 
-fn collect_comment_line_spacing_normalized_texts(
-    comment: &LuaComment,
-    plan: &FormatPlan,
-) -> Vec<Option<String>> {
-    let mut lines = Vec::new();
-    let mut current_line = Vec::new();
-
-    for element in comment.syntax().descendants_with_tokens() {
-        let Some(token) = element.into_token() else {
-            continue;
-        };
-
-        match token.kind().to_token() {
-            LuaTokenKind::TkEndOfLine => {
-                lines.push(normalize_comment_line_with_spacing(&current_line, plan));
-                current_line.clear();
-            }
-            _ => current_line.push(token),
-        }
-    }
-
-    if !current_line.is_empty() {
-        lines.push(normalize_comment_line_with_spacing(&current_line, plan));
-    }
-
-    lines
-}
-
-fn normalize_comment_line_with_spacing(
-    tokens: &[LuaSyntaxToken],
-    plan: &FormatPlan,
-) -> Option<String> {
-    let mut out = String::new();
-    let mut previous_token: Option<&LuaSyntaxToken> = None;
-    let mut saw_whitespace = false;
-
-    for token in tokens {
-        if token.kind().to_token() == LuaTokenKind::TkWhitespace {
-            saw_whitespace = !out.is_empty();
-            continue;
-        }
-
-        if !out.is_empty() {
-            let spacing =
-                comment_spacing_between_tokens(plan, previous_token, token, saw_whitespace);
-            out.extend(std::iter::repeat_n(' ', spacing));
-        }
-
-        out.push_str(comment_token_text(plan, token));
-        previous_token = Some(token);
-        saw_whitespace = false;
-    }
-
-    (!out.is_empty()).then_some(out)
-}
-
-fn comment_spacing_between_tokens(
-    plan: &FormatPlan,
-    previous_token: Option<&LuaSyntaxToken>,
-    current_token: &LuaSyntaxToken,
-    had_source_whitespace: bool,
-) -> usize {
-    if had_source_whitespace && previous_token.is_some_and(is_doc_tag_keyword_token) {
-        return 1;
-    }
-
-    if had_source_whitespace
-        && current_token.kind().to_token() == LuaTokenKind::TkLeftBracket
-        && previous_token.is_some_and(|token| {
-            matches!(
-                token.kind().to_token(),
-                LuaTokenKind::TkDocVisibility | LuaTokenKind::TkTagVisibility
-            )
-        })
-    {
-        return 1;
-    }
-
-    let current_id = LuaSyntaxId::from_token(current_token);
-    if let Some(expected) = plan.spacing.left_expected(current_id) {
-        return resolve_comment_spacing_expected(expected, had_source_whitespace);
-    }
-
-    if let Some(previous_token) = previous_token {
-        let previous_id = LuaSyntaxId::from_token(previous_token);
-        if let Some(expected) = plan.spacing.right_expected(previous_id) {
-            return resolve_comment_spacing_expected(expected, had_source_whitespace);
-        }
-    }
-
-    usize::from(had_source_whitespace)
-}
-
-fn resolve_comment_spacing_expected(
-    expected: &TokenSpacingExpected,
-    had_source_whitespace: bool,
-) -> usize {
-    match expected {
-        TokenSpacingExpected::Space(count) => *count,
-        TokenSpacingExpected::MaxSpace(count) => {
-            if had_source_whitespace {
-                (*count).min(1)
-            } else {
-                0
-            }
-        }
-    }
-}
-
-fn comment_token_text<'a>(plan: &'a FormatPlan, token: &'a LuaSyntaxToken) -> &'a str {
-    plan.spacing
-        .token_replace(LuaSyntaxId::from_token(token))
-        .unwrap_or(token.text())
-}
-
-fn is_doc_tag_keyword_token(token: &LuaSyntaxToken) -> bool {
-    matches!(
-        token.kind().to_token(),
-        LuaTokenKind::TkTagClass
-            | LuaTokenKind::TkTagAlias
-            | LuaTokenKind::TkTagField
-            | LuaTokenKind::TkTagType
-            | LuaTokenKind::TkTagParam
-            | LuaTokenKind::TkTagReturn
-            | LuaTokenKind::TkTagGeneric
-            | LuaTokenKind::TkTagOverload
-            | LuaTokenKind::TkTagVersion
-    )
-}
-
-pub(crate) fn preserved_dash_gap(text_after_dash: &str) -> Option<String> {
-    let gap_len = text_after_dash
-        .chars()
-        .take_while(|ch| matches!(ch, ' ' | '\t'))
-        .count();
-    if gap_len > 1 {
-        Some(text_after_dash[..gap_len].to_string())
-    } else {
-        None
-    }
-}
-
 fn should_preserve_comment_raw(comment: &LuaComment) -> bool {
     let raw = comment.syntax().text().to_string();
     if raw.starts_with("----") {
         return true;
     }
 
-    if raw_comment_starts_like_long_comment(raw.as_str()) {
+    if raw
+        .lines()
+        .any(|line| raw_comment_starts_like_long_comment(line.trim_start()))
+    {
         return true;
     }