优化范围格式化和type格式化, 支持对format disable的处理

CppCXY · CppCXY · commit 58caad2fe78d · 2023-03-30T13:41:00.000+08:00
diff --git a/CodeFormatLib/src/CodeFormatLib.cpp b/CodeFormatLib/src/CodeFormatLib.cpp
@@ -146,6 +146,11 @@ int range_format(lua_State *L) {
                 return 1;
             }
             auto &formattedText = formattedTextResult.Data;
+            if(formattedText.empty()){
+                lua_pushboolean(L, false);
+                return 1;
+            }
+
             lua_pushboolean(L, true);
             lua_pushlstring(L, formattedText.c_str(), formattedText.size());
             lua_pushinteger(L, range.StartLine);
diff --git a/CodeFormatServer/src/LSP/LSPHandle.cpp b/CodeFormatServer/src/LSP/LSPHandle.cpp
@@ -231,6 +231,10 @@ std::shared_ptr<lsp::Serializable> LSPHandle::OnRangeFormatting(
     range.EndLine = params->range.end.line;
 
     auto newText = _server->GetService<FormatService>()->RangeFormat(syntaxTree, luaStyle, range);
+    if(newText.empty()){
+        result->hasError = true;
+        return result;
+    }
 
     auto &edit = result->edits.emplace_back();
     edit.newText = std::move(newText);
diff --git a/CodeService/src/Format/Analyzer/FormatDocAnalyze.cpp b/CodeService/src/Format/Analyzer/FormatDocAnalyze.cpp
@@ -1,11 +1,10 @@
 #include "CodeService/Format/Analyzer/FormatDocAnalyze.h"
+#include "CodeService/Format/FormatState.h"
 #include "LuaParser/Lexer/LuaTokenTypeDetail.h"
-#include "Util/StringUtil.h"
 #include "LuaParser/Lexer/TextReader.h"
-#include "CodeService/Format/FormatState.h"
+#include "Util/StringUtil.h"
 
 FormatDocAnalyze::FormatDocAnalyze() {
-
 }
 
 void FormatDocAnalyze::Analyze(FormatState &f, const LuaSyntaxTree &t) {
@@ -27,8 +26,7 @@ void FormatDocAnalyze::Analyze(FormatState &f, const LuaSyntaxTree &t) {
 void FormatDocAnalyze::ComplexAnalyze(FormatState &f, const LuaSyntaxTree &t) {
 }
 
-void
-FormatDocAnalyze::Query(FormatState &f, LuaSyntaxNode &syntaxNode, const LuaSyntaxTree &t, FormatResolve &resolve) {
+void FormatDocAnalyze::Query(FormatState &f, LuaSyntaxNode &syntaxNode, const LuaSyntaxTree &t, FormatResolve &resolve) {
     auto it = _ignores.find(syntaxNode.GetIndex());
     if (it == _ignores.end()) {
         return;
@@ -102,8 +100,7 @@ void FormatDocAnalyze::AnalyzeDocFormat(LuaSyntaxNode n, FormatState &f, const L
                         break;
                     } else if (action == "disable-next") {
                         auto nextNode = n.GetNextSibling(t);
-                        while (!nextNode.IsNull(t)
-                               && !detail::multi_match::StatementMatch(nextNode.GetSyntaxKind(t))) {
+                        while (!nextNode.IsNull(t) && !detail::multi_match::StatementMatch(nextNode.GetSyntaxKind(t))) {
                             nextNode.ToNext(t);
                         }
                         if (nextNode.IsNode(t)) {
@@ -124,7 +121,7 @@ void FormatDocAnalyze::AnalyzeDocFormat(LuaSyntaxNode n, FormatState &f, const L
 
                 return;
             }
-            case ParseState::List : {
+            case ParseState::List: {
                 return;
             }
         }
@@ -136,3 +133,11 @@ void FormatDocAnalyze::AddIgnoreRange(const IndexRange &range, const LuaSyntaxTr
     auto endIndex = LuaSyntaxNode(range.EndIndex).GetLastToken(t).GetIndex();
     _ignores[startIndex] = IndexRange(startIndex, endIndex);
 }
+
+std::vector<IndexRange> FormatDocAnalyze::GetIgnores() const {
+    std::vector<IndexRange> result;
+    for (auto p: _ignores) {
+        result.push_back(p.second);
+    }
+    return result;
+}
diff --git a/CodeService/src/Format/FormatState.cpp b/CodeService/src/Format/FormatState.cpp
@@ -1,23 +1,24 @@
 #include "CodeService/Format/FormatState.h"
-#include "CodeService/Format/Analyzer/SpaceAnalyzer.h"
+#include "CodeService/Format/Analyzer/AlignAnalyzer.h"
+#include "CodeService/Format/Analyzer/FormatDocAnalyze.h"
 #include "CodeService/Format/Analyzer/IndentationAnalyzer.h"
 #include "CodeService/Format/Analyzer/LineBreakAnalyzer.h"
-#include "CodeService/Format/Analyzer/AlignAnalyzer.h"
+#include "CodeService/Format/Analyzer/SpaceAnalyzer.h"
 #include "CodeService/Format/Analyzer/TokenAnalyzer.h"
-#include "CodeService/Format/Analyzer/FormatDocAnalyze.h"
 
 FormatState::FormatState(Mode mode)
-        : _currentWidth(0),
-          _mode(mode) {
+    : _currentWidth(0),
+      _mode(mode),
+      _foreachContinue(true) {
 }
 
 std::size_t &FormatState::CurrentWidth() {
     return _currentWidth;
 }
 
 EndOfLine FormatState::GetEndOfLine() const {
-    return _formatStyle.detect_end_of_line ?
-           _fileEndOfLine : _formatStyle.end_of_line;;
+    return _formatStyle.detect_end_of_line ? _fileEndOfLine : _formatStyle.end_of_line;
+    ;
 }
 
 void FormatState::SetFormatStyle(LuaStyle &style) {
@@ -141,6 +142,7 @@ void FormatState::AddIgnore(IndexRange range) {
 void FormatState::DfsForeach(std::vector<LuaSyntaxNode> &startNodes,
                              const LuaSyntaxTree &t,
                              const FormatState::FormatHandle &enterHandle) {
+    _foreachContinue = true;
     std::vector<Traverse> traverseStack;
     for (auto it = startNodes.rbegin(); it != startNodes.rend(); it++) {
         traverseStack.emplace_back(*it, TraverseEvent::Enter);
@@ -155,7 +157,7 @@ void FormatState::DfsForeach(std::vector<LuaSyntaxNode> &startNodes,
             traverseStack.back().Event = TraverseEvent::Exit;
             if (_ignoreRange.EndIndex != 0) {
                 auto index = traverse.Node.GetIndex();
-                if(index >= _ignoreRange.StartIndex && index <= _ignoreRange.EndIndex){
+                if (index >= _ignoreRange.StartIndex && index <= _ignoreRange.EndIndex) {
                     continue;
                 }
             }
@@ -198,6 +200,9 @@ void FormatState::DfsForeach(std::vector<LuaSyntaxNode> &startNodes,
             }
 
             enterHandle(traverse.Node, t, resolve);
+            if (!_foreachContinue) {
+                return;
+            }
         } else {
             traverseStack.pop_back();
             if (GetCurrentIndent().SyntaxNode.GetIndex() == traverse.Node.GetIndex()) {
@@ -222,5 +227,6 @@ void FormatState::AddAbsoluteIndent(LuaSyntaxNode &syntaxNoe, std::size_t indent
     }
 }
 
-
-
+void FormatState::StopDfsForeach() {
+    _foreachContinue = false;
+}
diff --git a/CodeService/src/RangeFormat/RangeFormatBuilder.cpp b/CodeService/src/RangeFormat/RangeFormatBuilder.cpp
@@ -1,36 +1,35 @@
 #include "CodeService/RangeFormat/RangeFormatBuilder.h"
+#include "CodeService/Format/Analyzer/FormatDocAnalyze.h"
 #include "LuaParser/Lexer/LuaTokenTypeDetail.h"
 
 RangeFormatBuilder::RangeFormatBuilder(LuaStyle &style, FormatRange &range)
-        : FormatBuilder(style), _validRange(false), _range(range) {
-
+    : FormatBuilder(style), _validRange(Valid::Init), _range(range) {
 }
 
 std::string RangeFormatBuilder::GetFormatResult(const LuaSyntaxTree &t) {
     _state.Analyze(t);
-    auto root = t.GetRootNode();
-    std::vector<LuaSyntaxNode> startNodes;
-    for (auto child: root.GetChildren(t)) {
-        auto childEndLine = child.GetEndLine(t);
-        if (childEndLine >= _range.StartLine) {
-            startNodes.push_back(child);
-        }
-        if (childEndLine > _range.EndLine) {
-            break;
+
+    auto formatDoc = _state.GetAnalyzer<FormatDocAnalyze>();
+    if (formatDoc) {
+        auto ignores = formatDoc->GetIgnores();
+        for (auto &ignore: ignores) {
+            auto ignoreStartLine = LuaSyntaxNode(ignore.StartIndex).GetStartLine(t);
+            auto ignoreEndLine = LuaSyntaxNode(ignore.EndIndex).GetEndLine(t);
+            if ((_range.StartLine >= ignoreStartLine && _range.StartLine <= ignoreEndLine) || (_range.EndLine >= ignoreStartLine && _range.StartLine < ignoreStartLine)) {
+                return "";
+            }
         }
     }
 
-    LuaSyntaxNode n;
-    _state.AddRelativeIndent(n, 0);
+    auto root = t.GetRootNode();
+    std::vector<LuaSyntaxNode> startNodes = {root};
 
-    _state.DfsForeach(startNodes, t, [this](LuaSyntaxNode &syntaxNode,
-                                            const LuaSyntaxTree &t,
-                                            FormatResolve &resolve) {
-        CheckRange(syntaxNode, t);
+    _state.DfsForeach(startNodes, t, [this](LuaSyntaxNode &syntaxNode, const LuaSyntaxTree &t, FormatResolve &resolve) {
+        CheckRange(syntaxNode, t, resolve);
         DoResolve(syntaxNode, t, resolve);
     });
 
-    _validRange = true;
+    _validRange = Valid::Process;
     DealEndWithNewLine(true);
     return _formattedText;
 }
@@ -40,7 +39,7 @@ FormatRange RangeFormatBuilder::GetReplaceRange() const {
 }
 
 void RangeFormatBuilder::WriteSyntaxNode(LuaSyntaxNode &syntaxNode, const LuaSyntaxTree &t) {
-    if (_validRange) {
+    if (_validRange == Valid::Process) {
         return FormatBuilder::WriteSyntaxNode(syntaxNode, t);
     } else {
         auto text = syntaxNode.GetText(t);
@@ -60,23 +59,23 @@ void RangeFormatBuilder::WriteSyntaxNode(LuaSyntaxNode &syntaxNode, const LuaSyn
 }
 
 void RangeFormatBuilder::WriteSpace(std::size_t space) {
-    if (_validRange) {
+    if (_validRange == Valid::Process) {
         return FormatBuilder::WriteSpace(space);
     } else {
         _state.CurrentWidth() += space;
     }
 }
 
 void RangeFormatBuilder::WriteLine(std::size_t line) {
-    if (_validRange) {
+    if (_validRange == Valid::Process) {
         return FormatBuilder::WriteLine(line);
     } else {
         _state.CurrentWidth() = 0;
     }
 }
 
 void RangeFormatBuilder::WriteIndent() {
-    if (_validRange) {
+    if (_validRange == Valid::Process) {
         return FormatBuilder::WriteIndent();
     } else {
         auto topLevelIndent = _state.GetCurrentIndent();
@@ -85,25 +84,23 @@ void RangeFormatBuilder::WriteIndent() {
 }
 
 void RangeFormatBuilder::WriteChar(char ch) {
-    if (_validRange) {
+    if (_validRange == Valid::Process) {
         return FormatBuilder::WriteChar(ch);
     } else {
         _state.CurrentWidth()++;
     }
 }
 
 void RangeFormatBuilder::WriteText(std::string_view text) {
-    if (_validRange) {
+    if (_validRange == Valid::Process) {
         return FormatBuilder::WriteText(text);
     } else {
         std::size_t last = 0;
         for (std::size_t i = 0; i != text.size(); i++) {
             char ch = text[i];
             if (ch == '\n' || ch == '\r') {
                 _state.CurrentWidth() = 0;
-                if (ch == '\r'
-                    && (i + 1 < text.size())
-                    && (text[i + 1] == '\n')) {
+                if (ch == '\r' && (i + 1 < text.size()) && (text[i + 1] == '\n')) {
                     i++;
                 }
                 last = i + 1;
@@ -116,26 +113,46 @@ void RangeFormatBuilder::WriteText(std::string_view text) {
     }
 }
 
-void RangeFormatBuilder::CheckRange(LuaSyntaxNode &syntaxNode, const LuaSyntaxTree &t) {
+void RangeFormatBuilder::CheckRange(LuaSyntaxNode &syntaxNode, const LuaSyntaxTree &t, FormatResolve &resolve) {
     if (syntaxNode.IsToken(t)) {
-        auto tokenEndLine = syntaxNode.GetEndLine(t);
-        if (tokenEndLine < _range.StartLine) {
-            _validRange = false;
-            return;
-        }
-        auto tokenStartLine = syntaxNode.GetStartLine(t);
-        if (tokenStartLine > _range.EndLine) {
-            _validRange = false;
-            return;
+        LuaSyntaxNode startNode = syntaxNode;
+        LuaSyntaxNode endNode = syntaxNode;
+        if (resolve.GetTokenStrategy() == TokenStrategy::OriginRange) {
+            auto r = resolve.GetOriginRange();
+            startNode = LuaSyntaxNode(r.StartIndex);
+            endNode = LuaSyntaxNode(r.EndIndex);
         }
 
-        if (tokenStartLine < _range.StartLine) {
-            _range.StartLine = tokenStartLine;
-            _range.StartCol = syntaxNode.GetStartCol(t);
-        }
-        if (tokenEndLine > _range.EndLine) {
-            _range.EndLine = tokenEndLine;
+        switch (_validRange) {
+            case Valid::Init: {
+                auto tokenEndLine = endNode.GetEndLine(t);
+                if (tokenEndLine >= _range.StartLine) {
+                    _validRange = Valid::Process;
+                    auto tokenStartLine = startNode.GetStartLine(t);
+                    if (tokenStartLine < _range.StartLine) {
+                        _range.StartLine = tokenStartLine;
+                        _range.StartCol = startNode.GetStartCol(t);
+                    }
+                }
+                break;
+            }
+            case Valid::Process: {
+                auto tokenStartLine = startNode.GetStartLine(t);
+                if (tokenStartLine > _range.EndLine) {
+                    _validRange = Valid::Finish;
+                    _state.StopDfsForeach();
+                } else {
+                    auto tokenEndLine = endNode.GetEndLine(t);
+                    if (tokenEndLine > _range.EndLine) {
+                        _range.EndLine = tokenEndLine;
+                    }
+                }
+
+                break;
+            }
+            default: {
+                break;
+            }
         }
-        _validRange = true;
     }
 }
diff --git a/CodeService/src/TypeFormat/LuaTypeFormat.cpp b/CodeService/src/TypeFormat/LuaTypeFormat.cpp
@@ -1,17 +1,16 @@
 ﻿#include "CodeService/TypeFormat/LuaTypeFormat.h"
-#include <algorithm>
+#include "CodeService/RangeFormat/RangeFormatBuilder.h"
 #include "LuaParser/Lexer/LuaTokenTypeDetail.h"
 #include "Util/StringUtil.h"
 #include "Util/format.h"
-#include "CodeService/RangeFormat/RangeFormatBuilder.h"
+#include <algorithm>
 
 std::vector<LuaTypeFormat::Result> LuaTypeFormat::GetResult() {
     return _results;
 }
 
 LuaTypeFormat::LuaTypeFormat(LuaTypeFormatOptions &typeOptions)
-        : _typeOptions(typeOptions) {
-
+    : _typeOptions(typeOptions) {
 }
 
 void LuaTypeFormat::Analyze(std::string_view trigger,
@@ -191,16 +190,17 @@ void LuaTypeFormat::FormatLine(std::size_t line, std::size_t character, const Lu
 }
 
 void LuaTypeFormat::FixIndent(std::size_t line, std::size_t character, const LuaSyntaxTree &t, LuaStyle &style) {
-
 }
 
 void LuaTypeFormat::FixEndIndent(std::size_t line, std::size_t character) {
-
 }
 
 void LuaTypeFormat::FormatByRange(FormatRange range, const LuaSyntaxTree &t, LuaStyle &style) {
     RangeFormatBuilder f(style, range);
     auto newText = f.GetFormatResult(t);
+    if (newText.empty()) {
+        return;
+    }
     range = f.GetReplaceRange();
     auto &result = _results.emplace_back();
     result.Text = newText;
diff --git a/include/CodeService/Format/Analyzer/FormatDocAnalyze.h b/include/CodeService/Format/Analyzer/FormatDocAnalyze.h
@@ -24,6 +24,7 @@ class FormatDocAnalyze : public FormatAnalyzer {
 
     void AddIgnoreRange(const IndexRange& range, const LuaSyntaxTree &t);
 
+    std::vector<IndexRange> GetIgnores() const;
 private:
 
     void AnalyzeDocFormat(LuaSyntaxNode n, FormatState &f, const LuaSyntaxTree &t);
diff --git a/include/CodeService/Format/FormatState.h b/include/CodeService/Format/FormatState.h
@@ -67,6 +67,8 @@ class FormatState {
                     const FormatHandle &enterHandle
     );
 
+    void StopDfsForeach();
+
 private:
     LuaStyle _formatStyle;
     LuaDiagnosticStyle _diagnosticStyle;
@@ -75,5 +77,6 @@ class FormatState {
     std::stack<IndentState> _indentStack;
     Mode _mode;
     IndexRange _ignoreRange;
+    bool _foreachContinue;
     std::array<std::unique_ptr<FormatAnalyzer>, static_cast<std::size_t>(FormatAnalyzerType::Count)> _analyzers;
 };
diff --git a/include/CodeService/RangeFormat/RangeFormatBuilder.h b/include/CodeService/RangeFormat/RangeFormatBuilder.h
