support clike comments

CodeFormat/src/CodeFormat.cpp

@@ -58,6 +58,7 @@ int main(int argc, char **argv) {
                               "Use file wildcards to specify how to ignore files\n"
                               "\t\tseparated by ';'")
             .Add<bool>("non-standard", "", "Enable non-standard formatting")
+            .Add<bool>("c-like-comments", "", "Enable c-like-comments formatting")
             .EnableKeyValueArgs();
     cmd.AddTarget("rangeformat")
             .Add<std::string>("file", "f", "Specify the input file")
@@ -74,6 +75,7 @@ int main(int argc, char **argv) {
             .Add<std::string>("range-line", "", "the format is startline:endline, for eg: 1:10")
             .Add<std::string>("range-offset", "", "the format is startOffset:endOffset, for eg: 0:256")
             .Add<bool>("non-standard", "", "Enable non-standard rangeformatting")
+            .Add<bool>("c-like-comments", "", "Enable c-like-comments formatting")
             .EnableKeyValueArgs();
     cmd.AddTarget("check")
             .Add<std::string>("file", "f", "Specify the input file")
@@ -93,6 +95,7 @@ int main(int argc, char **argv) {
                               "\t\tseparated by ';'")
             .Add<bool>("name-style", "ns", "Enable name-style check")
             .Add<bool>("non-standard", "", "Enable non-standard checking")
+            .Add<bool>("c-like-comments", "", "Enable c-like-comments formatting")
             .Add<bool>("dump-json", "", "Dump json format diagnosis info")
             .EnableKeyValueArgs();
 
@@ -176,6 +179,10 @@ bool InitFormat(CommandLine &cmd, FormatContext &formatContext) {
         formatContext.EnableNonStandardLuaSupport();
     }
 
+    if (cmd.Get<bool>("c-like-comments")) {
+        formatContext.EnableCLikeCommentsSupport();
+    }
+
     formatContext.SetDefaultStyleOptions(cmd.GetKeyValueOptions());
     return true;
 }
@@ -234,10 +241,14 @@ bool InitCheck(CommandLine &cmd, FormatContext &formatContext) {
         formatContext.EnableNameStyleCheckSupport();
     }
 
-    if(cmd.Get<bool>("dump-json")) {
+    if (cmd.Get<bool>("dump-json")) {
         formatContext.EnableJsonDump();
     }
 
+    if (cmd.Get<bool>("c-like-comments")) {
+        formatContext.EnableCLikeCommentsSupport();
+    }
+
     formatContext.SetDefaultStyleOptions(cmd.GetKeyValueOptions());
     return true;
 }

CodeFormat/src/FormatContext.cpp

@@ -157,6 +157,10 @@ void FormatContext::EnableJsonDump() {
     _dumpJson = true;
 }
 
+void FormatContext::EnableCLikeCommentsSupport() {
+    _isSupportCLikeComments = false;
+}
+
 LuaStyle FormatContext::GetStyle(std::string_view path) const {
     std::shared_ptr<LuaEditorConfig> editorConfig = nullptr;
     std::size_t matchProcess = 0;
@@ -232,3 +236,7 @@ std::string FormatContext::GetInputPath() const {
 const LuaDiagnosticStyle &FormatContext::GetDiagnosticStyle() const {
     return _diagnosticStyle;
 }
+
+bool FormatContext::IsCLikeCommentsSupport() const {
+    return _isSupportCLikeComments;
+}

CodeFormat/src/FormatContext.h

@@ -41,6 +41,8 @@ class FormatContext {
 
     void EnableJsonDump();
 
+    void EnableCLikeCommentsSupport();
+
     [[nodiscard]] LuaStyle GetStyle(std::string_view path) const;
 
     [[nodiscard]] WorkMode GetWorkMode() const;
@@ -67,6 +69,7 @@ class FormatContext {
 
     [[nodiscard]] const LuaDiagnosticStyle &GetDiagnosticStyle() const;
 
+    [[nodiscard]] bool IsCLikeCommentsSupport() const;
 private:
     WorkMode _workMode = WorkMode::File;
     std::string _inputPath;
@@ -81,5 +84,6 @@ class FormatContext {
     bool _isRangeLine = false;
     std::string _rangeStr;
     bool _isSupportNonStandardLua = false;
+    bool _isSupportCLikeComments = false;
     bool _dumpJson = false;
 };

CodeFormat/src/LuaCheck.cpp

@@ -57,6 +57,10 @@ bool LuaCheck::CheckSingleFile(const FormatContext &context, std::string_view pa
     if (context.IsNonStandardLua()) {
         luaLexer.SupportNonStandardSymbol();
     }
+    if (context.IsCLikeCommentsSupport()) {
+        luaLexer.SupportCLikeComments();
+    }
+
     luaLexer.Parse();
 
     LuaParser p(file, std::move(luaLexer.GetTokens()));

CodeFormat/src/LuaFormat.cpp

@@ -12,7 +12,6 @@
 #include "Util/format.h"
 #include <fstream>
 #include <iostream>
-#include <sstream>
 
 bool LuaFormat::Reformat(const FormatContext &context) {
     switch (context.GetWorkMode()) {
@@ -37,6 +36,10 @@ bool LuaFormat::ReformatSingleFile(const FormatContext &context, std::string_vie
     if (context.IsNonStandardLua()) {
         luaLexer.SupportNonStandardSymbol();
     }
+    if (context.IsCLikeCommentsSupport()) {
+        luaLexer.SupportCLikeComments();
+    }
+
     luaLexer.Parse();
 
     LuaParser p(file, std::move(luaLexer.GetTokens()));
@@ -75,6 +78,9 @@ bool LuaFormat::RangeReformat(const FormatContext &context) {
     if (context.IsNonStandardLua()) {
         luaLexer.SupportNonStandardSymbol();
     }
+    if (context.IsCLikeCommentsSupport()) {
+        luaLexer.SupportCLikeComments();
+    }
 
     luaLexer.Parse();
 

CodeFormatLib/src/CodeFormatLib.cpp

@@ -169,7 +169,6 @@ int range_format(lua_State *L) {
     return 0;
 }
 
-
 int type_format(lua_State *L) {
     int top = lua_gettop(L);
 
@@ -293,7 +292,6 @@ int type_format(lua_State *L) {
     return 0;
 }
 
-
 int update_config(lua_State *L) {
     int top = lua_gettop(L);
 
@@ -487,6 +485,24 @@ int set_nonstandard_symbol(lua_State *L) {
     return 0;
 }
 
+int set_clike_comments_symbol(lua_State *L) {
+    int top = lua_gettop(L);
+
+    try {
+        LuaCodeFormat::GetInstance().SupportCLikeComments();
+        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;
+    }
+
+    return 0;
+}
+
 int spell_load_dictionary_from_path(lua_State *L) {
     int top = lua_gettop(L);
 
@@ -739,6 +755,7 @@ static const luaL_Reg lib[] = {
         {"spell_analysis",                    spell_analysis                   },
         {"spell_suggest",                     spell_suggest                    },
         {"set_nonstandard_symbol",            set_nonstandard_symbol           },
+        {"set_clike_comments_symbol",         set_clike_comments_symbol        },
         {"name_style_analysis",               name_style_analysis              },
         {"update_name_style_config",          update_name_style_config         },
         {nullptr,                             nullptr                          }

CodeFormatLib/src/LuaCodeFormat.cpp

@@ -11,7 +11,8 @@ LuaCodeFormat &LuaCodeFormat::GetInstance() {
 }
 
 LuaCodeFormat::LuaCodeFormat()
-    : _supportNonStandardSymbol(false) {
+    : _supportNonStandardSymbol(false),
+      _supportCLikeComments(false) {
 }
 
 void LuaCodeFormat::UpdateCodeStyle(const std::string &workspaceUri, const std::string &configPath) {
@@ -58,6 +59,10 @@ void LuaCodeFormat::SupportNonStandardSymbol() {
     _supportNonStandardSymbol = true;
 }
 
+void LuaCodeFormat::SupportCLikeComments() {
+    _supportCLikeComments = true;
+}
+
 void LuaCodeFormat::LoadSpellDictionary(const std::string &path) {
     _spellChecker.LoadDictionary(path);
 }
@@ -72,6 +77,10 @@ Result<std::string> LuaCodeFormat::Reformat(const std::string &uri, std::string
     if (_supportNonStandardSymbol) {
         luaLexer.SupportNonStandardSymbol();
     }
+    if (_supportCLikeComments) {
+        luaLexer.SupportCLikeComments();
+    }
+
     luaLexer.Parse();
 
     LuaParser p(file, std::move(luaLexer.GetTokens()));
@@ -100,6 +109,10 @@ Result<std::string> LuaCodeFormat::RangeFormat(const std::string &uri, FormatRan
     if (_supportNonStandardSymbol) {
         luaLexer.SupportNonStandardSymbol();
     }
+    if (_supportCLikeComments) {
+        luaLexer.SupportCLikeComments();
+    }
+
     luaLexer.Parse();
 
     LuaParser p(file, std::move(luaLexer.GetTokens()));
@@ -130,6 +143,10 @@ LuaCodeFormat::TypeFormat(const std::string &uri, std::size_t line, std::size_t
     if (_supportNonStandardSymbol) {
         luaLexer.SupportNonStandardSymbol();
     }
+    if (_supportCLikeComments) {
+        luaLexer.SupportCLikeComments();
+    }
+
     luaLexer.Parse();
 
     LuaParser p(file, std::move(luaLexer.GetTokens()));
@@ -158,6 +175,10 @@ Result<std::vector<LuaDiagnosticInfo>> LuaCodeFormat::Diagnostic(const std::stri
     if (_supportNonStandardSymbol) {
         luaLexer.SupportNonStandardSymbol();
     }
+    if (_supportCLikeComments) {
+        luaLexer.SupportCLikeComments();
+    }
+
     luaLexer.Parse();
 
     LuaParser p(file, std::move(luaLexer.GetTokens()));
@@ -184,6 +205,10 @@ Result<std::vector<LuaDiagnosticInfo>> LuaCodeFormat::SpellCheck(const std::stri
     if (_supportNonStandardSymbol) {
         luaLexer.SupportNonStandardSymbol();
     }
+    if (_supportCLikeComments) {
+        luaLexer.SupportCLikeComments();
+    }
+
     luaLexer.Parse();
 
     LuaParser p(file, std::move(luaLexer.GetTokens()));
@@ -210,6 +235,10 @@ Result<std::vector<LuaDiagnosticInfo>> LuaCodeFormat::NameStyleCheck(const std::
     if (_supportNonStandardSymbol) {
         luaLexer.SupportNonStandardSymbol();
     }
+    if (_supportCLikeComments) {
+        luaLexer.SupportCLikeComments();
+    }
+
     luaLexer.Parse();
 
     LuaParser p(file, std::move(luaLexer.GetTokens()));

CodeFormatLib/src/LuaCodeFormat.h

@@ -31,6 +31,8 @@ class LuaCodeFormat {
 
     void SupportNonStandardSymbol();
 
+    void SupportCLikeComments();
+
     void LoadSpellDictionary(const std::string &path);
 
     void LoadSpellDictionaryFromBuffer(const std::string &buffer);
@@ -65,4 +67,5 @@ class LuaCodeFormat {
     CodeSpellChecker _spellChecker;
     LuaDiagnosticStyle _diagnosticStyle;
     bool _supportNonStandardSymbol;
+    bool _supportCLikeComments;
 };

LuaParser/include/LuaParser/Lexer/LuaLexer.h

@@ -18,7 +18,7 @@
  */
 class LuaLexer {
 public:
-    explicit LuaLexer(std::shared_ptr<LuaSource> file);
+    explicit LuaLexer(std::shared_ptr<LuaSource> source);
 
     bool Parse();
 
@@ -32,7 +32,7 @@ class LuaLexer {
 
     void SupportNonStandardSymbol();
 
-    //	void SetCustomParser(std::shared_ptr<LuaCustomParser> parser);
+    void SupportCLikeComments();
 private:
     static std::map<std::string, LuaTokenKind, std::less<>> LuaReserved;
 
@@ -52,12 +52,13 @@ class LuaLexer {
 
     bool CurrentIsNewLine();
 
-    bool IsReserved(std::string_view text);
+    static bool IsReserved(std::string_view text);
 
     void TokenError(std::string_view message, TextRange range);
 
     int _linenumber;
     bool _supportNonStandardSymbol;
+    bool _supportCLikeComments;
     TextReader _reader;
     std::vector<LuaToken> _tokens;
     std::vector<LuaTokenError> _errors;

LuaParser/src/Lexer/LuaLexer.cpp

@@ -42,11 +42,12 @@ std::map<std::string, LuaTokenKind, std::less<>> LuaLexer::LuaReserved = {
         {"::",       TK_DBCOLON }
 };
 
-LuaLexer::LuaLexer(std::shared_ptr<LuaSource> file)
+LuaLexer::LuaLexer(std::shared_ptr<LuaSource> source)
     : _linenumber(0),
       _supportNonStandardSymbol(false),
-      _reader(file->GetSource()),
-      _file(file) {
+      _supportCLikeComments(false),
+      _reader(source->GetSource()),
+      _file(source) {
 }
 
 bool LuaLexer::Parse() {
@@ -85,6 +86,13 @@ std::vector<LuaToken> &LuaLexer::GetTokens() {
     return _tokens;
 }
 
+void LuaLexer::SupportNonStandardSymbol() {
+    _supportNonStandardSymbol = true;
+}
+void LuaLexer::SupportCLikeComments(){
+    _supportCLikeComments = true;
+}
+
 LuaTokenKind LuaLexer::Lex() {
     _reader.ResetBuffer();
 
@@ -204,9 +212,18 @@ LuaTokenKind LuaLexer::Lex() {
                         }
                         case '/': {
                             _reader.SaveAndNext();
+
+                            if(_supportCLikeComments) {
+                                while (!CurrentIsNewLine() && _reader.GetCurrentChar() != EOZ) {
+                                    _reader.SaveAndNext();
+                                }
+                                return TK_SHORT_COMMENT;
+                            }
+
                             if (_reader.CheckNext1('=')) {
                                 return '=';
                             }
+
                             return TK_IDIV;
                         }
                         case '*': {
@@ -607,7 +624,3 @@ bool LuaLexer::IsReserved(std::string_view text) {
 void LuaLexer::TokenError(std::string_view message, TextRange range) {
     _errors.emplace_back(message, range, 0);
 }
-
-void LuaLexer::SupportNonStandardSymbol() {
-    _supportNonStandardSymbol = true;
-}

Test/src/Grammar_unitest.cpp

@@ -62,4 +62,15 @@ local t = disableControl?.disableMovement
 local t2 = ddd?:ffffff()
 local t3 = ddd?["hello"]
 )", true).HasError()) << "extend grammar nullable operator test fail";
+    EXPECT_FALSE(TestHelper::GetParser(R"(
+local t = a // yes it is a comment
+)", true).HasError()) << "extend grammar comment test fail";
+    EXPECT_FALSE(TestHelper::GetParser(R"(
+-- yes it is a comment
+// it is a comemnt
+local t = a /*
+a new comments
+
+*/
+)", true, true).HasError()) << "extend grammar comment test fail";
 }