support allow_non_indented_comments, FIX #162

CppCXY · CppCXY · commit 70cc1200c493 · 2024-02-22T19:59:39.000+08:00
diff --git a/CodeFormatCore/include/CodeFormatCore/Config/LuaStyle.h b/CodeFormatCore/include/CodeFormatCore/Config/LuaStyle.h
@@ -127,6 +127,7 @@ class LuaStyle {
      */
     bool keep_indents_on_empty_lines = false;
 
+    bool allow_non_indented_comments = false;
     // [line space]
 
     LineSpace line_space_after_if_statement = LineSpace(LineSpaceType::Keep);
diff --git a/CodeFormatCore/include/CodeFormatCore/Diagnostic/CodeStyle/CodeStyleChecker.h b/CodeFormatCore/include/CodeFormatCore/Diagnostic/CodeStyle/CodeStyleChecker.h
@@ -32,7 +32,7 @@ class CodeStyleChecker {
                                  const LuaSyntaxTree &t,
                                  DiagnosticBuilder &d);
 
-    std::string GetIndentNote(IndentState indent, IndentStyle style);
+    std::string GetIndentNote(IndentState indent, std::size_t checkSpace, std::size_t checkTab, IndentStyle style);
 
     std::string GetAdditionalNote(LuaSyntaxNode &left, LuaSyntaxNode &right, const LuaSyntaxTree &t);
 
diff --git a/CodeFormatCore/include/CodeFormatCore/Format/Analyzer/FormatStrategy.h b/CodeFormatCore/include/CodeFormatCore/Format/Analyzer/FormatStrategy.h
@@ -50,7 +50,8 @@ enum class IndentType {
     InvertIndentation,
     WhenNewLine,
     WhenPrevIndent,
-    WhenExceedLinebreak
+    WhenExceedLinebreak,
+    Keep,
 };
 
 struct IndentData {
diff --git a/CodeFormatCore/include/CodeFormatCore/Format/Analyzer/IndentationAnalyzer.h b/CodeFormatCore/include/CodeFormatCore/Format/Analyzer/IndentationAnalyzer.h
@@ -48,6 +48,10 @@ class IndentationAnalyzer : public FormatAnalyzer {
 
     void ProcessExceedLinebreak(FormatState &f, LuaSyntaxNode syntaxNode, const LuaSyntaxTree &t);
 
+    void NeverIndentCommentOnIfBranch(FormatState &f, LuaSyntaxNode syntaxNode, const LuaSyntaxTree &t);
+
+    void AllowNonIndentedComment(FormatState &f, LuaSyntaxNode syntaxNode, const LuaSyntaxTree &t);
+
     std::unordered_map<std::size_t, IndentData> _indent;
     std::unordered_set<std::size_t> _indentMark;
 
diff --git a/CodeFormatCore/src/Config/LuaStyle.cpp b/CodeFormatCore/src/Config/LuaStyle.cpp
@@ -330,6 +330,8 @@ void LuaStyle::Parse(std::map<std::string, std::string, std::less<>> &configMap)
 
     BOOL_OPTION(keep_indents_on_empty_lines)
 
+    BOOL_OPTION(allow_non_indented_comments)
+
     std::vector<std::pair<std::string, LineSpace &>> fieldList = {
             {"line_space_after_if_statement",              line_space_after_if_statement             },
             {"line_space_after_do_statement",              line_space_after_do_statement             },
diff --git a/CodeFormatCore/src/Diagnostic/CodeStyle/CodeStyleChecker.cpp b/CodeFormatCore/src/Diagnostic/CodeStyle/CodeStyleChecker.cpp
@@ -268,18 +268,17 @@ void CodeStyleChecker::ProcessIndentDiagnostic(LuaSyntaxNode &node, const LuaSyn
     }
 
     if (indent.TabSize != checkIndent.Tab || indent.SpaceSize != checkIndent.Space) {
+        // if(state.GetStyle().indent_style)
         d.PushDiagnostic(DiagnosticType::Indent,
                          currentIndentRange,
-                         util::format("{}, found {} whitespace, {} tab",
-                                      GetIndentNote(indent, state.GetStyle().indent_style),
-                                      checkIndent.Space, checkIndent.Tab));
+                         GetIndentNote(indent,checkIndent.Space, checkIndent.Tab, state.GetStyle().indent_style));
     }
 }
 
-std::string CodeStyleChecker::GetIndentNote(IndentState indent, IndentStyle style) {
+std::string CodeStyleChecker::GetIndentNote(IndentState indent, std::size_t checkSpace, std::size_t checkTab, IndentStyle style) {
     if (style == IndentStyle::Tab) {
-        return util::format("expected {} tab indent", indent.TabSize);
+        return util::format("expected {} tab indent, found {} tab", indent.TabSize, checkTab);
     } else {
-        return util::format("expected {} whitespace indent", indent.SpaceSize);
+        return util::format("expected {} whitespace indent, found {} whitespace", indent.SpaceSize, checkSpace);
     }
 }
diff --git a/CodeFormatCore/src/Format/Analyzer/IndentationAnalyzer.cpp b/CodeFormatCore/src/Format/Analyzer/IndentationAnalyzer.cpp
@@ -18,35 +18,10 @@ void IndentationAnalyzer::Analyze(FormatState &f, const LuaSyntaxTree &t) {
                 case LuaSyntaxNodeKind::Block: {
                     AddIndenter(syntaxNode, t);
                     if (f.GetStyle().never_indent_comment_on_if_branch) {
-                        auto ifStmt = syntaxNode.GetParent(t);
-                        if (ifStmt.GetSyntaxKind(t) == LuaSyntaxNodeKind::IfStatement) {
-                            auto ifBranch = syntaxNode.GetNextToken(t);
-                            if (ifBranch.GetTokenKind(t) == TK_ELSEIF || ifBranch.GetTokenKind(t) == TK_ELSE) {
-                                auto bodyChildren = syntaxNode.GetChildren(t);
-                                bool isCommentOnly = true;
-                                for (auto bodyChild: bodyChildren) {
-                                    if (bodyChild.IsNode(t)) {
-                                        isCommentOnly = false;
-                                        break;
-                                    }
-                                }
-                                if (isCommentOnly) {
-                                    break;
-                                }
-                                std::size_t siblingLine = ifBranch.GetStartLine(t);
-                                for (auto it = bodyChildren.rbegin(); it != bodyChildren.rend(); it++) {
-                                    auto n = *it;
-                                    if (n.GetTokenKind(t) != TK_SHORT_COMMENT) {
-                                        break;
-                                    }
-                                    auto commentLine = n.GetStartLine(t);
-                                    if (commentLine + 1 == siblingLine) {
-                                        AddIndenter(n, t, IndentData(IndentType::InvertIndentation));
-                                        siblingLine = commentLine;
-                                    }
-                                }
-                            }
-                        }
+                        NeverIndentCommentOnIfBranch(f, syntaxNode, t);
+                    }
+                    if (f.GetStyle().allow_non_indented_comments) {
+                        AllowNonIndentedComment(f, syntaxNode, t);
                     }
                     break;
                 }
@@ -176,6 +151,10 @@ void IndentationAnalyzer::Query(FormatState &f, LuaSyntaxNode n, const LuaSyntax
                 }
                 break;
             }
+            case IndentType::Keep: {
+                resolve.SetIndent(0, IndentStrategy::Absolute);
+                break;
+            }
             default: {
                 break;
             }
@@ -354,3 +333,45 @@ void IndentationAnalyzer::ProcessExceedLinebreak(FormatState &f, LuaSyntaxNode s
         AddIndenter(c, t, IndentData(IndentType::WhenNewLine, group.Indent));
     }
 }
+
+void IndentationAnalyzer::NeverIndentCommentOnIfBranch(FormatState &f, LuaSyntaxNode syntaxNode, const LuaSyntaxTree &t) {
+    auto ifStmt = syntaxNode.GetParent(t);
+    if (ifStmt.GetSyntaxKind(t) == LuaSyntaxNodeKind::IfStatement) {
+        auto ifBranch = syntaxNode.GetNextToken(t);
+        if (ifBranch.GetTokenKind(t) == TK_ELSEIF || ifBranch.GetTokenKind(t) == TK_ELSE) {
+            auto bodyChildren = syntaxNode.GetChildren(t);
+            bool isCommentOnly = true;
+            for (auto bodyChild: bodyChildren) {
+                if (bodyChild.IsNode(t)) {
+                    isCommentOnly = false;
+                    break;
+                }
+            }
+            if (isCommentOnly) {
+                return;
+            }
+            std::size_t siblingLine = ifBranch.GetStartLine(t);
+            for (auto it = bodyChildren.rbegin(); it != bodyChildren.rend(); it++) {
+                auto n = *it;
+                if (n.GetTokenKind(t) != TK_SHORT_COMMENT) {
+                    break;
+                }
+                auto commentLine = n.GetStartLine(t);
+                if (commentLine + 1 == siblingLine) {
+                    AddIndenter(n, t, IndentData(IndentType::InvertIndentation));
+                    siblingLine = commentLine;
+                }
+            }
+        }
+    }
+}
+
+void IndentationAnalyzer::AllowNonIndentedComment(FormatState &f, LuaSyntaxNode syntaxNode, const LuaSyntaxTree &t) {
+    for (auto n: syntaxNode.GetChildren(t)) {
+        if (n.IsToken(t) && (n.GetTokenKind(t) == TK_SHORT_COMMENT || n.GetTokenKind(t) == TK_LONG_COMMENT)) {
+            if (n.GetStartCol(t) == 0) {
+                AddIndenter(n, t, IndentData(IndentType::Keep));
+            }
+        }
+    }
+}
diff --git a/CodeFormatCore/src/Format/FormatState.cpp b/CodeFormatCore/src/Format/FormatState.cpp
@@ -173,7 +173,7 @@ void FormatState::DfsForeach(std::vector<LuaSyntaxNode> &startNodes,
 
             if (resolve.GetIndentStrategy() != IndentStrategy::None) {
                 auto indent = resolve.GetIndent();
-                if (indent == 0) {
+                if (indent == 0 && resolve.GetIndentStrategy() != IndentStrategy::Absolute) {
                     if (_formatStyle.indent_style == IndentStyle::Space) {
                         indent = _formatStyle.indent_size;
                     } else {
diff --git a/Test/src/FormatStyle_unitest.cpp b/Test/src/FormatStyle_unitest.cpp
@@ -1990,4 +1990,39 @@ local t = true == false or a < 2 and b > 3 or c <= 4 and d >= 5 or e ~= 6 and f
 local t = true==false or a<2 and b>3 or c<=4 and d>=5 or e~=6 and f==7
 )",
             style));
+}
+
+TEST(FormatByStyleOption, allow_non_indented_comments) {
+    LuaStyle style;
+
+    style.allow_non_indented_comments = false;
+    EXPECT_TRUE(TestHelper::TestFormatted(
+            R"(
+function f()
+    --wjfowoj
+
+    local t = 123
+end
+
+do
+--12313
+    local t = 123
+    print(t)
+end
+)",
+            R"(
+function f()
+    --wjfowoj
+
+    local t = 123
+end
+
+do
+--12313
+    local t = 123
+    print(t)
+end
+)",
+            style));
+
 }
diff --git a/lua.template.editorconfig b/lua.template.editorconfig
@@ -78,6 +78,7 @@ space_before_inline_comment = 1
 
 # [operator space]
 space_around_math_operator = true
+# space_around_math_operator.exponent = false
 
 space_after_comma = true
 
@@ -121,6 +122,8 @@ never_indent_before_if_condition = false
 never_indent_comment_on_if_branch = false
 
 keep_indents_on_empty_lines = false
+
+allow_non_indented_comments = false
 # [line space]
 
 # The following configuration supports four expressions

Original file line number	Diff line number	Diff line change
`@@ -268,18 +268,17 @@ void CodeStyleChecker::ProcessIndentDiagnostic(LuaSyntaxNode &node, const LuaSyn`
`268`	`268`	`}`
`269`	`269`
`270`	`270`	`if (indent.TabSize != checkIndent.Tab \|\| indent.SpaceSize != checkIndent.Space) {`
	`271`	`+ // if(state.GetStyle().indent_style)`
`271`	`272`	`d.PushDiagnostic(DiagnosticType::Indent,`
`272`	`273`	`currentIndentRange,`
`273`		`- util::format("{}, found {} whitespace, {} tab",`
`274`		`- GetIndentNote(indent, state.GetStyle().indent_style),`
`275`		`- checkIndent.Space, checkIndent.Tab));`
	`274`	`+ GetIndentNote(indent,checkIndent.Space, checkIndent.Tab, state.GetStyle().indent_style));`
`276`	`275`	`}`
`277`	`276`	`}`
`278`	`277`
`279`		`-std::string CodeStyleChecker::GetIndentNote(IndentState indent, IndentStyle style) {`
	`278`	`+std::string CodeStyleChecker::GetIndentNote(IndentState indent, std::size_t checkSpace, std::size_t checkTab, IndentStyle style) {`
`280`	`279`	`if (style == IndentStyle::Tab) {`
`281`		`- return util::format("expected {} tab indent", indent.TabSize);`
	`280`	`+ return util::format("expected {} tab indent, found {} tab", indent.TabSize, checkTab);`
`282`	`281`	`} else {`
`283`		`- return util::format("expected {} whitespace indent", indent.SpaceSize);`
	`282`	`+ return util::format("expected {} whitespace indent, found {} whitespace", indent.SpaceSize, checkSpace);`
`284`	`283`	`}`
`285`	`284`	`}`