support lua5.5 grammar format

Author: CppCXY

CodeFormatCore/src/Format/Analyzer/SpaceAnalyzer.cpp

@@ -145,7 +145,8 @@ void SpaceAnalyzer::Analyze(FormatState &f, const LuaSyntaxTree &t) {
                 case TK_FOR:
                 case TK_ELSE:
                 case TK_FUNCTION:
-                case TK_END: {
+                case TK_END:
+                case TK_GLOBAL: {
                     SpaceRight(syntaxNode, t);
                     break;
                 }
@@ -194,6 +195,12 @@ void SpaceAnalyzer::Analyze(FormatState &f, const LuaSyntaxTree &t) {
                     SpaceRight(syntaxNode, t, 1);
                     break;
                 }
+                case TK_DOTS: {
+                    auto rightToken = syntaxNode.GetNextToken(t);
+                    if (rightToken.GetTokenKind(t) == TK_NAME) {
+                        SpaceRight(syntaxNode, t, 0);
+                    }
+                }
                 default: {
                     break;
                 }
@@ -317,6 +324,15 @@ void SpaceAnalyzer::ComplexAnalyze(FormatState &f, const LuaSyntaxTree &t) {
                     }
                     break;
                 }
+                case LuaSyntaxNodeKind::GlobalStatement: {
+                    auto childrens = syntaxNode.GetChildren(t);
+                    if (childrens.size() >= 2) {
+                        auto maybeAttrib = childrens[1];
+                        if (maybeAttrib.GetSyntaxKind(t) == LuaSyntaxNodeKind::Attribute) {
+                            SpaceRight(maybeAttrib, t, 1);
+                        }
+                    }
+                }
                 case LuaSyntaxNodeKind::FunctionBody: {
                     auto leftBrace = syntaxNode.GetChildToken('(', t);
                     if (syntaxNode.GetParent(t).GetSyntaxKind(t) == LuaSyntaxNodeKind::ClosureExpression) {

LuaParser/include/LuaParser/Ast/LuaSyntaxNodeKind.h

@@ -38,6 +38,8 @@ enum class LuaSyntaxNodeKind {
 
     AssignStatement,
 
+    GlobalStatement,
+
     SuffixedExpression,
 
     ParExpression,

LuaParser/include/LuaParser/Lexer/LuaTokenTypeDetail.h

@@ -28,6 +28,7 @@ enum LuaTokenTypeDetail : int {
     TK_TRUE,
     TK_UNTIL,
     TK_WHILE,
+    TK_GLOBAL, // global lua5.5
     /* other terminal symbols */
     TK_IDIV,
     TK_CONCAT,

LuaParser/include/LuaParser/Parse/LuaParser.h

@@ -33,10 +33,14 @@ class LuaParser {
 private:
     void Next();
 
+    void NextAs(LuaTokenKind kind);
+
     LuaTokenKind LookAhead();
 
     LuaTokenKind Current();
 
+    std::string_view CurrentText();
+
     void SkipComment();
 
     bool BlockFollow(bool rightbrace = false);
@@ -71,6 +75,10 @@ class LuaParser {
 
     void ExpressionStatement();
 
+    bool TryGlobalStatement();
+
+    void GlobalNameList();
+
     void ForNumber();
 
     void ForList();

LuaParser/src/Parse/LuaParser.cpp

@@ -63,6 +63,15 @@ void LuaParser::Next() {
     _invalid = true;
 }
 
+void LuaParser::NextAs(LuaTokenKind kind) {
+    auto me = MarkEvent(MarkEventType::EatToken);
+    me.U.Token.Kind = kind;
+    me.U.Token.Index = _tokenIndex;
+    _events.push_back(me);
+    _tokenIndex++;
+    _invalid = true;
+}
+
 LuaTokenKind LuaParser::LookAhead() {
     std::size_t nextIndex = _tokenIndex + 1;
 
@@ -103,6 +112,14 @@ LuaTokenKind LuaParser::Current() {
     return _current;
 }
 
+std::string_view LuaParser::CurrentText() {
+    if (_tokenIndex < _tokens.size()) {
+        auto range = _tokens[_tokenIndex].Range;
+        return _file->GetSource().substr(range.StartOffset, range.GetEndOffset() - range.StartOffset + 1);
+    }
+    return "";
+}
+
 void LuaParser::SkipComment() {
     for (; _tokenIndex < _tokens.size(); _tokenIndex++) {
         switch (_tokens[_tokenIndex].TokenType) {
@@ -453,6 +470,12 @@ void LuaParser::GotoStatement() {
 // exprStat -> call | assignment
 // assignment -> varList '=' exprList
 void LuaParser::ExpressionStatement() {
+    if (Current() == TK_NAME && CurrentText() == "global") {
+        if (TryGlobalStatement()) {
+            return;
+        }
+    }
+
     auto m = Mark();
     SuffixedExpression();
     if (Current() == '=' || Current() == ',') {
@@ -475,6 +498,66 @@ void LuaParser::ExpressionStatement() {
     }
 }
 
+bool LuaParser::TryGlobalStatement() {
+    auto m = Mark();
+    switch (LookAhead()) {
+        case '*':
+            Next();// Global
+            Next();
+
+            TestAndNext(';');
+            m.Complete(*this, LuaSyntaxNodeKind::GlobalStatement);
+            return true;
+        case '<':
+            Next();// Global
+            LocalAttribute();
+
+            switch (Current()) {
+                case TK_NAME:
+                    GlobalNameList();
+                    break;
+                case '*':
+                    Next();
+                    break;
+                default:
+                    break;
+            }
+            TestAndNext(';');
+            m.Complete(*this, LuaSyntaxNodeKind::GlobalStatement);
+            return true;
+        case TK_FUNCTION:
+            Next();// Global
+            Next();// Function
+            CheckName();
+            FunctionBody();
+            TestAndNext(';');
+            m.Complete(*this, LuaSyntaxNodeKind::FunctionStatement);
+            break;
+        case TK_NAME:
+            Next();// Global
+            GlobalNameList();
+            TestAndNext(';');
+            m.Complete(*this, LuaSyntaxNodeKind::GlobalStatement);
+            return true;
+        default:
+            break;
+    }
+
+    m.Undo(*this);
+    return false;
+}
+
+void LuaParser::GlobalNameList() {
+    do {
+        CheckName();
+        LocalAttribute();
+    } while (TestAndNext(','));
+
+    if (TestAndNext('=')) {
+        ExpressionList();
+    }
+}
+
 void LuaParser::Condition() {
     Expression();
 }
@@ -692,6 +775,9 @@ void LuaParser::ParamList() {
                 case TK_DOTS: {
                     isVararg = true;
                     Next();
+                    if (Current() == TK_NAME) {
+                        Next();
+                    }
                     break;
                 }
                 case ')': {