implement align_continuous_inline_comment

Author: CppCXY

CodeService/src/Format/Analyzer/AlignAnalyzer.cpp

@@ -63,8 +63,24 @@ void AlignAnalyzer::Analyze(FormatState &f, const LuaSyntaxTree &t) {
                     break;
                 }
             }
+        } else {
+            switch (syntaxNode.GetTokenKind(t)) {
+                case TK_SHORT_COMMENT: {
+                    if (f.GetStyle().align_continuous_inline_comment) {
+                        AnalyzeInlineComment(f, syntaxNode, t);
+                    }
+                    break;
+                }
+                default: {
+                    break;
+                }
+            }
         }
     }
+
+    for (auto &group: _inlineCommentGroup) {
+        PushAlignGroup(AlignStrategy::AlignComment, group);
+    }
 }
 
 void AlignAnalyzer::Query(FormatState &f, LuaSyntaxNode &syntaxNode, const LuaSyntaxTree &t, FormatResolve &resolve) {
@@ -91,6 +107,10 @@ void AlignAnalyzer::Query(FormatState &f, LuaSyntaxNode &syntaxNode, const LuaSy
                 resolve.SetIndent(alignGroup.AlignPos, IndentStrategy::Absolute);
                 break;
             }
+            case AlignStrategy::AlignComment: {
+                resolve.SetAlign(alignGroup.AlignPos);
+                break;
+            }
             default: {
                 break;
             }
@@ -349,6 +369,23 @@ AlignAnalyzer::ResolveAlignGroup(FormatState &f, std::size_t groupIndex, AlignGr
             }
             break;
         }
+        case AlignStrategy::AlignComment: {
+            std::size_t maxDis = 0;
+            auto &file = t.GetFile();
+            for (auto i: group.SyntaxGroup) {
+                auto comment = LuaSyntaxNode(i);
+                if (comment.IsToken(t)) {
+                    auto prev = comment.GetPrevToken(t);
+                    auto newPos =
+                            file.GetColumn(prev.GetTextRange(t).EndOffset) + f.GetStyle().space_before_inline_comment + 1;
+                    if (newPos > maxDis) {
+                        maxDis = newPos;
+                    }
+                    _resolveGroupIndex[comment.GetIndex()] = groupIndex;
+                }
+            }
+            group.AlignPos = maxDis;
+        }
         default: {
             break;
         }
@@ -459,3 +496,31 @@ void
 AlignAnalyzer::AnalyzeContinuousSimilarCallArgs(FormatState &f, LuaSyntaxNode &syntaxNode, const LuaSyntaxTree &t) {
 
 }
+
+void AlignAnalyzer::AnalyzeInlineComment(FormatState &f, LuaSyntaxNode &syntaxNode, const LuaSyntaxTree &t) {
+    auto prevToken = syntaxNode.GetPrevToken(t);
+    if (prevToken.IsNull(t)) {
+        return;
+    }
+    auto currentLine = syntaxNode.GetStartLine(t);
+    if (prevToken.GetEndLine(t) != currentLine) {
+        return;
+    }
+    // now it is inline comment
+    if (_inlineCommentGroup.empty()) {
+        _inlineCommentGroup.emplace_back();
+    }
+    auto &topGroup = _inlineCommentGroup.back();
+    if (topGroup.empty()) {
+        topGroup.push_back(syntaxNode.GetIndex());
+        return;
+    }
+
+    auto lastComment = LuaSyntaxNode(topGroup.back());
+    if (currentLine - lastComment.GetEndLine(t) > 2) {
+        auto &newTopGroup = _inlineCommentGroup.emplace_back();
+        newTopGroup.push_back(syntaxNode.GetIndex());
+    } else {
+        topGroup.push_back(syntaxNode.GetIndex());
+    }
+}

Test/src/FormatStyle_unitest.cpp

@@ -1159,4 +1159,77 @@ p(1,2,3,)
             R"(
 p(1, 2, 3)
 )", style));
+}
+
+TEST(FormatByStyleOption, align_continuous_inline_comment){
+    LuaStyle style;
+
+    style.align_continuous_inline_comment = false;
+    EXPECT_TRUE(TestHelper::TestFormatted(
+            R"(
+function f() --hello world
+    local t = 132 --1313
+end
+
+local t = {
+    { 11111, 2,   3333333333333 }, --hello
+    { 123,   345, 46 }, --yes
+    { 1,     2,   3 }, --hh
+}
+
+local t = {
+    aa = 1, -- e1
+    bbaa = 2, --bb
+}
+)",
+            R"(
+function f() --hello world
+    local t = 132 --1313
+end
+
+local t = {
+    { 11111, 2,   3333333333333 }, --hello
+    { 123,   345, 46 }, --yes
+    { 1,     2,   3 }, --hh
+}
+
+local t = {
+    aa = 1, -- e1
+    bbaa = 2, --bb
+}
+)", style));
+    style.align_continuous_inline_comment = true;
+    EXPECT_TRUE(TestHelper::TestFormatted(
+            R"(
+function f() --hello world
+    local t = 132 --1313
+end
+
+local t = {
+    { 11111, 2,   3333333333333 }, --hello
+    { 123,   345, 46 }, --yes
+    { 1,     2,   3 }, --hh
+}
+
+local t = {
+    aa = 1, -- e1
+    bbaa = 2, --bb
+}
+)",
+            R"(
+function f()      --hello world
+    local t = 132 --1313
+end
+
+local t = {
+    { 11111, 2,   3333333333333 }, --hello
+    { 123,   345, 46 },            --yes
+    { 1,     2,   3 },             --hh
+}
+
+local t = {
+    aa = 1,   -- e1
+    bbaa = 2, --bb
+}
+)", style));
 }

include/CodeService/Config/LuaStyle.h

@@ -100,6 +100,8 @@ class LuaStyle {
     // not implement now
     bool align_continuous_similar_call_args = false;
 
+    bool align_continuous_inline_comment = false;
+
     bool align_array_table = true;
 
     // not implement now

include/CodeService/Format/Analyzer/AlignAnalyzer.h

@@ -37,7 +37,11 @@ class AlignAnalyzer : public FormatAnalyzer {
 
     void AnalyzeContinuousSimilarCallArgs(FormatState &f, LuaSyntaxNode &syntaxNode, const LuaSyntaxTree &t);
 
+    void AnalyzeInlineComment(FormatState &f, LuaSyntaxNode &syntaxNode, const LuaSyntaxTree &t);
+
     std::vector<AlignGroup> _alignGroup;
     std::unordered_map<std::size_t, std::size_t> _startNodeToGroupIndex;
     std::unordered_map<std::size_t, std::size_t> _resolveGroupIndex;
+
+    std::vector<std::vector<std::size_t>> _inlineCommentGroup;
 };

include/CodeService/Format/Analyzer/FormatStrategy.h

@@ -105,11 +105,12 @@ struct LineBreakData {
 enum class AlignStrategy {
     Normal,
     AlignToEq,
-    AlignToFirst
+    AlignToFirst,
+    AlignComment,
 };
 
 struct AlignGroup {
-    AlignGroup(AlignStrategy strategy, std::vector<std::size_t> &group)
+    AlignGroup(AlignStrategy strategy, const std::vector<std::size_t> &group)
             : Strategy(strategy), SyntaxGroup(group), Resolve(false), AlignPos(0) {}
 
     AlignStrategy Strategy;