impl call_arg_parentheses = always

CppCXY · CppCXY · commit 5b5f54455793 · 2024-06-05T01:21:53.000+08:00
diff --git a/CodeFormatCore/include/CodeFormatCore/Format/Analyzer/FormatStrategy.h b/CodeFormatCore/include/CodeFormatCore/Format/Analyzer/FormatStrategy.h
@@ -30,7 +30,7 @@ enum class TokenStrategy {
 
     WithParentheses,
     WithLeftParentheses,
-    WithRightParentheses
+    WithRightParentheses,
     SpaceAfterCommentDash
 };
 
diff --git a/CodeFormatCore/include/CodeFormatCore/Format/Analyzer/SpaceAnalyzer.h b/CodeFormatCore/include/CodeFormatCore/Format/Analyzer/SpaceAnalyzer.h
@@ -10,7 +10,7 @@ class SpaceAnalyzer : public FormatAnalyzer {
 
     enum class SpacePriority : std::size_t {
         Normal = 0,
-        CommentFirst,
+        First,
     };
 
     SpaceAnalyzer();
diff --git a/CodeFormatCore/src/Config/LuaStyle.cpp b/CodeFormatCore/src/Config/LuaStyle.cpp
@@ -131,6 +131,8 @@ void LuaStyle::Parse(std::map<std::string, std::string, std::less<>> &configMap)
             call_arg_parentheses = CallArgParentheses::RemoveStringOnly;
         } else if (value == "remove_table_only") {
             call_arg_parentheses = CallArgParentheses::RemoveTableOnly;
+        } else if (value == "always") {
+            call_arg_parentheses = CallArgParentheses::Always;
         }
     }
 
diff --git a/CodeFormatCore/src/Format/Analyzer/SpaceAnalyzer.cpp b/CodeFormatCore/src/Format/Analyzer/SpaceAnalyzer.cpp
@@ -181,14 +181,14 @@ void SpaceAnalyzer::Analyze(FormatState &f, const LuaSyntaxTree &t) {
                 case TK_LONG_COMMENT:
                 case TK_SHORT_COMMENT: {
                     if (f.GetStyle().space_before_inline_comment.Style == SpaceBeforeInlineCommentStyle::Fixed) {
-                        SpaceLeft(syntaxNode, t, f.GetStyle().space_before_inline_comment.Space, SpacePriority::CommentFirst);
+                        SpaceLeft(syntaxNode, t, f.GetStyle().space_before_inline_comment.Space, SpacePriority::First);
                     } else {
                         auto prevToken = syntaxNode.GetPrevToken(t);
                         if (prevToken.GetEndLine(t) == syntaxNode.GetStartLine(t)) {
                             auto space = syntaxNode.GetStartCol(t) - prevToken.GetEndCol(t) - 1;
-                            SpaceLeft(syntaxNode, t, space, SpacePriority::CommentFirst);
+                            SpaceLeft(syntaxNode, t, space, SpacePriority::First);
                         } else {
-                            SpaceLeft(syntaxNode, t, 0, SpacePriority::CommentFirst);
+                            SpaceLeft(syntaxNode, t, 0, SpacePriority::First);
                         }
                     }
                     SpaceRight(syntaxNode, t, 1);
@@ -421,15 +421,15 @@ void SpaceAnalyzer::FunctionCallSingleArgSpace(FormatState &f, LuaSyntaxNode n,
         firstToken.GetTokenKind(t) == TK_LONG_STRING) {
         switch (f.GetStyle().space_before_function_call_single_arg.string) {
             case FunctionSingleArgSpace::None: {
-                SpaceLeft(n, t, 0);
+                SpaceLeft(firstToken, t, 0);
                 break;
             }
             case FunctionSingleArgSpace::Always: {
-                SpaceLeft(n, t, 1);
+                SpaceLeft(firstToken, t, 1);
                 break;
             }
             case FunctionSingleArgSpace::Keep: {
-                SpaceIgnore(n);
+                SpaceIgnore(firstToken);
                 break;
             }
             default: {
@@ -439,15 +439,15 @@ void SpaceAnalyzer::FunctionCallSingleArgSpace(FormatState &f, LuaSyntaxNode n,
     } else {
         switch (f.GetStyle().space_before_function_call_single_arg.table) {
             case FunctionSingleArgSpace::None: {
-                SpaceLeft(n, t, 0);
+                SpaceLeft(firstToken, t, 0);
                 break;
             }
             case FunctionSingleArgSpace::Always: {
-                SpaceLeft(n, t, 1);
+                SpaceLeft(firstToken, t, 1);
                 break;
             }
             case FunctionSingleArgSpace::Keep: {
-                SpaceIgnore(n);
+                SpaceIgnore(firstToken);
                 break;
             }
             default: {
diff --git a/CodeFormatCore/src/Format/Analyzer/TokenAnalyzer.cpp b/CodeFormatCore/src/Format/Analyzer/TokenAnalyzer.cpp
@@ -182,7 +182,7 @@ void TokenAnalyzer::AnalyzeTableField(FormatState &f, LuaSyntaxNode n, const Lua
 bool IsSingleTableOrStringArg(LuaSyntaxNode n, const LuaSyntaxTree &t) {
     auto children = n.GetChildren(t);
     for (auto child: children) {
-        if (child.GetTokenKind(t) == TK_STRING || child.GetTokenKind(t) == TK_LONG_STRING ||
+        if (child.GetSyntaxKind(t) == LuaSyntaxNodeKind::StringLiteralExpression ||
             child.GetSyntaxKind(t) == LuaSyntaxNodeKind::TableExpression) {
             return true;
         } else if (
@@ -201,12 +201,12 @@ bool IsSingleTableOrStringArg(LuaSyntaxNode n, const LuaSyntaxTree &t) {
     return false;
 }
 
-LuaSyntaxNode GetSingleArgStringOrTable(LuaSyntaxNode &syntaxNode, const LuaSyntaxTree &t) {
-    auto children = syntaxNode.GetChildren(t);
+LuaSyntaxNode GetSingleArgStringOrTable(LuaSyntaxNode n, const LuaSyntaxTree &t) {
+    auto children = n.GetChildren(t);
     for (auto child: children) {
-        if (child.GetTokenKind(t) == TK_STRING || child.GetTokenKind(t) == TK_LONG_STRING ||
+        if (child.GetSyntaxKind(t) == LuaSyntaxNodeKind::StringLiteralExpression ||
             child.GetSyntaxKind(t) == LuaSyntaxNodeKind::TableExpression) {
-            return syntaxNode;
+            return child;
         } else if (child.GetSyntaxKind(t) == LuaSyntaxNodeKind::ExpressionList) {
             auto exprs = child.GetChildSyntaxNodes(LuaSyntaxMultiKind::Expression, t);
             if (exprs.size() == 1) {
@@ -266,14 +266,22 @@ void TokenAnalyzer::AnalyzeCallExpression(FormatState &f, LuaSyntaxNode n, const
             }
             case CallArgParentheses::Always: {
                 auto lbrace = n.GetChildToken('(', t);
-                if (!lbrace.IsToken(t)) {
+                auto spaceAnalyzer = f.GetAnalyzer<SpaceAnalyzer>();
+                if (!lbrace.IsToken(t) && spaceAnalyzer) {
                     auto node = GetSingleArgStringOrTable(n, t);
                     if (node.IsToken(t)) {
                         Mark(node, t, TokenStrategy::WithParentheses);
+                        spaceAnalyzer->SpaceAround(node, t, 0, SpaceAnalyzer::SpacePriority::First);
+                    } else if (node.GetSyntaxKind(t) == LuaSyntaxNodeKind::StringLiteralExpression) {
+                        Mark(node.GetFirstToken(t), t, TokenStrategy::WithParentheses);
+                        spaceAnalyzer->SpaceLeft(node.GetFirstToken(t), t, 0, SpaceAnalyzer::SpacePriority::First);
                     } else {
                         Mark(node.GetFirstToken(t), t, TokenStrategy::WithLeftParentheses);
+                        spaceAnalyzer->SpaceLeft(node.GetFirstToken(t), t, 0, SpaceAnalyzer::SpacePriority::First);
                         Mark(node.GetLastToken(t), t, TokenStrategy::WithRightParentheses);
                     }
+
+                    return;
                 }
 
                 break;
diff --git a/CodeFormatCore/src/Format/FormatBuilder.cpp b/CodeFormatCore/src/Format/FormatBuilder.cpp
@@ -157,9 +157,11 @@ void FormatBuilder::DoResolve(LuaSyntaxNode &syntaxNode, const LuaSyntaxTree &t,
                 WriteSyntaxNode(syntaxNode, t);
                 break;
             }
-            case TokenStrategy::WithRightParentheses:{
+            case TokenStrategy::WithRightParentheses: {
                 WriteSyntaxNode(syntaxNode, t);
                 WriteChar(')');
+                break;
+            }
             case TokenStrategy::SpaceAfterCommentDash: {
                 auto text = syntaxNode.GetText(t);
                 std::size_t pos = 0;
diff --git a/Test2/src/FormatTest2.cpp b/Test2/src/FormatTest2.cpp
@@ -8,11 +8,9 @@
 
 int main() {
     std::string buffer = R"(
-with_latin_extended_a = {
-    { 'aaaa', nil },
-    { 'ő', nil },  -- U+0151
-    { 'ű', nil },  -- U+0171
-}
+
+require "check"
+
 )";
 
     auto file = std::make_shared<LuaSource>(std::move(buffer));

Original file line number	Diff line number	Diff line change
`@@ -131,6 +131,8 @@ void LuaStyle::Parse(std::map<std::string, std::string, std::less<>> &configMap)`
`131`	`131`	`call_arg_parentheses = CallArgParentheses::RemoveStringOnly;`
`132`	`132`	`} else if (value == "remove_table_only") {`
`133`	`133`	`call_arg_parentheses = CallArgParentheses::RemoveTableOnly;`
	`134`	`+ } else if (value == "always") {`
	`135`	`+ call_arg_parentheses = CallArgParentheses::Always;`
`134`	`136`	`}`
`135`	`137`	`}`
`136`	`138`