修复bug

CppCXY · CppCXY · commit 03bd828b6377 · 2023-02-02T19:51:04.000+08:00
diff --git a/.editorconfig b/.editorconfig
@@ -1,10 +1,3 @@
-[*]
-
-# ReSharper properties
-resharper_namespace_indentation=none
-indent_style=tab
-tab_width=4
-
 [*.yml]
 indent_style = space
 indent_size = 2
diff --git a/CodeService/CMakeLists.txt b/CodeService/CMakeLists.txt
@@ -14,6 +14,7 @@ target_include_directories(CodeService PUBLIC
 target_sources(CodeService
         PRIVATE
         # config
+        ${CodeService_SOURCE_DIR}/src/Config/FunctionOption.cpp
         ${CodeService_SOURCE_DIR}/src/Config/LuaStyle.cpp
         ${CodeService_SOURCE_DIR}/src/Config/LuaEditorConfig.cpp
         ${CodeService_SOURCE_DIR}/src/Config/LuaDiagnosticStyle.cpp
diff --git a/CodeService/src/Config/FunctionOption.cpp b/CodeService/src/Config/FunctionOption.cpp
@@ -0,0 +1,72 @@
+#include "FunctionOption.h"
+#include "LuaParser/Lexer/LuaLexer.h"
+#include "LuaParser/lexer/LuaTokenTypeDetail.h"
+
+void FunctionOption::Parse(std::string_view option) {
+    std::string text(option);
+    auto virtualFile = std::make_shared<LuaFile>(std::move(text));
+    LuaLexer lexer(virtualFile);
+    lexer.Parse();
+    if (lexer.HasError()) {
+        return;
+    }
+    enum class ParseState {
+        None,
+        Key,
+        ExpectParam,
+        ExpectCommaOrFinish
+    } state = ParseState::None;
+    auto &tokens = lexer.GetTokens();
+    for (auto token: tokens) {
+        switch (state) {
+            case ParseState::None: {
+                if (token.TokenType != TK_NAME) {
+                    return;
+                }
+                _key = std::string(
+                        virtualFile->Slice(token.Range.StartOffset, token.Range.EndOffset));
+                state = ParseState::Key;
+                break;
+            }
+            case ParseState::Key: {
+                if (token.TokenType != '(') {
+                    return;
+                }
+                state = ParseState::ExpectParam;
+                break;
+            }
+            case ParseState::ExpectParam: {
+                if (token.TokenType == TK_NAME || token.TokenType == TK_NUMBER || token.TokenType == TK_STRING) {
+                    _params.emplace_back(virtualFile->Slice(token.Range.StartOffset, token.Range.EndOffset));
+                    state = ParseState::ExpectCommaOrFinish;
+                } else if (token.TokenType == ')') {
+                    return;
+                }
+                break;
+            }
+            case ParseState::ExpectCommaOrFinish: {
+                if (token.TokenType == ',') {
+                    state = ParseState::ExpectParam;
+                } else if (token.TokenType == ')') {
+                    return;
+                }
+                break;
+            }
+        }
+    }
+}
+
+std::string &FunctionOption::GetKey() {
+    return _key;
+}
+
+std::string FunctionOption::GetParam(std::size_t index) {
+    if (index < _params.size()) {
+        return _params[index];
+    }
+    return "";
+}
+
+std::size_t FunctionOption::GetParamSize() {
+    return _params.size();
+}
diff --git a/CodeService/src/Config/FunctionOption.h b/CodeService/src/Config/FunctionOption.h
@@ -0,0 +1,20 @@
+#pragma once
+
+#include <string_view>
+#include <string>
+#include <vector>
+
+class FunctionOption {
+public:
+    void Parse(std::string_view option);
+
+    std::string& GetKey();
+
+    std::string GetParam(std::size_t index);
+
+    std::size_t GetParamSize();
+
+private:
+    std::string _key;
+    std::vector<std::string> _params;
+};
diff --git a/CodeService/src/Config/LuaStyle.cpp b/CodeService/src/Config/LuaStyle.cpp
@@ -1,6 +1,6 @@
 #include "CodeService/Config/LuaStyle.h"
 #include <map>
-#include <regex>
+#include "FunctionOption.h"
 
 bool IsNumber(std::string_view source) {
     for (auto c: source) {
@@ -159,7 +159,7 @@ void LuaStyle::ParseFromMap(std::map<std::string, std::string, std::less<>> &con
 
     BOOL_OPTION(never_indent_before_if_condition)
 
-    if(align_if_branch){
+    if (align_if_branch) {
         never_indent_before_if_condition = true;
     }
 
@@ -176,30 +176,33 @@ void LuaStyle::ParseFromMap(std::map<std::string, std::string, std::less<>> &con
             {"line_space_after_expression_statement",      line_space_after_expression_statement},
             {"line_space_after_comment",                   line_space_after_comment}
     };
-    std::regex minLineRegex = std::regex(R"(minLine:\s*(\d+))");
-    std::regex keepLineRegex = std::regex(R"(keepLine:\s*(\d+))");
-    std::regex maxLineRegex = std::regex(R"(maxLine:\s*(\d+))");
-    for (auto &keepLineOption: fieldList) {
-        if (configMap.count(keepLineOption.first)) {
-            std::string value = configMap.at(keepLineOption.first);
-            if (value == "keepLine") {
-                keepLineOption.second = LineSpace(LineSpaceType::Keep);
-                continue;
-            }
-            std::smatch m;
 
-            if (std::regex_search(value, m, minLineRegex)) {
-                keepLineOption.second = LineSpace(LineSpaceType::Min, std::stoi(m.str(1)));
-                continue;
-            }
+    for (auto &lineOption: fieldList) {
+        if (configMap.count(lineOption.first)) {
+            std::string value = configMap.at(lineOption.first);
+            FunctionOption option;
+            option.Parse(value);
 
-            if (std::regex_search(value, m, keepLineRegex)) {
-                keepLineOption.second = LineSpace(LineSpaceType::Fixed, std::stoi(m.str(1)));
-                continue;
+            if (option.GetKey() == "keep") {
+                lineOption.second = LineSpace(LineSpaceType::Keep);
             }
-
-            if (std::regex_search(value, m, maxLineRegex)) {
-                keepLineOption.second = LineSpace(LineSpaceType::Max, std::stoi(m.str(1)));
+            else if(option.GetKey() == "min") {
+                auto p1 = option.GetParam(0);
+                if(!p1.empty() && IsNumber(p1)) {
+                    lineOption.second = LineSpace(LineSpaceType::Min, std::stoi(p1));
+                }
+            }
+            else if(option.GetKey() == "fixed") {
+                auto p1 = option.GetParam(0);
+                if(!p1.empty() && IsNumber(p1)) {
+                    lineOption.second = LineSpace(LineSpaceType::Fixed, std::stoi(p1));
+                }
+            }
+            else if(option.GetKey() == "max") {
+                auto p1 = option.GetParam(0);
+                if(!p1.empty() && IsNumber(p1)) {
+                    lineOption.second = LineSpace(LineSpaceType::Max, std::stoi(p1));
+                }
             }
         }
     }
diff --git a/CodeService/src/Format/Analyzer/AlignAnalyzer.cpp b/CodeService/src/Format/Analyzer/AlignAnalyzer.cpp
@@ -50,12 +50,6 @@ void AlignAnalyzer::Analyze(FormatState &f, const LuaSyntaxTree &t) {
                         AnalyzeIfStatement(f, syntaxNode, t);
                     }
                 }
-
-//                case LuaSyntaxNodeKind::ExpressionStatement: {
-//                    if (f.GetStyle().align_chained_expression_statement) {
-//                    }
-//                    break;
-//                }
                 default: {
                     break;
                 }
diff --git a/CodeService/src/Format/Analyzer/LineBreakAnalyzer.cpp b/CodeService/src/Format/Analyzer/LineBreakAnalyzer.cpp
@@ -11,6 +11,23 @@ LineBreakAnalyzer::LineBreakAnalyzer() {
 }
 
 void LineBreakAnalyzer::Analyze(FormatState &f, const LuaSyntaxTree &t) {
+    for (auto syntaxNode: t.GetSyntaxNodes()) {
+        if (syntaxNode.IsToken(t)) {
+            switch (syntaxNode.GetTokenKind(t)) {
+                case TK_SHEBANG:
+                case TK_SHORT_COMMENT: {
+                    BreakAfter(syntaxNode, t, LineSpace(LineSpaceType::Keep));
+                    break;
+                }
+                default: {
+                    break;
+                }
+            }
+        }
+    }
+}
+
+void LineBreakAnalyzer::ComplexAnalyze(FormatState &f, const LuaSyntaxTree &t) {
     for (auto syntaxNode: t.GetSyntaxNodes()) {
         if (syntaxNode.IsNode(t)) {
             switch (syntaxNode.GetSyntaxKind(t)) {
@@ -143,17 +160,6 @@ void LineBreakAnalyzer::Analyze(FormatState &f, const LuaSyntaxTree &t) {
                     break;
                 }
             }
-        } else {
-            switch (syntaxNode.GetTokenKind(t)) {
-                case TK_SHEBANG:
-                case TK_SHORT_COMMENT: {
-                    BreakAfter(syntaxNode, t);
-                    break;
-                }
-                default: {
-                    break;
-                }
-            }
         }
     }
 }
@@ -411,3 +417,4 @@ bool LineBreakAnalyzer::CanCollapseLines(FormatState &f, LuaSyntaxNode &n, const
         }
     }
 }
+
diff --git a/CodeService/src/Format/Analyzer/SpaceAnalyzer.cpp b/CodeService/src/Format/Analyzer/SpaceAnalyzer.cpp
@@ -82,7 +82,9 @@ void SpaceAnalyzer::Analyze(FormatState &f, const LuaSyntaxTree &t) {
                 case TK_RETURN:
                 case TK_GOTO:
                 case TK_FOR:
-                case TK_FUNCTION: {
+                case TK_ELSE:
+                case TK_FUNCTION:
+                case TK_END: {
                     SpaceRight(syntaxNode, t);
                     break;
                 }
diff --git a/CodeService/src/Format/FormatBuilder.cpp b/CodeService/src/Format/FormatBuilder.cpp
@@ -173,6 +173,8 @@ void FormatBuilder::DoResolve(LuaSyntaxNode &syntaxNode, const LuaSyntaxTree &t,
                             if (nextLine > currentLine) {
                                 WriteLine(nextLine - currentLine);
                                 return;
+                            } else {
+                                WriteLine(1);
                             }
                         }
                         break;
@@ -189,6 +191,8 @@ void FormatBuilder::DoResolve(LuaSyntaxNode &syntaxNode, const LuaSyntaxTree &t,
                                 }
                                 WriteLine(line);
                                 return;
+                            } else {
+                                WriteLine(1);
                             }
                         }
                         break;
@@ -205,6 +209,8 @@ void FormatBuilder::DoResolve(LuaSyntaxNode &syntaxNode, const LuaSyntaxTree &t,
                                 }
                                 WriteLine(line);
                                 return;
+                            } else {
+                                WriteLine(1);
                             }
                         }
                     }
diff --git a/README.md b/README.md
@@ -19,17 +19,12 @@
 
 ## RoadMap
 
-* 重写范围格式化[0%]
-* 重新实现type formatting[0%]
 * plugin[0%]
 
 ## 文档
-* [使用方式](docs/usage.md)
 * [格式化行为介绍](docs/format_action.md)
 * [如何配置格式化](docs/format_config.md)
 * [代码诊断配置](docs/diagnosis_config.md)
-* [部分屏蔽格式化](docs/disable_format.md)
-* [auto import配置](docs/auto_import_config.md)
 # Contribute
 
 任何pr或者issue都是欢迎的
@@ -54,6 +49,9 @@ cmake --build .
 
 **Contributors**
 
+[**@obszczymucha**](https://github.com/obszczymucha)
+
+[**@Rainer Poisel**](https://github.com/rpoisel)
 
 ## License
 
diff --git a/Test/src/FormatResult_unitest.cpp b/Test/src/FormatResult_unitest.cpp
@@ -565,3 +565,28 @@ local t = {
             R"(#! lua 1.lua
 )"));
 }
+
+TEST(Format, MultiLine) {
+    EXPECT_TRUE(TestHelper::TestFormatted(
+            R"(
+function g(x)
+    if not x then return 3 end return (x('a', 'x'))
+end
+)",
+            R"(
+function g(x)
+    if not x then return 3 end
+    return (x('a', 'x'))
+end
+)"));
+    EXPECT_TRUE(TestHelper::TestFormatted(
+            R"(
+if a then
+else end
+)",
+            R"(
+if a then
+else
+end
+)"));
+}
diff --git a/Test2/src/FormatTest2.cpp b/Test2/src/FormatTest2.cpp
@@ -6,7 +6,8 @@
 
 int main() {
     std::string buffer = R"(
-local t = {a--[[]]=123}
+if a then
+else end
 )";
 
     auto file = std::make_shared<LuaFile>(std::move(buffer));
diff --git a/include/CodeService/Config/LuaStyle.h b/include/CodeService/Config/LuaStyle.h
@@ -31,6 +31,8 @@ class LuaStyle {
 
     QuoteStyle quote_style = QuoteStyle::None;
 
+    std::size_t continuation_indent = 4;
+
     TableSeparatorStyle table_separator_style = TableSeparatorStyle::Comma;
 
     std::size_t max_line_length = 120;
@@ -44,8 +46,6 @@ class LuaStyle {
 
     CallArgParentheses call_arg_parentheses = CallArgParentheses::Keep;
 
-	std::size_t continuation_indent = 4;
-
 	bool detect_end_of_line = true;
 
 	bool insert_final_newline = true;
diff --git a/include/CodeService/Config/LuaStyleEnum.h b/include/CodeService/Config/LuaStyleEnum.h
@@ -51,7 +51,7 @@ struct LineSpace {
     explicit LineSpace(std::size_t space = 1)
             : Type(LineSpaceType::Fixed), Space(space) {}
 
-    LineSpace(LineSpaceType type, std::size_t space = 0)
+    explicit LineSpace(LineSpaceType type, std::size_t space = 0)
             : Type(type), Space(space) {}
 
     LineSpaceType Type;
diff --git a/include/CodeService/Format/Analyzer/FormatStrategy.h b/include/CodeService/Format/Analyzer/FormatStrategy.h
@@ -70,7 +70,7 @@ struct LineBreakData {
 
     explicit LineBreakData(LineSpace lineSpace)
             : Strategy(LineBreakStrategy::Standard),
-              Data(LineSpace(lineSpace)) {
+              Data(lineSpace) {
     }
 
     LineBreakData(LineBreakStrategy strategy, std::size_t index)
diff --git a/include/CodeService/Format/Analyzer/LineBreakAnalyzer.h b/include/CodeService/Format/Analyzer/LineBreakAnalyzer.h
@@ -13,6 +13,8 @@ class LineBreakAnalyzer: public FormatAnalyzer {
 
     void Analyze(FormatState &f, const LuaSyntaxTree &t) override;
 
+    void ComplexAnalyze(FormatState &f, const LuaSyntaxTree &t) override;
+
     void Query(FormatState &f, LuaSyntaxNode &syntaxNode, const LuaSyntaxTree &t, FormatResolve& resolve) override;
 
     void BreakAfter(LuaSyntaxNode n, const LuaSyntaxTree &t, std::size_t line = 1);
diff --git a/lua.template.editorconfig b/lua.template.editorconfig

Original file line number	Diff line number	Diff line change
`@@ -50,12 +50,6 @@ void AlignAnalyzer::Analyze(FormatState &f, const LuaSyntaxTree &t) {`
`50`	`50`	`AnalyzeIfStatement(f, syntaxNode, t);`
`51`	`51`	`}`
`52`	`52`	`}`
`53`		`-`
`54`		`-// case LuaSyntaxNodeKind::ExpressionStatement: {`
`55`		`-// if (f.GetStyle().align_chained_expression_statement) {`
`56`		`-// }`
`57`		`-// break;`
`58`		`-// }`
`59`	`53`	`default: {`
`60`	`54`	`break;`
`61`	`55`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,23 @@ LineBreakAnalyzer::LineBreakAnalyzer() {`
`11`	`11`	`}`
`12`	`12`
`13`	`13`	`void LineBreakAnalyzer::Analyze(FormatState &f, const LuaSyntaxTree &t) {`
	`14`	`+ for (auto syntaxNode: t.GetSyntaxNodes()) {`
	`15`	`+ if (syntaxNode.IsToken(t)) {`
	`16`	`+ switch (syntaxNode.GetTokenKind(t)) {`
	`17`	`+ case TK_SHEBANG:`
	`18`	`+ case TK_SHORT_COMMENT: {`
	`19`	`+ BreakAfter(syntaxNode, t, LineSpace(LineSpaceType::Keep));`
	`20`	`+ break;`
	`21`	`+ }`
	`22`	`+ default: {`
	`23`	`+ break;`
	`24`	`+ }`
	`25`	`+ }`
	`26`	`+ }`
	`27`	`+ }`
	`28`	`+}`
	`29`	`+`
	`30`	`+void LineBreakAnalyzer::ComplexAnalyze(FormatState &f, const LuaSyntaxTree &t) {`
`14`	`31`	`for (auto syntaxNode: t.GetSyntaxNodes()) {`
`15`	`32`	`if (syntaxNode.IsNode(t)) {`
`16`	`33`	`switch (syntaxNode.GetSyntaxKind(t)) {`
`@@ -143,17 +160,6 @@ void LineBreakAnalyzer::Analyze(FormatState &f, const LuaSyntaxTree &t) {`
`143`	`160`	`break;`
`144`	`161`	`}`
`145`	`162`	`}`
`146`		`- } else {`
`147`		`- switch (syntaxNode.GetTokenKind(t)) {`
`148`		`- case TK_SHEBANG:`
`149`		`- case TK_SHORT_COMMENT: {`
`150`		`- BreakAfter(syntaxNode, t);`
`151`		`- break;`
`152`		`- }`
`153`		`- default: {`
`154`		`- break;`
`155`		`- }`
`156`		`- }`
`157`	`163`	`}`
`158`	`164`	`}`
`159`	`165`	`}`
`@@ -411,3 +417,4 @@ bool LineBreakAnalyzer::CanCollapseLines(FormatState &f, LuaSyntaxNode &n, const`
`411`	`417`	`}`
`412`	`418`	`}`
`413`	`419`	`}`
	`420`	`+`
Original file line number	Diff line number	Diff line change
`@@ -173,6 +173,8 @@ void FormatBuilder::DoResolve(LuaSyntaxNode &syntaxNode, const LuaSyntaxTree &t,`
`173`	`173`	`if (nextLine > currentLine) {`
`174`	`174`	`WriteLine(nextLine - currentLine);`
`175`	`175`	`return;`
	`176`	`+ } else {`
	`177`	`+ WriteLine(1);`
`176`	`178`	`}`
`177`	`179`	`}`
`178`	`180`	`break;`
`@@ -189,6 +191,8 @@ void FormatBuilder::DoResolve(LuaSyntaxNode &syntaxNode, const LuaSyntaxTree &t,`
`189`	`191`	`}`
`190`	`192`	`WriteLine(line);`
`191`	`193`	`return;`
	`194`	`+ } else {`
	`195`	`+ WriteLine(1);`
`192`	`196`	`}`
`193`	`197`	`}`
`194`	`198`	`break;`
`@@ -205,6 +209,8 @@ void FormatBuilder::DoResolve(LuaSyntaxNode &syntaxNode, const LuaSyntaxTree &t,`
`205`	`209`	`}`
`206`	`210`	`WriteLine(line);`
`207`	`211`	`return;`
	`212`	`+ } else {`
	`213`	`+ WriteLine(1);`
`208`	`214`	`}`
`209`	`215`	`}`
`210`	`216`	`}`