Fix #186

CppCXY · CppCXY · commit 4ab859fd1f44 · 2024-09-29T11:03:47.000+08:00
diff --git a/CodeFormatCore/include/CodeFormatCore/Diagnostic/DiagnosticType.h b/CodeFormatCore/include/CodeFormatCore/Diagnostic/DiagnosticType.h
@@ -15,7 +15,8 @@ enum class DiagnosticType {
     Indent,
     Semicolon,
     NameStyle,
-    Spell
+    Spell,
+    Parentheses,
 };
 
 class LuaDiagnostic {
diff --git a/CodeFormatCore/include/CodeFormatCore/Format/Analyzer/FormatResolve.h b/CodeFormatCore/include/CodeFormatCore/Format/Analyzer/FormatResolve.h
@@ -12,9 +12,11 @@ class FormatResolve {
 
     PrevSpaceStrategy GetPrevSpaceStrategy() const;
 
+    PrevTokenStrategy GetPrevTokenStrategy() const;
+
     TokenStrategy GetTokenStrategy() const;
 
-    TokenAddStrategy GetTokenAddStrategy() const;
+    NextTokenStrategy GetNextTokenStrategy() const;
 
     IndentStrategy GetIndentStrategy() const;
 
@@ -30,7 +32,9 @@ class FormatResolve {
 
     void SetTokenStrategy(TokenStrategy strategy);
 
-    void SetTokenAddStrategy(TokenAddStrategy strategy);
+    void SetNextTokenStrategy(NextTokenStrategy strategy);
+
+    void SetPrevTokenStrategy(PrevTokenStrategy strategy);
 
     std::size_t GetNextSpace();
 
@@ -49,8 +53,9 @@ class FormatResolve {
 private:
     NextSpaceStrategy _nextSpaceStrategy;
     PrevSpaceStrategy _prevSpaceStrategy;
+    PrevTokenStrategy _prevTokenStrategy;
     TokenStrategy _tokenStrategy;
-    TokenAddStrategy _tokenAddStrategy;
+    NextTokenStrategy _nextAddStrategy;
     IndentStrategy _indentStrategy;
 
     union NextData {
diff --git a/CodeFormatCore/include/CodeFormatCore/Format/Analyzer/FormatStrategy.h b/CodeFormatCore/include/CodeFormatCore/Format/Analyzer/FormatStrategy.h
@@ -17,6 +17,12 @@ enum class PrevSpaceStrategy {
     LineBreak
 };
 
+enum class PrevTokenStrategy {
+    None,
+    LeftParentheses,
+
+};
+
 enum class TokenStrategy {
     Origin,
     Remove,
@@ -28,17 +34,18 @@ enum class TokenStrategy {
     StmtEndSemicolon,
     NewLineBeforeToken,
 
-    WithParentheses,
-    WithLeftParentheses,
-    WithRightParentheses,
+//    WithParentheses,
+//    WithLeftParentheses,
+//    WithRightParentheses,
     SpaceAfterCommentDash
 };
 
-enum class TokenAddStrategy {
+enum class NextTokenStrategy {
     None,
     TableAddColon,
     TableAddComma,
     StmtEndSemicolon,
+    RightParentheses,
 };
 
 enum class IndentStrategy {
diff --git a/CodeFormatCore/include/CodeFormatCore/Format/Analyzer/TokenAnalyzer.h b/CodeFormatCore/include/CodeFormatCore/Format/Analyzer/TokenAnalyzer.h
@@ -13,9 +13,11 @@ class TokenAnalyzer : public FormatAnalyzer {
 
     void Query(FormatState &f, LuaSyntaxNode syntaxNode, const LuaSyntaxTree &t, FormatResolve &resolve) override;
 
+    void MarkPrev(LuaSyntaxNode n, const LuaSyntaxTree &t, PrevTokenStrategy strategy);
+
     void Mark(LuaSyntaxNode n, const LuaSyntaxTree &t, TokenStrategy strategy);
 
-    void MarkAdd(LuaSyntaxNode n, const LuaSyntaxTree &t, TokenAddStrategy strategy);
+    void MarkNext(LuaSyntaxNode n, const LuaSyntaxTree &t, NextTokenStrategy strategy);
 
     bool IsRemove(LuaSyntaxNode n, const LuaSyntaxTree &t) const;
 
@@ -29,5 +31,6 @@ class TokenAnalyzer : public FormatAnalyzer {
     void AnalyzeComment(FormatState &f, LuaSyntaxNode n, const LuaSyntaxTree &t);
 
     std::unordered_map<std::size_t, TokenStrategy> _tokenStrategies;
-    std::unordered_map<std::size_t, TokenAddStrategy> _tokenAddStrategies;
+    std::unordered_map<std::size_t, NextTokenStrategy> _nextTokenStrategies;
+    std::unordered_map<std::size_t, PrevTokenStrategy> _prevTokenStrategies;
 };
diff --git a/CodeFormatCore/src/Diagnostic/CodeStyle/CodeStyleChecker.cpp b/CodeFormatCore/src/Diagnostic/CodeStyle/CodeStyleChecker.cpp
@@ -70,6 +70,17 @@ void CodeStyleChecker::BasicResolve(LuaSyntaxNode syntaxNode, const LuaSyntaxTre
             }
         }
 
+        switch (resolve.GetPrevTokenStrategy()) {
+            case PrevTokenStrategy::LeftParentheses: {
+                d.PushDiagnostic(DiagnosticType::Parentheses, textRange,
+                                 LText("expected ("));
+                break;
+            }
+            default: {
+                break;
+            }
+        }
+
         switch (resolve.GetTokenStrategy()) {
             case TokenStrategy::StringSingleQuote: {
                 if (syntaxNode.GetTokenKind(t) == TK_STRING) {
@@ -117,13 +128,18 @@ void CodeStyleChecker::BasicResolve(LuaSyntaxNode syntaxNode, const LuaSyntaxTre
             }
         }
 
-        switch (resolve.GetTokenAddStrategy()) {
-            case TokenAddStrategy::StmtEndSemicolon: {
+        switch (resolve.GetNextTokenStrategy()) {
+            case NextTokenStrategy::StmtEndSemicolon: {
                 d.PushDiagnostic(DiagnosticType::Semicolon,
                                  TextRange(textRange.GetEndOffset(), 1),
                                  LText("expected ; at end of statement"));
                 break;
             }
+            case NextTokenStrategy::RightParentheses: {
+                d.PushDiagnostic(DiagnosticType::Parentheses, textRange,
+                                 LText("expected )"));
+                break;
+            }
             default: {
                 break;
             }
@@ -271,7 +287,7 @@ void CodeStyleChecker::ProcessIndentDiagnostic(LuaSyntaxNode &node, const LuaSyn
         // if(state.GetStyle().indent_style)
         d.PushDiagnostic(DiagnosticType::Indent,
                          currentIndentRange,
-                         GetIndentNote(indent,checkIndent.Space, checkIndent.Tab, state.GetStyle().indent_style));
+                         GetIndentNote(indent, checkIndent.Space, checkIndent.Tab, state.GetStyle().indent_style));
     }
 }
 
diff --git a/CodeFormatCore/src/Format/Analyzer/FormatResolve.cpp b/CodeFormatCore/src/Format/Analyzer/FormatResolve.cpp
@@ -4,7 +4,7 @@ FormatResolve::FormatResolve()
     : _nextSpaceStrategy(NextSpaceStrategy::None),
       _prevSpaceStrategy(PrevSpaceStrategy::None),
       _tokenStrategy(TokenStrategy::Origin),
-      _tokenAddStrategy(TokenAddStrategy::None),
+      _nextAddStrategy(NextTokenStrategy::None),
       _indentStrategy(IndentStrategy::None),
       _nextSpaceData(),
       _prevSpaceData(),
@@ -19,23 +19,29 @@ PrevSpaceStrategy FormatResolve::GetPrevSpaceStrategy() const {
     return _prevSpaceStrategy;
 }
 
+PrevTokenStrategy FormatResolve::GetPrevTokenStrategy() const {
+    return _prevTokenStrategy;
+}
+
 TokenStrategy FormatResolve::GetTokenStrategy() const {
     return _tokenStrategy;
 }
 
-TokenAddStrategy FormatResolve::GetTokenAddStrategy() const {
-    return _tokenAddStrategy;
+NextTokenStrategy FormatResolve::GetNextTokenStrategy() const {
+    return _nextAddStrategy;
 }
 
 IndentStrategy FormatResolve::GetIndentStrategy() const {
     return _indentStrategy;
 }
 
 void FormatResolve::Reset() {
+    _prevSpaceStrategy = PrevSpaceStrategy::None;
+    _prevTokenStrategy = PrevTokenStrategy::None;
     _tokenStrategy = TokenStrategy::Origin;
-    _tokenAddStrategy = TokenAddStrategy::None;
+    _nextAddStrategy = NextTokenStrategy::None;
     _nextSpaceStrategy = NextSpaceStrategy::None;
-    _prevSpaceStrategy = PrevSpaceStrategy::None;
+
     _indentStrategy = IndentStrategy::None;
     _nextSpaceData = NextData();
     _prevSpaceData = PrevData();
@@ -88,8 +94,12 @@ void FormatResolve::SetTokenStrategy(TokenStrategy strategy) {
     _tokenStrategy = strategy;
 }
 
-void FormatResolve::SetTokenAddStrategy(TokenAddStrategy strategy) {
-    _tokenAddStrategy = strategy;
+void FormatResolve::SetPrevTokenStrategy(PrevTokenStrategy strategy) {
+    _prevTokenStrategy = strategy;
+}
+
+void FormatResolve::SetNextTokenStrategy(NextTokenStrategy strategy) {
+    _nextAddStrategy = strategy;
 }
 
 void FormatResolve::SetOriginRange(IndexRange range) {
diff --git a/CodeFormatCore/src/Format/Analyzer/SemicolonAnalyzer.cpp b/CodeFormatCore/src/Format/Analyzer/SemicolonAnalyzer.cpp
@@ -63,7 +63,7 @@ void SemicolonAnalyzer::Query(FormatState &f, LuaSyntaxNode n, const LuaSyntaxTr
         auto &strategy = it->second;
         switch (strategy) {
             case SemicolonStrategy::Add: {
-                resolve.SetTokenAddStrategy(TokenAddStrategy::StmtEndSemicolon);
+                resolve.SetNextTokenStrategy(NextTokenStrategy::StmtEndSemicolon);
                 break;
             }
             case SemicolonStrategy::Remove: {
diff --git a/CodeFormatCore/src/Format/Analyzer/TokenAnalyzer.cpp b/CodeFormatCore/src/Format/Analyzer/TokenAnalyzer.cpp
@@ -64,24 +64,33 @@ void TokenAnalyzer::Analyze(FormatState &f, const LuaSyntaxTree &t) {
 
 void TokenAnalyzer::Query(FormatState &f, LuaSyntaxNode syntaxNode, const LuaSyntaxTree &t, FormatResolve &resolve) {
     if (syntaxNode.IsToken(t)) {
+        auto itPrev = _prevTokenStrategies.find(syntaxNode.GetIndex());
+        if (itPrev != _prevTokenStrategies.end()) {
+            resolve.SetPrevTokenStrategy(itPrev->second);
+        }
+
         auto it = _tokenStrategies.find(syntaxNode.GetIndex());
         if (it != _tokenStrategies.end()) {
             resolve.SetTokenStrategy(it->second);
         }
 
-        auto it2 = _tokenAddStrategies.find(syntaxNode.GetIndex());
-        if (it2 != _tokenAddStrategies.end()) {
-            resolve.SetTokenAddStrategy(it2->second);
+        auto itNext = _nextTokenStrategies.find(syntaxNode.GetIndex());
+        if (itNext != _nextTokenStrategies.end()) {
+            resolve.SetNextTokenStrategy(itNext->second);
         }
     }
 }
 
+void TokenAnalyzer::MarkPrev(LuaSyntaxNode n, const LuaSyntaxTree &t, PrevTokenStrategy strategy) {
+    _prevTokenStrategies[n.GetIndex()] = strategy;
+}
+
 void TokenAnalyzer::Mark(LuaSyntaxNode n, const LuaSyntaxTree &t, TokenStrategy strategy) {
     _tokenStrategies[n.GetIndex()] = strategy;
 }
 
-void TokenAnalyzer::MarkAdd(LuaSyntaxNode n, const LuaSyntaxTree &t, TokenAddStrategy strategy) {
-    _tokenAddStrategies[n.GetIndex()] = strategy;
+void TokenAnalyzer::MarkNext(LuaSyntaxNode n, const LuaSyntaxTree &t, NextTokenStrategy strategy) {
+    _nextTokenStrategies[n.GetIndex()] = strategy;
 }
 
 bool TokenAnalyzer::IsRemove(LuaSyntaxNode n, const LuaSyntaxTree &t) const {
@@ -101,16 +110,16 @@ void TokenAnalyzer::TableFieldAddSep(FormatState &f, LuaSyntaxNode n, const LuaS
         }
         switch (f.GetStyle().table_separator_style) {
             case TableSeparatorStyle::Semicolon: {
-                return MarkAdd(lastToken, t, TokenAddStrategy::TableAddColon);
+                return MarkNext(lastToken, t, NextTokenStrategy::TableAddColon);
             }
             case TableSeparatorStyle::OnlyKVColon: {
                 if (n.GetChildToken('=', t).IsToken(t)) {
-                    return MarkAdd(lastToken, t, TokenAddStrategy::TableAddColon);
+                    return MarkNext(lastToken, t, NextTokenStrategy::TableAddColon);
                 }
                 // fallthrough
             }
             default: {
-                return MarkAdd(lastToken, t, TokenAddStrategy::TableAddComma);
+                return MarkNext(lastToken, t, NextTokenStrategy::TableAddComma);
             }
         }
     }
@@ -270,15 +279,18 @@ void TokenAnalyzer::AnalyzeCallExpression(FormatState &f, LuaSyntaxNode n, const
                 if (!lbrace.IsToken(t) && spaceAnalyzer) {
                     auto node = GetSingleArgStringOrTable(n, t);
                     if (node.IsToken(t)) {
-                        Mark(node, t, TokenStrategy::WithParentheses);
+                        MarkPrev(node, t, PrevTokenStrategy::LeftParentheses);
+                        MarkNext(node, t, NextTokenStrategy::RightParentheses);
                         spaceAnalyzer->SpaceAround(node, t, 0, SpaceAnalyzer::SpacePriority::First);
                     } else if (node.GetSyntaxKind(t) == LuaSyntaxNodeKind::StringLiteralExpression) {
-                        Mark(node.GetFirstToken(t), t, TokenStrategy::WithParentheses);
+                        auto firstToken = node.GetFirstToken(t);
+                        MarkPrev(firstToken, t, PrevTokenStrategy::LeftParentheses);
+                        MarkNext(firstToken, t, NextTokenStrategy::RightParentheses);
                         spaceAnalyzer->SpaceLeft(node.GetFirstToken(t), t, 0, SpaceAnalyzer::SpacePriority::First);
                     } else {
-                        Mark(node.GetFirstToken(t), t, TokenStrategy::WithLeftParentheses);
+                        MarkPrev(node.GetFirstToken(t), t, PrevTokenStrategy::LeftParentheses);
+                        MarkNext(node.GetLastToken(t), t, NextTokenStrategy::RightParentheses);
                         spaceAnalyzer->SpaceLeft(node.GetFirstToken(t), t, 0, SpaceAnalyzer::SpacePriority::First);
-                        Mark(node.GetLastToken(t), t, TokenStrategy::WithRightParentheses);
                     }
 
                     return;
@@ -310,3 +322,5 @@ void TokenAnalyzer::AnalyzeComment(FormatState &f, LuaSyntaxNode n, const LuaSyn
         }
     }
 }
+
+
diff --git a/CodeFormatCore/src/Format/FormatBuilder.cpp b/CodeFormatCore/src/Format/FormatBuilder.cpp
@@ -75,6 +75,16 @@ void FormatBuilder::DoResolve(LuaSyntaxNode &syntaxNode, const LuaSyntaxTree &t,
             }
         }
 
+        switch (resolve.GetPrevTokenStrategy()) {
+            case PrevTokenStrategy::LeftParentheses: {
+                WriteChar('(');
+                break;
+            }
+            default: {
+                break;
+            }
+        }
+
         switch (resolve.GetTokenStrategy()) {
             case TokenStrategy::Origin: {
                 WriteSyntaxNode(syntaxNode, t);
@@ -146,22 +156,6 @@ void FormatBuilder::DoResolve(LuaSyntaxNode &syntaxNode, const LuaSyntaxTree &t,
                 WriteSyntaxNode(syntaxNode, t);
                 break;
             }
-            case TokenStrategy::WithParentheses: {
-                WriteChar('(');
-                WriteSyntaxNode(syntaxNode, t);
-                WriteChar(')');
-                break;
-            }
-            case TokenStrategy::WithLeftParentheses:{
-                WriteChar('(');
-                WriteSyntaxNode(syntaxNode, t);
-                break;
-            }
-            case TokenStrategy::WithRightParentheses: {
-                WriteSyntaxNode(syntaxNode, t);
-                WriteChar(')');
-                break;
-            }
             case TokenStrategy::SpaceAfterCommentDash: {
                 auto text = syntaxNode.GetText(t);
                 std::size_t pos = 0;
@@ -178,19 +172,23 @@ void FormatBuilder::DoResolve(LuaSyntaxNode &syntaxNode, const LuaSyntaxTree &t,
             }
         }
 
-        switch (resolve.GetTokenAddStrategy()) {
-            case TokenAddStrategy::TableAddComma: {
+        switch (resolve.GetNextTokenStrategy()) {
+            case NextTokenStrategy::TableAddComma: {
                 WriteChar(',');
                 break;
             }
-            case TokenAddStrategy::TableAddColon: {
+            case NextTokenStrategy::TableAddColon: {
                 WriteChar(';');
                 break;
             }
-            case TokenAddStrategy::StmtEndSemicolon: {
+            case NextTokenStrategy::StmtEndSemicolon: {
                 WriteChar(';');
                 break;
             }
+            case NextTokenStrategy::RightParentheses: {
+                WriteChar(')');
+                break;
+            }
             default: {
                 break;
             }
diff --git a/CodeFormatLib/src/CodeFormatLib.cpp b/CodeFormatLib/src/CodeFormatLib.cpp
@@ -43,6 +43,8 @@ std::string GetDiagnosisString(DiagnosticType type) {
             return "string-quote";
         case DiagnosticType::Semicolon:
             return "semicolon";
+        case DiagnosticType::Parentheses:
+            return "parentheses";
         default: {
             break;
         }
diff --git a/CodeFormatServer/src/Service/CodeActionService.cpp b/CodeFormatServer/src/Service/CodeActionService.cpp
@@ -16,6 +16,7 @@ bool CodeActionService::Initialize() {
     CodeProtocol(DiagnosticType::Indent, "code-indent", &CodeActionService::Reformat);
     CodeProtocol(DiagnosticType::Space, "whitespace", &CodeActionService::Reformat);
     CodeProtocol(DiagnosticType::StringQuote, "string-quote", &CodeActionService::Reformat);
+    CodeProtocol(DiagnosticType::Parentheses, "parentheses", &CodeActionService::Reformat);
     CodeProtocol(DiagnosticType::EndWithNewLine, "end-with-new-line");
     CodeProtocol(DiagnosticType::NameStyle, "name-style");
     CodeProtocol(DiagnosticType::Semicolon, "semicolon");
diff --git a/CodeFormatServer/src/Service/DiagnosticService.cpp b/CodeFormatServer/src/Service/DiagnosticService.cpp
diff --git a/Test/src/FormatResult_unitest.cpp b/Test/src/FormatResult_unitest.cpp

Original file line number	Diff line number	Diff line change
`@@ -70,6 +70,17 @@ void CodeStyleChecker::BasicResolve(LuaSyntaxNode syntaxNode, const LuaSyntaxTre`
`70`	`70`	`}`
`71`	`71`	`}`
`72`	`72`
	`73`	`+ switch (resolve.GetPrevTokenStrategy()) {`
	`74`	`+ case PrevTokenStrategy::LeftParentheses: {`
	`75`	`+ d.PushDiagnostic(DiagnosticType::Parentheses, textRange,`
	`76`	`+ LText("expected ("));`
	`77`	`+ break;`
	`78`	`+ }`
	`79`	`+ default: {`
	`80`	`+ break;`
	`81`	`+ }`
	`82`	`+ }`
	`83`	`+`
`73`	`84`	`switch (resolve.GetTokenStrategy()) {`
`74`	`85`	`case TokenStrategy::StringSingleQuote: {`
`75`	`86`	`if (syntaxNode.GetTokenKind(t) == TK_STRING) {`
`@@ -117,13 +128,18 @@ void CodeStyleChecker::BasicResolve(LuaSyntaxNode syntaxNode, const LuaSyntaxTre`
`117`	`128`	`}`
`118`	`129`	`}`
`119`	`130`
`120`		`- switch (resolve.GetTokenAddStrategy()) {`
`121`		`- case TokenAddStrategy::StmtEndSemicolon: {`
	`131`	`+ switch (resolve.GetNextTokenStrategy()) {`
	`132`	`+ case NextTokenStrategy::StmtEndSemicolon: {`
`122`	`133`	`d.PushDiagnostic(DiagnosticType::Semicolon,`
`123`	`134`	`TextRange(textRange.GetEndOffset(), 1),`
`124`	`135`	`LText("expected ; at end of statement"));`
`125`	`136`	`break;`
`126`	`137`	`}`
	`138`	`+ case NextTokenStrategy::RightParentheses: {`
	`139`	`+ d.PushDiagnostic(DiagnosticType::Parentheses, textRange,`
	`140`	`+ LText("expected )"));`
	`141`	`+ break;`
	`142`	`+ }`
`127`	`143`	`default: {`
`128`	`144`	`break;`
`129`	`145`	`}`
`@@ -271,7 +287,7 @@ void CodeStyleChecker::ProcessIndentDiagnostic(LuaSyntaxNode &node, const LuaSyn`
`271`	`287`	`// if(state.GetStyle().indent_style)`
`272`	`288`	`d.PushDiagnostic(DiagnosticType::Indent,`
`273`	`289`	`currentIndentRange,`
`274`		`- GetIndentNote(indent,checkIndent.Space, checkIndent.Tab, state.GetStyle().indent_style));`
	`290`	`+ GetIndentNote(indent, checkIndent.Space, checkIndent.Tab, state.GetStyle().indent_style));`
`275`	`291`	`}`
`276`	`292`	`}`
`277`	`293`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ void SemicolonAnalyzer::Query(FormatState &f, LuaSyntaxNode n, const LuaSyntaxTr`
`63`	`63`	`auto &strategy = it->second;`
`64`	`64`	`switch (strategy) {`
`65`	`65`	`case SemicolonStrategy::Add: {`
`66`		`- resolve.SetTokenAddStrategy(TokenAddStrategy::StmtEndSemicolon);`
	`66`	`+ resolve.SetNextTokenStrategy(NextTokenStrategy::StmtEndSemicolon);`
`67`	`67`	`break;`
`68`	`68`	`}`
`69`	`69`	`case SemicolonStrategy::Remove: {`
Original file line number	Diff line number	Diff line change
`@@ -64,24 +64,33 @@ void TokenAnalyzer::Analyze(FormatState &f, const LuaSyntaxTree &t) {`
`64`	`64`
`65`	`65`	`void TokenAnalyzer::Query(FormatState &f, LuaSyntaxNode syntaxNode, const LuaSyntaxTree &t, FormatResolve &resolve) {`
`66`	`66`	`if (syntaxNode.IsToken(t)) {`
	`67`	`+ auto itPrev = _prevTokenStrategies.find(syntaxNode.GetIndex());`
	`68`	`+ if (itPrev != _prevTokenStrategies.end()) {`
	`69`	`+ resolve.SetPrevTokenStrategy(itPrev->second);`
	`70`	`+ }`
	`71`	`+`
`67`	`72`	`auto it = _tokenStrategies.find(syntaxNode.GetIndex());`
`68`	`73`	`if (it != _tokenStrategies.end()) {`
`69`	`74`	`resolve.SetTokenStrategy(it->second);`
`70`	`75`	`}`
`71`	`76`
`72`		`- auto it2 = _tokenAddStrategies.find(syntaxNode.GetIndex());`
`73`		`- if (it2 != _tokenAddStrategies.end()) {`
`74`		`- resolve.SetTokenAddStrategy(it2->second);`
	`77`	`+ auto itNext = _nextTokenStrategies.find(syntaxNode.GetIndex());`
	`78`	`+ if (itNext != _nextTokenStrategies.end()) {`
	`79`	`+ resolve.SetNextTokenStrategy(itNext->second);`
`75`	`80`	`}`
`76`	`81`	`}`
`77`	`82`	`}`
`78`	`83`
	`84`	`+void TokenAnalyzer::MarkPrev(LuaSyntaxNode n, const LuaSyntaxTree &t, PrevTokenStrategy strategy) {`
	`85`	`+ _prevTokenStrategies[n.GetIndex()] = strategy;`
	`86`	`+}`
	`87`	`+`
`79`	`88`	`void TokenAnalyzer::Mark(LuaSyntaxNode n, const LuaSyntaxTree &t, TokenStrategy strategy) {`
`80`	`89`	`_tokenStrategies[n.GetIndex()] = strategy;`
`81`	`90`	`}`
`82`	`91`
`83`		`-void TokenAnalyzer::MarkAdd(LuaSyntaxNode n, const LuaSyntaxTree &t, TokenAddStrategy strategy) {`
`84`		`- _tokenAddStrategies[n.GetIndex()] = strategy;`
	`92`	`+void TokenAnalyzer::MarkNext(LuaSyntaxNode n, const LuaSyntaxTree &t, NextTokenStrategy strategy) {`
	`93`	`+ _nextTokenStrategies[n.GetIndex()] = strategy;`
`85`	`94`	`}`
`86`	`95`
`87`	`96`	`bool TokenAnalyzer::IsRemove(LuaSyntaxNode n, const LuaSyntaxTree &t) const {`
`@@ -101,16 +110,16 @@ void TokenAnalyzer::TableFieldAddSep(FormatState &f, LuaSyntaxNode n, const LuaS`
`101`	`110`	`}`
`102`	`111`	`switch (f.GetStyle().table_separator_style) {`
`103`	`112`	`case TableSeparatorStyle::Semicolon: {`
`104`		`- return MarkAdd(lastToken, t, TokenAddStrategy::TableAddColon);`
	`113`	`+ return MarkNext(lastToken, t, NextTokenStrategy::TableAddColon);`
`105`	`114`	`}`
`106`	`115`	`case TableSeparatorStyle::OnlyKVColon: {`
`107`	`116`	`if (n.GetChildToken('=', t).IsToken(t)) {`
`108`		`- return MarkAdd(lastToken, t, TokenAddStrategy::TableAddColon);`
	`117`	`+ return MarkNext(lastToken, t, NextTokenStrategy::TableAddColon);`
`109`	`118`	`}`
`110`	`119`	`// fallthrough`
`111`	`120`	`}`
`112`	`121`	`default: {`
`113`		`- return MarkAdd(lastToken, t, TokenAddStrategy::TableAddComma);`
	`122`	`+ return MarkNext(lastToken, t, NextTokenStrategy::TableAddComma);`
`114`	`123`	`}`
`115`	`124`	`}`
`116`	`125`	`}`
`@@ -270,15 +279,18 @@ void TokenAnalyzer::AnalyzeCallExpression(FormatState &f, LuaSyntaxNode n, const`
`270`	`279`	`if (!lbrace.IsToken(t) && spaceAnalyzer) {`
`271`	`280`	`auto node = GetSingleArgStringOrTable(n, t);`
`272`	`281`	`if (node.IsToken(t)) {`
`273`		`- Mark(node, t, TokenStrategy::WithParentheses);`
	`282`	`+ MarkPrev(node, t, PrevTokenStrategy::LeftParentheses);`
	`283`	`+ MarkNext(node, t, NextTokenStrategy::RightParentheses);`
`274`	`284`	`spaceAnalyzer->SpaceAround(node, t, 0, SpaceAnalyzer::SpacePriority::First);`
`275`	`285`	`} else if (node.GetSyntaxKind(t) == LuaSyntaxNodeKind::StringLiteralExpression) {`
`276`		`- Mark(node.GetFirstToken(t), t, TokenStrategy::WithParentheses);`
	`286`	`+ auto firstToken = node.GetFirstToken(t);`
	`287`	`+ MarkPrev(firstToken, t, PrevTokenStrategy::LeftParentheses);`
	`288`	`+ MarkNext(firstToken, t, NextTokenStrategy::RightParentheses);`
`277`	`289`	`spaceAnalyzer->SpaceLeft(node.GetFirstToken(t), t, 0, SpaceAnalyzer::SpacePriority::First);`
`278`	`290`	`} else {`
`279`		`- Mark(node.GetFirstToken(t), t, TokenStrategy::WithLeftParentheses);`
	`291`	`+ MarkPrev(node.GetFirstToken(t), t, PrevTokenStrategy::LeftParentheses);`
	`292`	`+ MarkNext(node.GetLastToken(t), t, NextTokenStrategy::RightParentheses);`
`280`	`293`	`spaceAnalyzer->SpaceLeft(node.GetFirstToken(t), t, 0, SpaceAnalyzer::SpacePriority::First);`
`281`		`- Mark(node.GetLastToken(t), t, TokenStrategy::WithRightParentheses);`
`282`	`294`	`}`
`283`	`295`
`284`	`296`	`return;`
`@@ -310,3 +322,5 @@ void TokenAnalyzer::AnalyzeComment(FormatState &f, LuaSyntaxNode n, const LuaSyn`
`310`	`322`	`}`
`311`	`323`	`}`
`312`	`324`	`}`
	`325`	`+`
	`326`	`+`
Original file line number	Diff line number	Diff line change
`@@ -43,6 +43,8 @@ std::string GetDiagnosisString(DiagnosticType type) {`
`43`	`43`	`return "string-quote";`
`44`	`44`	`case DiagnosticType::Semicolon:`
`45`	`45`	`return "semicolon";`
	`46`	`+ case DiagnosticType::Parentheses:`
	`47`	`+ return "parentheses";`
`46`	`48`	`default: {`
`47`	`49`	`break;`
`48`	`50`	`}`