完善align_if_branch

CppCXY · CppCXY · commit 1e806c0c2ffd · 2023-02-01T20:21:39.000+08:00
diff --git a/CodeFormatLib/src/CodeFormatLib.cpp b/CodeFormatLib/src/CodeFormatLib.cpp
@@ -173,7 +173,7 @@ int type_format(lua_State *L) {
             auto line = lua_tointeger(L, 3);
             auto character = lua_tointeger(L, 4);
 
-            if(line < 0 || character < 0){
+            if (line < 0 || character < 0) {
                 lua_pushboolean(L, false);
                 lua_pushstring(L, "line or character param error");
                 return 2;
@@ -454,33 +454,17 @@ int set_default_config(lua_State *L) {
 int set_nonstandard_symbol(lua_State *L) {
     int top = lua_gettop(L);
 
-    if (top != 2) {
-        return 0;
+    try {
+        LuaCodeFormat::GetInstance().SupportNonStandardSymbol();
+        lua_pushboolean(L, true);
+        return 1;
     }
-
-    if (lua_isstring(L, 1) && lua_istable(L, 2)) {
-        try {
-            std::string type = lua_tostring(L, 1);
-            std::vector<std::string> tokens;
-            lua_pushnil(L);
-            while (lua_next(L, -2) != 0) {
-                auto value = luaToString(L, -1);
-                tokens.push_back(value);
-                lua_pop(L, 1);
-            }
-            lua_settop(L, top);
-
-            LuaCodeFormat::GetInstance().SetSupportNonStandardSymbol(type, tokens);
-            lua_pushboolean(L, true);
-            return 1;
-        }
-        catch (std::exception &e) {
-            std::string err = e.what();
-            lua_settop(L, top);
-            lua_pushboolean(L, false);
-            lua_pushlstring(L, err.c_str(), err.size());
-            return 2;
-        }
+    catch (std::exception &e) {
+        std::string err = e.what();
+        lua_settop(L, top);
+        lua_pushboolean(L, false);
+        lua_pushlstring(L, err.c_str(), err.size());
+        return 2;
     }
 
     return 0;
diff --git a/CodeFormatLib/src/LuaCodeFormat.cpp b/CodeFormatLib/src/LuaCodeFormat.cpp
@@ -10,7 +10,8 @@ LuaCodeFormat &LuaCodeFormat::GetInstance() {
     return instance;
 }
 
-LuaCodeFormat::LuaCodeFormat() {
+LuaCodeFormat::LuaCodeFormat()
+        : _supportNonStandardSymbol(false) {
 }
 
 void LuaCodeFormat::UpdateCodeStyle(const std::string &workspaceUri, const std::string &configPath) {
@@ -46,10 +47,8 @@ void LuaCodeFormat::SetDefaultCodeStyle(ConfigMap &configMap) {
     }
 }
 
-void LuaCodeFormat::SetSupportNonStandardSymbol(const std::string &tokenType, const std::vector<std::string> &tokens) {
-//    if (tokenType.size() == 1) {
-//        _customParser->SetTokens(tokenType.front(), tokens);
-//    }
+void LuaCodeFormat::SupportNonStandardSymbol() {
+    _supportNonStandardSymbol = true;
 }
 
 void LuaCodeFormat::LoadSpellDictionary(const std::string &path) {
@@ -72,6 +71,8 @@ std::string LuaCodeFormat::Reformat(const std::string &uri, std::string &&text,
     t.BuildTree(p);
 
     LuaStyle style = GetStyle(uri);
+    CalculateTempStyle(style, configMap);
+
     FormatBuilder f(style);
 
     return f.GetFormatResult(t);
@@ -91,6 +92,8 @@ std::string LuaCodeFormat::RangeFormat(const std::string &uri, FormatRange &rang
     t.BuildTree(p);
 
     LuaStyle style = GetStyle(uri);
+    CalculateTempStyle(style, configMap);
+
     RangeFormatBuilder f(style, range);
 
     auto formattedText = f.GetFormatResult(t);
@@ -112,8 +115,10 @@ LuaCodeFormat::TypeFormat(const std::string &uri, std::size_t line, std::size_t
     t.BuildTree(p);
 
     LuaStyle style = GetStyle(uri);
+    CalculateTempStyle(style, configMap);
+
+    LuaTypeFormatOptions typeFormatOptions = LuaTypeFormatOptions::ParseFromMap(stringTypeOptions);
 
-    LuaTypeFormatOptions typeFormatOptions;
     LuaTypeFormat tf(typeFormatOptions);
     tf.Analyze("\n", line, character, t, style);
     return tf.GetResult();
@@ -234,3 +239,22 @@ std::vector<LuaDiagnosticInfo> LuaCodeFormat::MakeDiagnosticInfo(const std::vect
 
     return results;
 }
+
+void LuaCodeFormat::CalculateTempStyle(LuaStyle &style, ConfigMap &configMap) {
+    if (configMap.empty()) {
+        return;
+    }
+
+    if (configMap.count("insertSpaces")) {
+        style.indent_style = configMap.at("insertSpaces") == "true"
+                                   ? IndentStyle::Space
+                                   : IndentStyle::Tab;
+    }
+    if (configMap.count("tabSize")) {
+        if (style.indent_style == IndentStyle::Tab) {
+            style.tab_width = std::stoi(configMap.at("tabSize"));
+        } else if (style.indent_style == IndentStyle::Space) {
+            style.indent_size = std::stoi(configMap.at("tabSize"));
+        }
+    }
+}
diff --git a/CodeFormatLib/src/LuaCodeFormat.h b/CodeFormatLib/src/LuaCodeFormat.h
@@ -27,7 +27,7 @@ class LuaCodeFormat {
 
     void SetDefaultCodeStyle(ConfigMap &configMap);
 
-    void SetSupportNonStandardSymbol(const std::string &tokenType, const std::vector<std::string> &tokens);
+    void SupportNonStandardSymbol();
 
     void LoadSpellDictionary(const std::string &path);
 
@@ -55,8 +55,11 @@ class LuaCodeFormat {
     std::vector<LuaDiagnosticInfo> MakeDiagnosticInfo(const std::vector<LuaDiagnostic>& diagnostics,
                                                       std::shared_ptr<LuaFile> file);
 
+    void CalculateTempStyle(LuaStyle& style, ConfigMap &configMap);
+
     std::vector<LuaConfig> _configs;
     LuaStyle _defaultStyle;
     CodeSpellChecker _spellChecker;
     LuaDiagnosticStyle _diagnosticStyle;
+    bool _supportNonStandardSymbol;
 };
diff --git a/CodeService/src/Config/LuaStyle.cpp b/CodeService/src/Config/LuaStyle.cpp
@@ -159,6 +159,10 @@ void LuaStyle::ParseFromMap(std::map<std::string, std::string, std::less<>> &con
 
     BOOL_OPTION(never_indent_before_if_condition)
 
+    if(align_if_branch){
+        never_indent_before_if_condition = true;
+    }
+
     BOOL_OPTION(never_indent_comment_on_if_branch)
 
     std::vector<std::pair<std::string, LineSpace &>> fieldList = {
diff --git a/CodeService/src/Format/Analyzer/AlignAnalyzer.cpp b/CodeService/src/Format/Analyzer/AlignAnalyzer.cpp
@@ -372,48 +372,76 @@ void AlignAnalyzer::AnalyzeParamList(FormatState &f, LuaSyntaxNode &syntaxNode,
     PushAlignGroup(AlignStrategy::AlignToFirst, group);
 }
 
-
+// 需求真是复杂
 void AlignAnalyzer::AnalyzeIfStatement(FormatState &f, LuaSyntaxNode &syntaxNode, const LuaSyntaxTree &t) {
-    auto ifExprs = syntaxNode.GetChildSyntaxNodes(LuaSyntaxNodeKind::BinaryExpression, t);
+    auto if_ = syntaxNode.GetChildToken(TK_IF, t);
+    auto elseifs = syntaxNode.GetChildTokens(TK_ELSEIF, t);
+    std::vector<std::size_t> group;
+
+    // if 之后的表达式可以有多种对齐方式
+    group.push_back(if_.GetNextToken(t).GetIndex());
+    auto ifCondition = if_.GetNextSibling(t);
     std::vector<LuaSyntaxNode> logicOps;
-    for (auto ifExpr: ifExprs) {
-        auto ops = helper::CollectBinaryOperator(ifExpr, t, [](LuaTokenKind kind) {
+    std::size_t ifAlignPos = 0;
+    if (ifCondition.GetSyntaxKind(t) == LuaSyntaxNodeKind::BinaryExpression) {
+        auto ifConditionLogicOps = helper::CollectBinaryOperator(ifCondition, t, [](LuaTokenKind kind) {
             return kind == TK_AND || kind == TK_OR;
         });
-        for (auto op: ops) {
-            logicOps.push_back(op);
+
+        for (auto op: ifConditionLogicOps) {
+            if (op.GetPrevToken(t).GetEndLine(t) != op.GetStartLine(t)) {
+                if (op.GetTokenKind(t) == TK_AND) {
+                    ifAlignPos = std::max(ifAlignPos, 4u);
+                } else if (op.GetTokenKind(t) == TK_OR) {
+                    ifAlignPos = std::max(ifAlignPos, 3u);
+                }
+            }
         }
+        logicOps = ifConditionLogicOps;
     }
 
-    std::size_t alignPos = 0;
-    auto elseifs = syntaxNode.GetChildTokens(TK_ELSEIF, t);
-    if (!elseifs.empty()) {
-        alignPos = 7; // sizeof 'elseif '
-    } else {
-        alignPos = 3; // sizeof 'if '
-        for (auto &n: logicOps) {
-            if (n.GetTokenKind(t) == TK_AND) {
-                alignPos = 4; // sizeof 'and '
-                break;
+    // 如果仅仅if语句
+    if (elseifs.empty()) {
+        if (ifAlignPos != 0) {
+            for (auto &n: logicOps) {
+                auto nextToken = n.GetNextToken(t);
+                if (nextToken.IsToken(t)) {
+                    group.push_back(nextToken.GetIndex());
+                }
             }
+            PushNormalAlignGroup(ifAlignPos, group);
+        }
+        return;
+    }
+
+    // 若有 elseif
+
+    auto spaceAfterIf = if_.GetNextToken(t).GetStartCol(t) - if_.GetStartCol(t);
+    if(spaceAfterIf == 3 && ifAlignPos == 0){
+        group.clear();
+        logicOps.clear();
+    }
+
+    ifAlignPos = 7;
+
+    for (auto elseif_: elseifs) {
+        auto elseifCondition = elseif_.GetNextSibling(t);
+        auto ops = helper::CollectBinaryOperator(elseifCondition, t, [](LuaTokenKind kind) {
+            return kind == TK_AND || kind == TK_OR;
+        });
+        for (auto op: ops) {
+            logicOps.push_back(op);
         }
     }
 
-    std::vector<std::size_t> group;
     for (auto &n: logicOps) {
         auto nextToken = n.GetNextToken(t);
         if (nextToken.IsToken(t)) {
             group.push_back(nextToken.GetIndex());
         }
     }
-    auto if_ = syntaxNode.GetChildToken(TK_IF, t);
-    group.push_back(if_.GetNextToken(t).GetIndex());
-
-    for (auto elseif_: elseifs) {
-        group.push_back(elseif_.GetNextToken(t).GetIndex());
-    }
 
-    PushNormalAlignGroup(alignPos, group);
+    PushNormalAlignGroup(ifAlignPos, group);
 }
 
 void AlignAnalyzer::PushNormalAlignGroup(std::size_t alignPos, std::vector<std::size_t> &data) {
diff --git a/LuaParser/src/Lexer/LuaLexer.cpp b/LuaParser/src/Lexer/LuaLexer.cpp
@@ -45,6 +45,7 @@ std::map<std::string, LuaTokenKind, std::less<>> LuaLexer::LuaReserved = {
 LuaLexer::LuaLexer(std::shared_ptr<LuaFile> file)
         :
         _linenumber(0),
+        _supportNonStandardSymbol(false),
         _reader(file->GetSource()),
         _file(file) {
 }
@@ -106,6 +107,9 @@ LuaTokenKind LuaLexer::Lex() {
             case '-': {
                 _reader.SaveAndNext();
                 if (_reader.GetCurrentChar() != '-') {
+                    if (_supportNonStandardSymbol && _reader.CheckNext1('=')) {
+                        return '=';
+                    }
                     return '-';
                 }
                 // is comment
@@ -130,6 +134,13 @@ LuaTokenKind LuaLexer::Lex() {
 
                 return type;
             }
+            case '+': {
+                _reader.SaveAndNext();
+                if (_supportNonStandardSymbol && _reader.CheckNext1('=')) {
+                    return '=';
+                }
+                return '+';
+            }
             case '[': {
                 std::size_t sep = SkipSep();
                 if (sep >= 2) {
diff --git a/include/LuaParser/Lexer/LuaLexer.h b/include/LuaParser/Lexer/LuaLexer.h
@@ -31,6 +31,7 @@ class LuaLexer
 
 	std::vector<LuaToken>& GetTokens();
 
+    void SupportNonStandardSymbol();
 
 //	void SetCustomParser(std::shared_ptr<LuaCustomParser> parser);
 private:
@@ -55,6 +56,7 @@ class LuaLexer
 	void TokenError(std::string_view message, TextRange range);
 
 	int _linenumber;
+    bool _supportNonStandardSymbol;
     TextReader _reader;
 	std::vector<LuaToken> _tokens;
 	std::vector<LuaTokenError> _errors;
