🔧 chore(symbol): trace per-library file indexing

- Log each indexed .tsf file at trace level during LoadSystemLibrary.
- Include top-level symbol summary when a file is skipped for stem mismatch.

lsp-server/.clangd

@@ -1,5 +1,9 @@
+CompileFlags:
+  CompilationDatabase: build/clang-linux/Release
+
+---
 If:
-  PathMatch: [.*\.hpp, .*\.cpp]
+  PathMatch: [.*\.hpp, .*\.hxx, .*\.cpp, .*\.cc, .*\.cxx, .*\.cppm, .*\.ixx, .*\.mpp]
 
 CompileFlags:
   Add:

lsp-server/src/CMakeLists.txt

@@ -41,9 +41,9 @@ endif()
 set(CMAKE_EXPERIMENTAL_CXX_MODULE_DYNDEP 1)
 
 set(SOURCES
-    main.cppm
+    cli/launcher.cppm
+    main.cc
     utils/args_parser.cppm
-    utils/string.cpp
     utils/text_coordinates.cppm
     core/dispacther.cppm
     core/server.cppm
@@ -86,7 +86,7 @@ target_sources(
                                                bridge/spdlog.cppm
                                                bridge/taskflow.cppm
                                                bridge/tree_sitter.cppm
-                                               main.cppm
+                                               cli/launcher.cppm
                                                language/ast/ast.cppm
                                                language/ast/types.cppm
                                                language/ast/deserializer.cppm

lsp-server/src/cli/launcher.cppm

@@ -1,14 +1,14 @@
 module;
 
+export module lsp.cli.launcher;
 
-export module lsp.main;
 import spdlog;
-
 import std;
+
 import lsp.core.server;
 import lsp.utils.args_parser;
 
-int main(int argc, char* argv[])
+export int Run(int argc, char* argv[])
 {
     lsp::utils::ArgsParser& args_parser = lsp::utils::ArgsParser::Instance();
     auto& config = args_parser.Parse(argc, argv);
@@ -24,7 +24,7 @@ int main(int argc, char* argv[])
     try
     {
         spdlog::info("TSL-LSP server starting...");
-        lsp::core::LspServer server(config.thread_count);
+        lsp::core::LspServer server(config.thread_count, config.interpreter_path);
         server.Run();
     }
     catch (const std::exception& e)

lsp-server/src/core/server.cppm

@@ -15,6 +15,7 @@ import lsp.core.dispacther;
 import lsp.protocol;
 import lsp.codec.facade;
 import lsp.manager.manager_hub;
+import lsp.manager.bootstrap;
 import lsp.scheduler.async_executor;
 import lsp.provider.base.interface;
 import lsp.provider.base.registry;
@@ -37,7 +38,8 @@ export namespace lsp::core
     class LspServer
     {
     public:
-        LspServer(std::size_t concurrency = std::thread::hardware_concurrency());
+        explicit LspServer(std::size_t concurrency = std::thread::hardware_concurrency(),
+                           std::string interpreter_path = "");
         ~LspServer();
         void Run();
 
@@ -80,6 +82,7 @@ export namespace lsp::core
         RequestDispatcher dispatcher_;
         scheduler::AsyncExecutor async_executor_;
         manager::ManagerHub manager_hub_;
+        std::string interpreter_path_;
 
         std::atomic<bool> is_initialized_ = false;
         std::atomic<bool> is_shutting_down_ = false;
@@ -89,7 +92,8 @@ export namespace lsp::core
 
 namespace lsp::core
 {
-    LspServer::LspServer(std::size_t concurrency) : async_executor_(concurrency)
+    LspServer::LspServer(std::size_t concurrency, std::string interpreter_path) : async_executor_(concurrency),
+                                                                                  interpreter_path_(std::move(interpreter_path))
     {
         spdlog::info("Initializing LSP server with {} worker threads", concurrency);
 
@@ -108,6 +112,7 @@ namespace lsp::core
     void LspServer::Run()
     {
         spdlog::info("LSP server starting main loop...");
+        spdlog::info("Waiting for LSP messages on stdin...");
 
 // 设置二进制模式
 #ifdef _WIN32
@@ -378,6 +383,23 @@ namespace lsp::core
     void LspServer::InitializeManagerHub()
     {
         manager_hub_.Initialize();
+
+        if (!interpreter_path_.empty())
+        {
+            std::filesystem::path base = interpreter_path_;
+            std::filesystem::path funcext_path = base / "funcext";
+            if (std::filesystem::exists(funcext_path))
+            {
+                manager::bootstrap::InitializeManagerHub(
+                    manager_hub_,
+                    async_executor_,
+                    { funcext_path.string() });
+            }
+            else
+            {
+                spdlog::warn("Interpreter funcext path does not exist: {}", funcext_path.string());
+            }
+        }
     }
 
     void LspServer::RegisterProviders()

lsp-server/src/language/ast/detail.cppm

@@ -1,6 +1,5 @@
 module;
 
-
 module lsp.language.ast:detail;
 import tree_sitter;
 
@@ -113,6 +112,7 @@ namespace lsp::language::ast::detail
     ExpressionPtr ParseEchoExpression(TSNode node, ParseContext& ctx);
     ExpressionPtr ParseRaiseExpression(TSNode node, ParseContext& ctx);
     ExpressionPtr ParseInheritedExpression(TSNode node, ParseContext& ctx);
+    ExpressionPtr ParseRdoExpression(TSNode node, ParseContext& ctx);
 
     ExpressionPtr ParseArrayExpression(TSNode node, ParseContext& ctx);
     ExpressionPtr ParseParenthesizedExpression(TSNode node, ParseContext& ctx);
@@ -589,6 +589,8 @@ namespace lsp::language::ast::detail
             return ParseRaiseExpression(node, ctx);
         if (node_type == "inherited_expression")
             return ParseInheritedExpression(node, ctx);
+        if (node_type == "rdo_expression")
+            return ParseRdoExpression(node, ctx);
 
         if (node_type == "array_expression")
             return ParseArrayExpression(node, ctx);
@@ -751,7 +753,26 @@ namespace lsp::language::ast::detail
         auto expr = MakeNode<InheritedExpression>();
         expr->span = ts_utils::NodeLocation(node);
 
-        TSNode call_node = ts_node_child_by_field_name(node, "class", 5);
+        TSNode call_node = ts_node_child_by_field_name(node, "call", 4);
+        if (!ts_node_is_null(call_node))
+        {
+            auto call_expr = ParseExpression(call_node, ctx);
+            if (call_expr && call_expr->kind == NodeKind::kCallExpression)
+            {
+                expr->call = std::unique_ptr<CallExpression>(
+                    static_cast<CallExpression*>(call_expr.release()));
+            }
+        }
+
+        return expr;
+    }
+
+    ExpressionPtr ParseRdoExpression(TSNode node, ParseContext& ctx)
+    {
+        auto expr = MakeNode<RdoExpression>();
+        expr->span = ts_utils::NodeLocation(node);
+
+        TSNode call_node = ts_node_child_by_field_name(node, "call", 4);
         if (!ts_node_is_null(call_node))
         {
             auto call_expr = ParseExpression(call_node, ctx);

lsp-server/src/language/ast/types.cppm

@@ -1,6 +1,5 @@
 module;
 
-
 export module lsp.language.ast:types;
 import tree_sitter;
 
@@ -213,6 +212,7 @@ export namespace lsp::language::ast
         kEchoExpression,
         kRaiseExpression,
         kInheritedExpression,
+        kRdoExpression,
 
         kTSSQLExpression,
         kColumnReference,
@@ -327,6 +327,7 @@ export namespace lsp::language::ast
     class EchoExpression;
     class RaiseExpression;
     class InheritedExpression;
+    class RdoExpression;
     class TSSQLExpression;
     class ColumnReference;
 
@@ -473,6 +474,7 @@ export namespace lsp::language::ast
         virtual void VisitEchoExpression(EchoExpression& node) = 0;
         virtual void VisitRaiseExpression(RaiseExpression& node) = 0;
         virtual void VisitInheritedExpression(InheritedExpression& node) = 0;
+        virtual void VisitRdoExpression(RdoExpression& node) = 0;
         virtual void VisitTSSQLExpression(TSSQLExpression& node) = 0;
         virtual void VisitColumnReference(ColumnReference& node) = 0;
 
@@ -895,6 +897,16 @@ export namespace lsp::language::ast
         std::optional<std::unique_ptr<CallExpression>> call;
     };
 
+    class RdoExpression : public Expression
+    {
+    public:
+        RdoExpression() { kind = NodeKind::kRdoExpression; }
+        void Accept(ASTVisitor& visitor) override { visitor.VisitRdoExpression(*this); }
+
+    public:
+        std::optional<std::unique_ptr<CallExpression>> call;
+    };
+
     class TSSQLExpression : public Expression
     {
     public:

lsp-server/src/language/semantic/analyzer.cppm

@@ -11,6 +11,77 @@ import lsp.utils.string;
 
 namespace lsp::language::semantic
 {
+    namespace
+    {
+        std::optional<std::string> UnquoteStringLiteral(std::string value)
+        {
+            if (value.size() < 2)
+            {
+                return std::nullopt;
+            }
+
+            char first = value.front();
+            char last = value.back();
+            if ((first == '"' && last == '"') || (first == '\'' && last == '\''))
+            {
+                value.erase(value.begin());
+                value.pop_back();
+                return value;
+            }
+
+            return std::nullopt;
+        }
+
+        std::optional<std::pair<std::string, std::string>> ParseQualifiedTypeName(const std::string& text)
+        {
+            std::string trimmed = utils::Trim(text);
+            if (trimmed.empty())
+            {
+                return std::nullopt;
+            }
+
+            std::string lower = utils::ToLower(trimmed);
+            if (lower.starts_with("unit("))
+            {
+                std::string after_unit = trimmed.substr(5);
+                std::size_t close_paren = after_unit.find(')');
+                if (close_paren == std::string::npos)
+                {
+                    return std::nullopt;
+                }
+
+                std::string unit_name = utils::Trim(after_unit.substr(0, close_paren));
+                std::size_t dot_pos = after_unit.find('.', close_paren);
+                if (dot_pos == std::string::npos || dot_pos + 1 >= after_unit.size())
+                {
+                    return std::nullopt;
+                }
+
+                std::string class_name = utils::Trim(after_unit.substr(dot_pos + 1));
+                if (unit_name.empty() || class_name.empty())
+                {
+                    return std::nullopt;
+                }
+
+                return std::make_pair(std::move(unit_name), std::move(class_name));
+            }
+
+            std::size_t dot_pos = trimmed.find_last_of('.');
+            if (dot_pos == std::string::npos || dot_pos == 0 || dot_pos + 1 >= trimmed.size())
+            {
+                return std::nullopt;
+            }
+
+            std::string unit_name = utils::Trim(trimmed.substr(0, dot_pos));
+            std::string class_name = utils::Trim(trimmed.substr(dot_pos + 1));
+            if (unit_name.empty() || class_name.empty())
+            {
+                return std::nullopt;
+            }
+
+            return std::make_pair(std::move(unit_name), std::move(class_name));
+        }
+    }
 
     Analyzer::Analyzer(symbol::SymbolTable& symbol_table,
                        SemanticModel& semantic_model) : symbol_table_(symbol_table),
@@ -447,21 +518,28 @@ namespace lsp::language::semantic
 
     void Analyzer::VisitUsesStatement(ast::UsesStatement& node)
     {
+        auto add_to = [&](std::vector<symbol::UnitImport>& target) {
+            target.reserve(target.size() + node.units.size());
+            for (const auto& unit : node.units)
+            {
+                symbol::UnitImport import;
+                import.unit_name = unit.name;
+                import.location = unit.location;
+                target.push_back(std::move(import));
+            }
+        };
+
         if (!current_unit_context_)
         {
+            // Top-level `uses` is treated as file-global.
+            add_to(file_imports_);
             return;
         }
 
         auto& context = *current_unit_context_;
         auto* target = current_unit_section_ == symbol::UnitVisibility::kInterface ? &context.interface_imports : &context.implementation_imports;
 
-        for (const auto& unit : node.units)
-        {
-            symbol::UnitImport import;
-            import.unit_name = unit.name;
-            import.location = unit.location;
-            target->push_back(std::move(import));
-        }
+        add_to(*target);
     }
 
     void Analyzer::VisitIdentifier(ast::Identifier& node)
@@ -737,7 +815,74 @@ namespace lsp::language::semantic
             }
             else if ([[maybe_unused]] auto* attr = dynamic_cast<ast::AttributeExpression*>(node.target.get()))
             {
-                // 处理限定名的类型（如 SomeUnit.SomeClass）
+                const auto* class_ident = dynamic_cast<ast::Identifier*>(attr->attribute.get());
+                if (class_ident && !class_ident->name.empty())
+                {
+                    std::optional<std::string> unit_name;
+                    if (const auto* unit_ident = dynamic_cast<ast::Identifier*>(attr->object.get()))
+                    {
+                        unit_name = unit_ident->name;
+                    }
+                    else if (const auto* unit_call = dynamic_cast<ast::CallExpression*>(attr->object.get()))
+                    {
+                        if (const auto* callee_ident = dynamic_cast<ast::Identifier*>(unit_call->callee.get()))
+                        {
+                            if (utils::IEquals(callee_ident->name, "unit") && !unit_call->arguments.empty() && unit_call->arguments[0].value)
+                            {
+                                if (const auto* arg_ident = dynamic_cast<ast::Identifier*>(unit_call->arguments[0].value.get()))
+                                {
+                                    unit_name = arg_ident->name;
+                                }
+                            }
+                        }
+                    }
+
+                    if (unit_name && !unit_name->empty())
+                    {
+                        auto unit_id = ResolveIdentifier(*unit_name, class_ident->location);
+                        if (unit_id)
+                        {
+                            const auto* unit_symbol = symbol_table_.definition(*unit_id);
+                            if (unit_symbol && unit_symbol->Is<symbol::Unit>())
+                            {
+                                auto scope_id = FindScopeOwnedBy(*unit_id);
+                                if (scope_id)
+                                {
+                                    auto member_id = symbol_table_.scopes().FindSymbolInScope(*scope_id, class_ident->name);
+                                    if (member_id)
+                                    {
+                                        const auto* member_symbol = symbol_table_.definition(*member_id);
+                                        if (member_symbol && member_symbol->kind() == protocol::SymbolKind::Class)
+                                        {
+                                            TrackReference(*member_id, class_ident->location, false);
+
+                                            auto class_scope_id = FindScopeOwnedBy(*member_id);
+                                            if (class_scope_id)
+                                            {
+                                                auto ctor_id = symbol_table_.scopes().FindSymbolInScope(*class_scope_id, class_ident->name);
+                                                if (ctor_id)
+                                                {
+                                                    TrackCall(*ctor_id, node.span);
+                                                }
+                                                else
+                                                {
+                                                    TrackCall(*member_id, node.span);
+                                                }
+                                            }
+                                            else
+                                            {
+                                                TrackCall(*member_id, node.span);
+                                            }
+                                            return;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                // fallback
                 VisitExpression(*node.target);
             }
             else
@@ -780,6 +925,15 @@ namespace lsp::language::semantic
         // TODO: 处理 inherited 调用
     }
 
+    void Analyzer::VisitRdoExpression(ast::RdoExpression& node)
+    {
+        if (node.call && *node.call)
+        {
+            (*node.call)->Accept(*this);
+        }
+        // TODO: 处理 rdo/rdo2 语义
+    }
+
     void Analyzer::VisitParenthesizedExpression(ast::ParenthesizedExpression& node)
     {
         for (const auto& element : node.elements)
@@ -1020,64 +1174,78 @@ namespace lsp::language::semantic
 
     std::optional<symbol::SymbolId> Analyzer::ResolveFromUses(const std::string& name)
     {
-        if (!current_unit_context_)
-        {
-            return std::nullopt;
-        }
-
-        // 获取当前上下文的导入列表
-        const auto& imports = current_unit_section_ == symbol::UnitVisibility::kInterface ? current_unit_context_->interface_imports : current_unit_context_->implementation_imports;
-
-        // 从后往前查找（最后导入的优先级最高）
-        for (auto it = imports.rbegin(); it != imports.rend(); ++it)
-        {
-            const auto& unit_import = *it;
-
-            // 1. 查找导入的 unit 符号
-            auto unit_matches = symbol_table_.FindSymbolsByName(unit_import.unit_name);
-            if (unit_matches.empty())
+        auto resolve_from_imports = [&](const std::vector<symbol::UnitImport>& imports) -> std::optional<symbol::SymbolId> {
+            // 从后往前查找（最后导入的优先级最高）
+            for (auto it = imports.rbegin(); it != imports.rend(); ++it)
             {
-                // 如果本地找不到，尝试通过 external_symbol_provider_ 查找
-                if (external_symbol_provider_)
+                const auto& unit_import = *it;
+
+                // 1. 查找导入的 unit 符号
+                auto unit_matches = symbol_table_.FindSymbolsByName(unit_import.unit_name);
+                if (unit_matches.empty())
                 {
-                    auto external_unit = external_symbol_provider_(unit_import.unit_name);
-                    if (external_unit)
+                    // 如果本地找不到，尝试通过 external_symbol_provider_ 查找
+                    if (external_symbol_provider_)
                     {
-                        auto unit_id = symbol_table_.CreateSymbol(std::move(*external_unit));
-                        unit_matches.push_back(unit_id);
+                        auto external_unit = external_symbol_provider_(unit_import.unit_name);
+                        if (external_unit)
+                        {
+                            auto unit_id = symbol_table_.CreateSymbol(std::move(*external_unit));
+                            unit_matches.push_back(unit_id);
+                        }
+                    }
+                }
+
+                // 2. 在每个找到的 unit 中查找目标符号
+                for (auto unit_id : unit_matches)
+                {
+                    const auto* unit_symbol = symbol_table_.definition(unit_id);
+                    if (!unit_symbol || !unit_symbol->Is<symbol::Unit>())
+                    {
+                        continue;
+                    }
+
+                    // 3. 查找 unit 的作用域
+                    auto unit_scope_id = FindScopeOwnedBy(unit_id);
+                    if (!unit_scope_id)
+                    {
+                        continue;
+                    }
+
+                    // 4. 在 unit 的 Interface 作用域中查找符号
+                    auto symbol_id = symbol_table_.scopes().FindSymbolInScope(*unit_scope_id, name);
+                    if (symbol_id)
+                    {
+                        // 验证符号是否在 Interface 部分（通过 visibility 检查）
+                        const auto* symbol = symbol_table_.definition(*symbol_id);
+                        if (symbol)
+                        {
+                            // 如果符号有 visibility 信息，确保它是 Interface 可见的
+                            // TODO: 需要符号表支持 visibility 标记
+                            return symbol_id;
+                        }
                     }
                 }
             }
 
-            // 2. 在每个找到的 unit 中查找目标符号
-            for (auto unit_id : unit_matches)
+            return std::nullopt;
+        };
+
+        if (current_unit_context_)
+        {
+            // 获取当前上下文的导入列表
+            const auto& imports = current_unit_section_ == symbol::UnitVisibility::kInterface ? current_unit_context_->interface_imports : current_unit_context_->implementation_imports;
+            if (auto result = resolve_from_imports(imports))
             {
-                const auto* unit_symbol = symbol_table_.definition(unit_id);
-                if (!unit_symbol || !unit_symbol->Is<symbol::Unit>())
-                {
-                    continue;
-                }
+                return result;
+            }
+        }
 
-                // 3. 查找 unit 的作用域
-                auto unit_scope_id = FindScopeOwnedBy(unit_id);
-                if (!unit_scope_id)
-                {
-                    continue;
-                }
-
-                // 4. 在 unit 的 Interface 作用域中查找符号
-                auto symbol_id = symbol_table_.scopes().FindSymbolInScope(*unit_scope_id, name);
-                if (symbol_id)
-                {
-                    // 验证符号是否在 Interface 部分（通过 visibility 检查）
-                    const auto* symbol = symbol_table_.definition(*symbol_id);
-                    if (symbol)
-                    {
-                        // 如果符号有 visibility 信息，确保它是 Interface 可见的
-                        // TODO: 需要符号表支持 visibility 标记
-                        return symbol_id;
-                    }
-                }
+        if (!file_imports_.empty())
+        {
+            if (auto result = resolve_from_imports(file_imports_))
+            {
+                return result;
             }
         }
 
@@ -1141,6 +1309,56 @@ namespace lsp::language::semantic
                         return type_system.CreateClassType(*class_id);
                     }
                 }
+                else if (auto* attr = dynamic_cast<ast::AttributeExpression*>(new_expr->target.get()))
+                {
+                    const auto* class_ident = dynamic_cast<ast::Identifier*>(attr->attribute.get());
+                    if (class_ident && !class_ident->name.empty())
+                    {
+                        std::optional<std::string> unit_name;
+                        if (const auto* unit_ident = dynamic_cast<ast::Identifier*>(attr->object.get()))
+                        {
+                            unit_name = unit_ident->name;
+                        }
+                        else if (const auto* unit_call = dynamic_cast<ast::CallExpression*>(attr->object.get()))
+                        {
+                            if (const auto* callee_ident = dynamic_cast<ast::Identifier*>(unit_call->callee.get()))
+                            {
+                                if (utils::IEquals(callee_ident->name, "unit") && !unit_call->arguments.empty() && unit_call->arguments[0].value)
+                                {
+                                    if (const auto* arg_ident = dynamic_cast<ast::Identifier*>(unit_call->arguments[0].value.get()))
+                                    {
+                                        unit_name = arg_ident->name;
+                                    }
+                                }
+                            }
+                        }
+
+                        if (unit_name && !unit_name->empty())
+                        {
+                            auto unit_id = ResolveIdentifier(*unit_name, class_ident->location);
+                            if (unit_id)
+                            {
+                                const auto* unit_symbol = symbol_table_.definition(*unit_id);
+                                if (unit_symbol && unit_symbol->Is<symbol::Unit>())
+                                {
+                                    auto scope_id = FindScopeOwnedBy(*unit_id);
+                                    if (scope_id)
+                                    {
+                                        auto member_id = symbol_table_.scopes().FindSymbolInScope(*scope_id, class_ident->name);
+                                        if (member_id)
+                                        {
+                                            const auto* member_symbol = symbol_table_.definition(*member_id);
+                                            if (member_symbol && member_symbol->kind() == protocol::SymbolKind::Class)
+                                            {
+                                                return type_system.CreateClassType(*member_id);
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
             }
             return type_system.GetUnknownType();
         }
@@ -1149,6 +1367,58 @@ namespace lsp::language::semantic
         {
             if (auto* ident = dynamic_cast<ast::Identifier*>(call->callee.get()))
             {
+                if (utils::IEquals(ident->name, "createobject"))
+                {
+                    if (!call->arguments.empty() && call->arguments.front().value)
+                    {
+                        if (auto* lit = dynamic_cast<ast::Literal*>(call->arguments.front().value.get()))
+                        {
+                            if (lit->literal_kind == ast::LiteralKind::kString)
+                            {
+                                std::string type_name = lit->value;
+                                if (auto unquoted = UnquoteStringLiteral(type_name))
+                                {
+                                    type_name = *unquoted;
+                                }
+
+                                if (auto qualified = ParseQualifiedTypeName(type_name))
+                                {
+                                    auto unit_id = ResolveIdentifier(qualified->first, lit->location);
+                                    if (unit_id)
+                                    {
+                                        const auto* unit_symbol = symbol_table_.definition(*unit_id);
+                                        if (unit_symbol && unit_symbol->Is<symbol::Unit>())
+                                        {
+                                            auto scope_id = FindScopeOwnedBy(*unit_id);
+                                            if (scope_id)
+                                            {
+                                                auto member_id = symbol_table_.scopes().FindSymbolInScope(*scope_id, qualified->second);
+                                                if (member_id)
+                                                {
+                                                    const auto* member_symbol = symbol_table_.definition(*member_id);
+                                                    if (member_symbol && member_symbol->kind() == protocol::SymbolKind::Class)
+                                                    {
+                                                        return type_system.CreateClassType(*member_id);
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                else
+                                {
+                                    auto class_id = ResolveClassSymbol(type_name, lit->location);
+                                    if (class_id)
+                                    {
+                                        return type_system.CreateClassType(*class_id);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    return type_system.GetUnknownType();
+                }
+
                 auto callee_id = ResolveIdentifier(ident->name, ident->location);
                 if (callee_id)
                 {

lsp-server/src/language/semantic/interface.cppm

@@ -1,6 +1,5 @@
 module;
 
-
 export module lsp.language.semantic:interface;
 import tree_sitter;
 
@@ -628,6 +627,7 @@ export namespace lsp::language::semantic
         void VisitEchoExpression(ast::EchoExpression& node) override;
         void VisitRaiseExpression(ast::RaiseExpression& node) override;
         void VisitInheritedExpression(ast::InheritedExpression& node) override;
+        void VisitRdoExpression(ast::RdoExpression& node) override;
         void VisitParenthesizedExpression(ast::ParenthesizedExpression& node) override;
 
         void VisitExpressionStatement(ast::ExpressionStatement& node) override;
@@ -681,6 +681,7 @@ export namespace lsp::language::semantic
         std::optional<symbol::SymbolId> current_class_id_;
         std::optional<UnitContext> current_unit_context_;
         std::optional<symbol::UnitVisibility> current_unit_section_;
+        std::vector<symbol::UnitImport> file_imports_;
         ExternalSymbolProvider external_symbol_provider_;
         std::unordered_map<std::string, symbol::SymbolId> imported_symbols_;
     };

lsp-server/src/language/symbol/internal/builder.cppm

@@ -7,9 +7,177 @@ module lsp.language.symbol:internal.builder;
 import :types;
 import lsp.language.ast;
 import lsp.protocol.types;
+import lsp.utils.string;
 
 namespace lsp::language::symbol
 {
+    namespace
+    {
+        std::optional<std::string> UnquoteStringLiteral(std::string value)
+        {
+            if (value.size() < 2)
+            {
+                return std::nullopt;
+            }
+
+            char first = value.front();
+            char last = value.back();
+            if ((first == '"' && last == '"') || (first == '\'' && last == '\''))
+            {
+                value.erase(value.begin());
+                value.pop_back();
+                return value;
+            }
+
+            return std::nullopt;
+        }
+
+        std::optional<std::string> ExtractClassNameFromExpression(const ast::Expression* expr)
+        {
+            if (!expr)
+            {
+                return std::nullopt;
+            }
+
+            if (const auto* ident = dynamic_cast<const ast::Identifier*>(expr))
+            {
+                if (!ident->name.empty())
+                {
+                    return ident->name;
+                }
+                return std::nullopt;
+            }
+
+            if (const auto* attr = dynamic_cast<const ast::AttributeExpression*>(expr))
+            {
+                // Prefer preserving unit-qualified names like `UnitA.ClassName` / `unit(UnitA).ClassName`,
+                // fallback to last attribute segment if we can't extract a qualifier.
+                auto attr_name = ExtractClassNameFromExpression(attr->attribute.get());
+                if (!attr_name || attr_name->empty())
+                {
+                    return std::nullopt;
+                }
+
+                std::optional<std::string> qualifier;
+                if (const auto* obj_ident = dynamic_cast<const ast::Identifier*>(attr->object.get()))
+                {
+                    if (!obj_ident->name.empty())
+                    {
+                        qualifier = obj_ident->name;
+                    }
+                }
+                else if (const auto* obj_call = dynamic_cast<const ast::CallExpression*>(attr->object.get()))
+                {
+                    if (const auto* callee_ident = dynamic_cast<const ast::Identifier*>(obj_call->callee.get()))
+                    {
+                        if (utils::IEquals(callee_ident->name, "unit") && !obj_call->arguments.empty() && obj_call->arguments[0].value)
+                        {
+                            if (const auto* arg_ident = dynamic_cast<const ast::Identifier*>(obj_call->arguments[0].value.get()))
+                            {
+                                if (!arg_ident->name.empty())
+                                {
+                                    qualifier = "unit(" + arg_ident->name + ")";
+                                }
+                            }
+                        }
+                    }
+                }
+
+                if (qualifier && !qualifier->empty())
+                {
+                    return *qualifier + "." + *attr_name;
+                }
+
+                return attr_name;
+            }
+
+            if (const auto* call = dynamic_cast<const ast::CallExpression*>(expr))
+            {
+                return ExtractClassNameFromExpression(call->callee.get());
+            }
+
+            return std::nullopt;
+        }
+
+        std::optional<std::string> InferTypeFromExpression(const ast::Expression* expr)
+        {
+            if (!expr)
+            {
+                return std::nullopt;
+            }
+
+            if (const auto* new_expr = dynamic_cast<const ast::NewExpression*>(expr))
+            {
+                return ExtractClassNameFromExpression(new_expr->target.get());
+            }
+
+            if (const auto* call = dynamic_cast<const ast::CallExpression*>(expr))
+            {
+                const auto* callee_ident = dynamic_cast<const ast::Identifier*>(call->callee.get());
+                if (!callee_ident)
+                {
+                    return std::nullopt;
+                }
+
+                if (!utils::IEquals(utils::ToLower(callee_ident->name), "createobject"))
+                {
+                    return std::nullopt;
+                }
+
+                if (call->arguments.empty() || !call->arguments[0].value)
+                {
+                    return std::nullopt;
+                }
+
+                const auto* literal = dynamic_cast<const ast::Literal*>(call->arguments[0].value.get());
+                if (!literal || literal->literal_kind != ast::LiteralKind::kString)
+                {
+                    return std::nullopt;
+                }
+
+                if (auto unquoted = UnquoteStringLiteral(literal->value))
+                {
+                    if (!unquoted->empty())
+                    {
+                        return *unquoted;
+                    }
+                }
+                return std::nullopt;
+            }
+
+            return std::nullopt;
+        }
+
+        void MaybeUpdateSymbolType(SymbolTable& table, ScopeId scope_id, const std::string& name, const std::string& type_name)
+        {
+            if (name.empty() || type_name.empty())
+            {
+                return;
+            }
+
+            auto id_opt = table.scopes().FindSymbolInScopeChain(scope_id, name);
+            if (!id_opt)
+            {
+                return;
+            }
+
+            Symbol* symbol = const_cast<Symbol*>(table.definition(*id_opt));
+            if (!symbol)
+            {
+                return;
+            }
+
+            if (auto* var = symbol->As<Variable>())
+            {
+                var->type = type_name;
+            }
+            else if (auto* field = symbol->As<Field>())
+            {
+                field->type = type_name;
+            }
+        }
+    }
+
     Builder::Builder(SymbolTable& table) : table_(table),
                                            current_scope_id_(kInvalidScopeId),
                                            in_interface_section_(false),
@@ -64,6 +232,14 @@ namespace lsp::language::symbol
         Symbol symbol = [&]() -> Symbol {
             switch (kind)
             {
+            case protocol::SymbolKind::Module:
+            {
+                Unit unit;
+                unit.name = name;
+                unit.selection_range = location;
+                unit.range = location;
+                return Symbol(std::move(unit));
+            }
             case protocol::SymbolKind::Class:
             {
                 Class cls;
@@ -256,6 +432,30 @@ namespace lsp::language::symbol
 
     Builder::ScopeGuard Builder::EnterScopeWithSymbol(ScopeKind kind, SymbolId symbol_id, const ast::Location& range)
     {
+        if (!file_imports_.empty() && file_imports_applied_.insert(symbol_id).second)
+        {
+            Symbol* owner_symbol = const_cast<Symbol*>(table_.definition(symbol_id));
+            if (owner_symbol)
+            {
+                if (auto* fn = owner_symbol->As<Function>())
+                {
+                    fn->imports.insert(fn->imports.begin(), file_imports_.begin(), file_imports_.end());
+                }
+                else if (auto* method = owner_symbol->As<Method>())
+                {
+                    method->imports.insert(method->imports.begin(), file_imports_.begin(), file_imports_.end());
+                }
+                else if (auto* cls = owner_symbol->As<Class>())
+                {
+                    cls->imports.insert(cls->imports.begin(), file_imports_.begin(), file_imports_.end());
+                }
+                else if (auto* unit = owner_symbol->As<Unit>())
+                {
+                    unit->interface_imports.insert(unit->interface_imports.begin(), file_imports_.begin(), file_imports_.end());
+                    unit->implementation_imports.insert(unit->implementation_imports.begin(), file_imports_.begin(), file_imports_.end());
+                }
+            }
+        }
         current_scope_id_ = table_.CreateScope(kind, range, current_scope_id_, symbol_id);
         return ScopeGuard(*this, current_scope_id_);
     }
@@ -544,7 +744,13 @@ namespace lsp::language::symbol
 
     void Builder::VisitVarDeclaration(ast::VarDeclaration& node)
     {
-        CreateSymbol(node.name, protocol::SymbolKind::Variable, node.location, ExtractTypeName(node.type));
+        auto type_hint = ExtractTypeName(node.type);
+        if (!type_hint && node.initializer && *node.initializer)
+        {
+            type_hint = InferTypeFromExpression(node.initializer->get());
+        }
+
+        CreateSymbol(node.name, protocol::SymbolKind::Variable, node.location, type_hint);
 
         if (node.initializer && *node.initializer)
         {
@@ -624,6 +830,12 @@ namespace lsp::language::symbol
         const auto* scope_info = table_.scopes().scope(current_scope_id_);
         if (!scope_info || !scope_info->owner)
         {
+            // Top-level `uses` (no owner scope) is treated as file-global.
+            file_imports_.reserve(file_imports_.size() + node.units.size());
+            for (const auto& unit : node.units)
+            {
+                file_imports_.push_back({ unit.name, unit.location });
+            }
             return;
         }
 
@@ -702,11 +914,40 @@ namespace lsp::language::symbol
 
     void Builder::VisitAssignmentExpression(ast::AssignmentExpression& node)
     {
+        std::optional<std::string> inferred_type;
+        if (node.right)
+        {
+            inferred_type = InferTypeFromExpression(node.right.get());
+        }
+
+        if (const auto* ident = std::get_if<std::unique_ptr<ast::Identifier>>(&node.left))
+        {
+            if (*ident)
+            {
+                auto existing = table_.scopes().FindSymbolInScopeChain(current_scope_id_, (*ident)->name);
+                if (!existing)
+                {
+                    CreateSymbol((*ident)->name, protocol::SymbolKind::Variable, (*ident)->location, inferred_type);
+                }
+            }
+        }
+
         ProcessLValue(node.left, true);
 
         if (node.right)
         {
             VisitExpression(*node.right);
+
+            if (inferred_type)
+            {
+                if (const auto* ident = std::get_if<std::unique_ptr<ast::Identifier>>(&node.left))
+                {
+                    if (*ident)
+                    {
+                        MaybeUpdateSymbolType(table_, current_scope_id_, (*ident)->name, *inferred_type);
+                    }
+                }
+            }
         }
     }
 
@@ -1158,6 +1399,14 @@ namespace lsp::language::symbol
         }
     }
 
+    void Builder::VisitRdoExpression(ast::RdoExpression& node)
+    {
+        if (node.call && *node.call)
+        {
+            (*node.call)->Accept(*this);
+        }
+    }
+
     void Builder::VisitParenthesizedExpression(ast::ParenthesizedExpression& node)
     {
         for (auto& elem : node.elements)

lsp-server/src/language/symbol/types.cppm

@@ -508,6 +508,7 @@ export namespace lsp::language::symbol
         void VisitEchoExpression(ast::EchoExpression& node) override;
         void VisitRaiseExpression(ast::RaiseExpression& node) override;
         void VisitInheritedExpression(ast::InheritedExpression& node) override;
+        void VisitRdoExpression(ast::RdoExpression& node) override;
         void VisitParenthesizedExpression(ast::ParenthesizedExpression& node) override;
 
         void VisitExpressionStatement(ast::ExpressionStatement& node) override;
@@ -607,6 +608,9 @@ export namespace lsp::language::symbol
         std::optional<SymbolId> current_parent_symbol_id_;
         std::optional<SymbolId> current_function_id_;
 
+        std::vector<UnitImport> file_imports_;
+        std::unordered_set<SymbolId> file_imports_applied_;
+
         bool in_interface_section_;
         ast::AccessModifier current_access_modifier_ = ast::AccessModifier::kPublic;
     };

lsp-server/src/main.cc

@@ -0,0 +1,6 @@
+import lsp.cli.launcher;
+
+int main(int argc, char* argv[])
+{
+    return Run(argc, argv);
+}

lsp-server/src/manager/symbol.cppm

@@ -1,6 +1,5 @@
 module;
 
-
 export module lsp.manager.symbol;
 import tree_sitter;
 import spdlog;
@@ -136,23 +135,42 @@ namespace lsp::manager
             return decoded;
         }
 
-        bool IsTsfFile(const std::filesystem::path& path)
+        enum class TslFileKind
+        {
+            kLibraryTsf,
+            kScriptTsl,
+            kOther,
+        };
+
+        TslFileKind GetTslFileKind(const std::filesystem::path& path)
         {
             if (!path.has_extension())
-                return false;
+            {
+                return TslFileKind::kOther;
+            }
+
             std::string ext = path.extension().string();
             std::transform(
                 ext.begin(),
                 ext.end(),
                 ext.begin(),
                 [](unsigned char ch) { return static_cast<char>(std::tolower(ch)); });
-            return ext == ".tsf" || ext == ".tsl";
+
+            if (ext == ".tsf")
+            {
+                return TslFileKind::kLibraryTsf;
+            }
+            if (ext == ".tsl")
+            {
+                return TslFileKind::kScriptTsl;
+            }
+            return TslFileKind::kOther;
         }
 
         std::unique_ptr<language::symbol::SymbolTable> BuildSymbolTableFromFile(
             const std::filesystem::path& file_path)
         {
-            if (!IsTsfFile(file_path))
+            if (GetTslFileKind(file_path) == TslFileKind::kOther)
                 return nullptr;
 
             std::ifstream file(file_path, std::ios::binary);
@@ -230,6 +248,44 @@ namespace lsp::manager
             }
             return false;
         }
+
+        std::string DescribeTopLevelSymbols(const language::symbol::SymbolTable& table)
+        {
+            std::vector<std::string> parts;
+            for (const auto& wrapper : table.all_definitions())
+            {
+                const auto& symbol = wrapper.get();
+                switch (symbol.kind())
+                {
+                case protocol::SymbolKind::Function:
+                    parts.push_back("function:" + symbol.name());
+                    break;
+                case protocol::SymbolKind::Class:
+                    parts.push_back("class:" + symbol.name());
+                    break;
+                case protocol::SymbolKind::Module:
+                    parts.push_back("unit:" + symbol.name());
+                    break;
+                default:
+                    break;
+                }
+            }
+            if (parts.empty())
+            {
+                return "<none>";
+            }
+
+            std::string result;
+            for (std::size_t i = 0; i < parts.size(); ++i)
+            {
+                if (i > 0)
+                {
+                    result += ", ";
+                }
+                result += parts[i];
+            }
+            return result;
+        }
     }
 
     Symbol::Symbol(EventBus& event_bus) : event_bus_(event_bus)
@@ -269,9 +325,18 @@ namespace lsp::manager
             if (!entry.is_regular_file())
                 continue;
 
+            // System library only accepts `.tsf` as a library unit. `.tsl` is a script and should be ignored here.
+            if (GetTslFileKind(entry.path()) != TslFileKind::kLibraryTsf)
+            {
+                continue;
+            }
+
+            spdlog::trace("Indexing library file: {}", entry.path().string());
+
             auto table = BuildSymbolTableFromFile(entry.path());
             if (!table)
             {
+                spdlog::trace("Failed to build symbol table for: {}", entry.path().string());
                 ++failed;
                 continue;
             }
@@ -279,7 +344,10 @@ namespace lsp::manager
             auto stem = entry.path().stem().string();
             if (!HasMatchingTopLevelSymbol(*table, stem))
             {
-                spdlog::warn("Skipping system file {}: top-level symbol does not match file name", entry.path().string());
+                spdlog::warn("Skipping system file {}: top-level symbol does not match file name (stem='{}', top-level={})",
+                             entry.path().string(),
+                             stem,
+                             DescribeTopLevelSymbols(*table));
                 ++failed;
                 continue;
             }
@@ -331,7 +399,9 @@ namespace lsp::manager
         {
             if (!entry.is_regular_file())
                 continue;
-            if (!IsTsfFile(entry.path()))
+
+            auto kind = GetTslFileKind(entry.path());
+            if (kind == TslFileKind::kOther)
                 continue;
 
             auto table = BuildSymbolTableFromFile(entry.path());
@@ -342,9 +412,11 @@ namespace lsp::manager
             }
 
             auto stem = entry.path().stem().string();
-            if (!HasMatchingTopLevelSymbol(*table, stem))
+            // Only `.tsf` is a library unit that must match the file name.
+            // `.tsl` is a script and should not be forced to have a top-level symbol.
+            if (kind == TslFileKind::kLibraryTsf && !HasMatchingTopLevelSymbol(*table, stem))
             {
-                spdlog::warn("Skipping system file {}: top-level symbol does not match file name", entry.path().string());
+                spdlog::warn("Skipping workspace file {}: top-level symbol does not match file name", entry.path().string());
                 ++failed;
                 continue;
             }
@@ -497,6 +569,11 @@ namespace lsp::manager
 
             analysis.semantic_model = std::make_unique<language::semantic::SemanticModel>(*analysis.symbol_table);
 
+            {
+                language::semantic::Analyzer analyzer(*analysis.symbol_table, *analysis.semantic_model);
+                analyzer.Analyze(*analysis.ast);
+            }
+
             {
                 std::unique_lock<std::shared_mutex> lock(mutex_);
                 editing_symbols_[event.item.uri] = std::move(analysis);

lsp-server/src/provider/completion_item/resolve.cppm

@@ -1,6 +1,5 @@
 module;
 
-
 export module lsp.provider.completion_item.resolve;
 import spdlog;
 
@@ -9,6 +8,9 @@ import std;
 import lsp.protocol;
 import lsp.codec.facade;
 import lsp.provider.base.interface;
+import lsp.language.symbol;
+import lsp.language.ast;
+import lsp.utils.string;
 
 namespace transform = lsp::codec;
 
@@ -27,6 +29,214 @@ export namespace lsp::provider::completion_item
 
 namespace lsp::provider::completion_item
 {
+    namespace
+    {
+        std::optional<std::string> GetStringField(const protocol::LSPObject& obj, const std::string& key)
+        {
+            auto it = obj.find(key);
+            if (it == obj.end() || !it->second.Is<protocol::string>())
+            {
+                return std::nullopt;
+            }
+            const auto& s = it->second.Get<protocol::string>();
+            return s;
+        }
+
+        std::optional<bool> GetBoolField(const protocol::LSPObject& obj, const std::string& key)
+        {
+            auto it = obj.find(key);
+            if (it == obj.end() || !it->second.Is<protocol::boolean>())
+            {
+                return std::nullopt;
+            }
+            return it->second.Get<protocol::boolean>();
+        }
+
+        std::string GetModuleName(const language::symbol::SymbolTable& table)
+        {
+            for (const auto& wrapper : table.all_definitions())
+            {
+                const auto& symbol = wrapper.get();
+                if (symbol.kind() == protocol::SymbolKind::Module)
+                {
+                    return symbol.name();
+                }
+            }
+            return "";
+        }
+
+        std::optional<const language::symbol::Symbol*> FindClassSymbol(
+            const language::symbol::SymbolTable& table,
+            const std::string& class_name)
+        {
+            auto ids = table.FindSymbolsByName(class_name);
+            for (auto id : ids)
+            {
+                const auto* symbol = table.definition(id);
+                if (symbol && symbol->kind() == protocol::SymbolKind::Class)
+                {
+                    return symbol;
+                }
+            }
+            return std::nullopt;
+        }
+
+        std::optional<language::symbol::ScopeId> FindScopeOwnedBy(
+            const language::symbol::SymbolTable& table,
+            language::symbol::ScopeKind kind,
+            language::symbol::SymbolId owner_id)
+        {
+            for (const auto& [scope_id, scope] : table.scopes().all_scopes())
+            {
+                if (scope.kind == kind && scope.owner && *scope.owner == owner_id)
+                {
+                    return scope_id;
+                }
+            }
+            return std::nullopt;
+        }
+
+        std::vector<const language::symbol::Method*> CollectConstructors(
+            const language::symbol::SymbolTable& table,
+            language::symbol::SymbolId class_id)
+        {
+            std::vector<const language::symbol::Method*> result;
+            auto scope_id = FindScopeOwnedBy(table, language::symbol::ScopeKind::kClass, class_id);
+            if (!scope_id)
+            {
+                return result;
+            }
+
+            const auto* scope = table.scopes().scope(*scope_id);
+            if (!scope)
+            {
+                return result;
+            }
+
+            for (const auto& [_, ids] : scope->symbols)
+            {
+                for (auto id : ids)
+                {
+                    const auto* member = table.definition(id);
+                    if (!member || member->kind() != protocol::SymbolKind::Method)
+                    {
+                        continue;
+                    }
+
+                    const auto* method = member->As<language::symbol::Method>();
+                    if (!method || method->method_kind != language::ast::MethodKind::kConstructor)
+                    {
+                        continue;
+                    }
+
+                    result.push_back(method);
+                }
+            }
+            return result;
+        }
+
+        const language::symbol::Method* PickBestConstructor(const std::vector<const language::symbol::Method*>& ctors)
+        {
+            const language::symbol::Method* best = nullptr;
+            std::size_t best_required = std::numeric_limits<std::size_t>::max();
+            std::size_t best_total = std::numeric_limits<std::size_t>::max();
+
+            for (const auto* ctor : ctors)
+            {
+                if (!ctor)
+                {
+                    continue;
+                }
+
+                std::size_t required = 0;
+                for (const auto& p : ctor->parameters)
+                {
+                    if (!p.default_value.has_value())
+                    {
+                        ++required;
+                    }
+                }
+
+                if (required < best_required || (required == best_required && ctor->parameters.size() < best_total))
+                {
+                    best = ctor;
+                    best_required = required;
+                    best_total = ctor->parameters.size();
+                }
+            }
+
+            return best;
+        }
+
+        std::string BuildSignature(const std::vector<language::symbol::Parameter>& params, const std::optional<std::string>& return_type)
+        {
+            std::string detail = "(";
+            for (std::size_t i = 0; i < params.size(); ++i)
+            {
+                if (i > 0)
+                    detail += ", ";
+                detail += params[i].name;
+                if (params[i].type && !params[i].type->empty())
+                    detail += ": " + *params[i].type;
+            }
+            detail += ")";
+            if (return_type && !return_type->empty())
+                detail += ": " + *return_type;
+            return detail;
+        }
+
+        std::string BuildNewSnippet(const std::string& class_name, const language::symbol::Method* ctor)
+        {
+            std::string snippet = class_name;
+            snippet += "(";
+
+            if (ctor && !ctor->parameters.empty())
+            {
+                for (std::size_t i = 0; i < ctor->parameters.size(); ++i)
+                {
+                    if (i > 0)
+                    {
+                        snippet += ", ";
+                    }
+                    const auto& p = ctor->parameters[i];
+                    snippet += "${" + std::to_string(i + 1) + ":" + p.name + "}";
+                }
+            }
+
+            snippet += ")";
+            snippet += "$0";
+            return snippet;
+        }
+
+        std::string BuildCreateObjectSnippet(const std::string& class_name,
+                                             const language::symbol::Method* ctor,
+                                             bool has_open_quote,
+                                             char quote_char)
+        {
+            std::string snippet;
+            if (!has_open_quote)
+            {
+                snippet.push_back(quote_char);
+            }
+
+            snippet += class_name;
+            snippet.push_back(quote_char);
+
+            if (ctor && !ctor->parameters.empty())
+            {
+                for (std::size_t i = 0; i < ctor->parameters.size(); ++i)
+                {
+                    snippet += ", ";
+                    const auto& p = ctor->parameters[i];
+                    snippet += "${" + std::to_string(i + 1) + ":" + p.name + "}";
+                }
+            }
+
+            snippet += "$0";
+            return snippet;
+        }
+    }
+
     std::string Resolve::GetMethod() const
     {
         return "completionItem/resolve";
@@ -40,8 +250,6 @@ namespace lsp::provider::completion_item
     std::string Resolve::ProvideResponse(const protocol::RequestMessage& request,
                                          ExecutionContext& execution_context)
     {
-        static_cast<void>(execution_context);
-
         if (!request.params.has_value())
         {
             spdlog::warn("{}: Missing params in request", GetProviderName());
@@ -52,7 +260,109 @@ namespace lsp::provider::completion_item
 
         protocol::CompletionItem item = transform::FromLSPAny.template operator()<protocol::CompletionItem>(request.params.value());
 
-        // 暂未迁移 resolve 逻辑，保持原样返回
+        if (item.data && item.data->Is<protocol::LSPObject>())
+        {
+            const auto& obj = item.data->Get<protocol::LSPObject>();
+            auto ctx = GetStringField(obj, "ctx");
+            auto class_name = GetStringField(obj, "class");
+            auto unit_name = GetStringField(obj, "unit");
+            auto uri = GetStringField(obj, "uri");
+
+            if (ctx && class_name && !class_name->empty() && uri)
+            {
+                auto& hub = execution_context.GetManagerHub();
+
+                const language::symbol::SymbolTable* editing_table = hub.symbols().GetSymbolTable(*uri);
+                auto workspace_tables = hub.symbols().GetWorkspaceSymbolTables();
+                auto system_tables = hub.symbols().GetSystemSymbolTables();
+
+                auto try_find = [&](const language::symbol::SymbolTable& table) -> std::optional<const language::symbol::SymbolTable*> {
+                    if (unit_name && !unit_name->empty())
+                    {
+                        auto module = GetModuleName(table);
+                        if (module.empty() || !utils::IEquals(module, *unit_name))
+                        {
+                            return std::nullopt;
+                        }
+                    }
+                    if (FindClassSymbol(table, *class_name))
+                    {
+                        return &table;
+                    }
+                    return std::nullopt;
+                };
+
+                const language::symbol::SymbolTable* table_for_class = nullptr;
+                if (editing_table)
+                {
+                    if (auto t = try_find(*editing_table))
+                        table_for_class = *t;
+                }
+                if (!table_for_class)
+                {
+                    for (const auto* t : workspace_tables)
+                    {
+                        if (!t)
+                            continue;
+                        if (auto found = try_find(*t))
+                        {
+                            table_for_class = *found;
+                            break;
+                        }
+                    }
+                }
+                if (!table_for_class)
+                {
+                    for (const auto* t : system_tables)
+                    {
+                        if (!t)
+                            continue;
+                        if (auto found = try_find(*t))
+                        {
+                            table_for_class = *found;
+                            break;
+                        }
+                    }
+                }
+
+                const language::symbol::Method* best_ctor = nullptr;
+                if (table_for_class)
+                {
+                    if (auto cls_sym = FindClassSymbol(*table_for_class, *class_name))
+                    {
+                        auto ctors = CollectConstructors(*table_for_class, (*cls_sym)->id());
+                        best_ctor = PickBestConstructor(ctors);
+
+                        if (!item.labelDetails)
+                        {
+                            item.labelDetails = protocol::CompletionItemLabelDetails{};
+                        }
+                        item.labelDetails->detail = best_ctor ? BuildSignature(best_ctor->parameters, best_ctor->return_type) : "";
+                    }
+                }
+
+                if (*ctx == "new")
+                {
+                    item.insertText = BuildNewSnippet(*class_name, best_ctor);
+                    item.insertTextFormat = protocol::InsertTextFormat::Snippet;
+                    item.kind = protocol::CompletionItemKind::Constructor;
+                }
+                else if (*ctx == "createobject")
+                {
+                    bool has_open_quote = GetBoolField(obj, "has_open_quote").value_or(false);
+                    char quote_char = '"';
+                    if (auto quote = GetStringField(obj, "quote"); quote && !quote->empty())
+                    {
+                        quote_char = (*quote)[0];
+                    }
+
+                    item.insertText = BuildCreateObjectSnippet(*class_name, best_ctor, has_open_quote, quote_char);
+                    item.insertTextFormat = protocol::InsertTextFormat::Snippet;
+                    item.kind = protocol::CompletionItemKind::Constructor;
+                }
+            }
+        }
+
         protocol::ResponseMessage response;
         response.id = request.id;
         response.result = transform::ToLSPAny(item);

lsp-server/src/tree-sitter/tree_sitter/alloc.h

@@ -12,37 +12,37 @@ extern "C" {
 // Allow clients to override allocation functions
 #ifdef TREE_SITTER_REUSE_ALLOCATOR
 
-extern void* (*ts_current_malloc)(size_t size);
-extern void* (*ts_current_calloc)(size_t count, size_t size);
-extern void* (*ts_current_realloc)(void* ptr, size_t size);
-extern void (*ts_current_free)(void* ptr);
+extern void *(*ts_current_malloc)(size_t size);
+extern void *(*ts_current_calloc)(size_t count, size_t size);
+extern void *(*ts_current_realloc)(void *ptr, size_t size);
+extern void (*ts_current_free)(void *ptr);
 
 #ifndef ts_malloc
-#define ts_malloc ts_current_malloc
+#define ts_malloc  ts_current_malloc
 #endif
 #ifndef ts_calloc
-#define ts_calloc ts_current_calloc
+#define ts_calloc  ts_current_calloc
 #endif
 #ifndef ts_realloc
 #define ts_realloc ts_current_realloc
 #endif
 #ifndef ts_free
-#define ts_free ts_current_free
+#define ts_free    ts_current_free
 #endif
 
 #else
 
 #ifndef ts_malloc
-#define ts_malloc malloc
+#define ts_malloc  malloc
 #endif
 #ifndef ts_calloc
-#define ts_calloc calloc
+#define ts_calloc  calloc
 #endif
 #ifndef ts_realloc
 #define ts_realloc realloc
 #endif
 #ifndef ts_free
-#define ts_free free
+#define ts_free    free
 #endif
 
 #endif

lsp-server/src/tree-sitter/tree_sitter/array.h

@@ -21,25 +21,24 @@ extern "C" {
 #pragma GCC diagnostic ignored "-Wunused-variable"
 #endif
 
-#define Array(T)           \
-    struct                 \
-    {                      \
-        T* contents;       \
-        uint32_t size;     \
-        uint32_t capacity; \
-    }
+#define Array(T)       \
+  struct {             \
+    T *contents;       \
+    uint32_t size;     \
+    uint32_t capacity; \
+  }
 
 /// Initialize an array.
 #define array_init(self) \
-    ((self)->size = 0, (self)->capacity = 0, (self)->contents = NULL)
+  ((self)->size = 0, (self)->capacity = 0, (self)->contents = NULL)
 
 /// Create an empty array.
 #define array_new() \
-    { NULL, 0, 0 }
+  { NULL, 0, 0 }
 
 /// Get a pointer to the element at a given `index` in the array.
 #define array_get(self, _index) \
-    (assert((uint32_t)(_index) < (self)->size), &(self)->contents[_index])
+  (assert((uint32_t)(_index) < (self)->size), &(self)->contents[_index])
 
 /// Get a pointer to the first element in the array.
 #define array_front(self) array_get(self, 0)
@@ -54,64 +53,66 @@ extern "C" {
 /// Reserve `new_capacity` elements of space in the array. If `new_capacity` is
 /// less than the array's current capacity, this function has no effect.
 #define array_reserve(self, new_capacity) \
-    _array__reserve((Array*)(self), array_elem_size(self), new_capacity)
+  _array__reserve((Array *)(self), array_elem_size(self), new_capacity)
 
 /// Free any memory allocated for this array. Note that this does not free any
 /// memory allocated for the array's contents.
-#define array_delete(self) _array__delete((Array*)(self))
+#define array_delete(self) _array__delete((Array *)(self))
 
 /// Push a new `element` onto the end of the array.
 #define array_push(self, element)                            \
-    (_array__grow((Array*)(self), 1, array_elem_size(self)), \
-     (self)->contents[(self)->size++] = (element))
+  (_array__grow((Array *)(self), 1, array_elem_size(self)), \
+   (self)->contents[(self)->size++] = (element))
 
 /// Increase the array's size by `count` elements.
 /// New elements are zero-initialized.
-#define array_grow_by(self, count)                                                   \
-    do                                                                               \
-    {                                                                                \
-        if ((count) == 0)                                                            \
-            break;                                                                   \
-        _array__grow((Array*)(self), count, array_elem_size(self));                  \
-        memset((self)->contents + (self)->size, 0, (count) * array_elem_size(self)); \
-        (self)->size += (count);                                                     \
-    } while (0)
+#define array_grow_by(self, count) \
+  do { \
+    if ((count) == 0) break; \
+    _array__grow((Array *)(self), count, array_elem_size(self)); \
+    memset((self)->contents + (self)->size, 0, (count) * array_elem_size(self)); \
+    (self)->size += (count); \
+  } while (0)
 
 /// Append all elements from one array to the end of another.
-#define array_push_all(self, other) \
-    array_extend((self), (other)->size, (other)->contents)
+#define array_push_all(self, other)                                       \
+  array_extend((self), (other)->size, (other)->contents)
 
 /// Append `count` elements to the end of the array, reading their values from the
 /// `contents` pointer.
-#define array_extend(self, count, contents) \
-    _array__splice(                         \
-        (Array*)(self), array_elem_size(self), (self)->size, 0, count, contents)
+#define array_extend(self, count, contents)                    \
+  _array__splice(                                               \
+    (Array *)(self), array_elem_size(self), (self)->size, \
+    0, count,  contents                                        \
+  )
 
 /// Remove `old_count` elements from the array starting at the given `index`. At
 /// the same index, insert `new_count` new elements, reading their values from the
 /// `new_contents` pointer.
-#define array_splice(self, _index, old_count, new_count, new_contents) \
-    _array__splice(                                                    \
-        (Array*)(self), array_elem_size(self), _index, old_count, new_count, new_contents)
+#define array_splice(self, _index, old_count, new_count, new_contents)  \
+  _array__splice(                                                       \
+    (Array *)(self), array_elem_size(self), _index,                \
+    old_count, new_count, new_contents                                 \
+  )
 
 /// Insert one `element` into the array at the given `index`.
 #define array_insert(self, _index, element) \
-    _array__splice((Array*)(self), array_elem_size(self), _index, 0, 1, &(element))
+  _array__splice((Array *)(self), array_elem_size(self), _index, 0, 1, &(element))
 
 /// Remove one element from the array at the given `index`.
 #define array_erase(self, _index) \
-    _array__erase((Array*)(self), array_elem_size(self), _index)
+  _array__erase((Array *)(self), array_elem_size(self), _index)
 
 /// Pop the last element off the array, returning the element by value.
 #define array_pop(self) ((self)->contents[--(self)->size])
 
 /// Assign the contents of one array to another, reallocating if necessary.
 #define array_assign(self, other) \
-    _array__assign((Array*)(self), (const Array*)(other), array_elem_size(self))
+  _array__assign((Array *)(self), (const Array *)(other), array_elem_size(self))
 
 /// Swap one array with another
 #define array_swap(self, other) \
-    _array__swap((Array*)(self), (Array*)(other))
+  _array__swap((Array *)(self), (Array *)(other))
 
 /// Get the size of the array contents
 #define array_elem_size(self) (sizeof *(self)->contents)
@@ -125,176 +126,153 @@ extern "C" {
 /// `needle` should be inserted in order to preserve the sorting, and `exists`
 /// is set to false.
 #define array_search_sorted_with(self, compare, needle, _index, _exists) \
-    _array__search_sorted(self, 0, compare, , needle, _index, _exists)
+  _array__search_sorted(self, 0, compare, , needle, _index, _exists)
 
 /// Search a sorted array for a given `needle` value, using integer comparisons
 /// of a given struct field (specified with a leading dot) to determine the order.
 ///
 /// See also `array_search_sorted_with`.
 #define array_search_sorted_by(self, field, needle, _index, _exists) \
-    _array__search_sorted(self, 0, _compare_int, field, needle, _index, _exists)
+  _array__search_sorted(self, 0, _compare_int, field, needle, _index, _exists)
 
 /// Insert a given `value` into a sorted array, using the given `compare`
 /// callback to determine the order.
-#define array_insert_sorted_with(self, compare, value)                        \
-    do                                                                        \
-    {                                                                         \
-        unsigned _index, _exists;                                             \
-        array_search_sorted_with(self, compare, &(value), &_index, &_exists); \
-        if (!_exists)                                                         \
-            array_insert(self, _index, value);                                \
-    } while (0)
+#define array_insert_sorted_with(self, compare, value) \
+  do { \
+    unsigned _index, _exists; \
+    array_search_sorted_with(self, compare, &(value), &_index, &_exists); \
+    if (!_exists) array_insert(self, _index, value); \
+  } while (0)
 
 /// Insert a given `value` into a sorted array, using integer comparisons of
 /// a given struct field (specified with a leading dot) to determine the order.
 ///
 /// See also `array_search_sorted_by`.
-#define array_insert_sorted_by(self, field, value)                            \
-    do                                                                        \
-    {                                                                         \
-        unsigned _index, _exists;                                             \
-        array_search_sorted_by(self, field, (value)field, &_index, &_exists); \
-        if (!_exists)                                                         \
-            array_insert(self, _index, value);                                \
-    } while (0)
+#define array_insert_sorted_by(self, field, value) \
+  do { \
+    unsigned _index, _exists; \
+    array_search_sorted_by(self, field, (value) field, &_index, &_exists); \
+    if (!_exists) array_insert(self, _index, value); \
+  } while (0)
 
 // Private
 
 typedef Array(void) Array;
 
 /// This is not what you're looking for, see `array_delete`.
-static inline void _array__delete(Array* self)
-{
-    if (self->contents)
-    {
-        ts_free(self->contents);
-        self->contents = NULL;
-        self->size = 0;
-        self->capacity = 0;
-    }
+static inline void _array__delete(Array *self) {
+  if (self->contents) {
+    ts_free(self->contents);
+    self->contents = NULL;
+    self->size = 0;
+    self->capacity = 0;
+  }
 }
 
 /// This is not what you're looking for, see `array_erase`.
-static inline void _array__erase(Array* self, size_t element_size, uint32_t index)
-{
-    assert(index < self->size);
-    char* contents = (char*)self->contents;
-    memmove(contents + index * element_size, contents + (index + 1) * element_size, (self->size - index - 1) * element_size);
-    self->size--;
+static inline void _array__erase(Array *self, size_t element_size,
+                                uint32_t index) {
+  assert(index < self->size);
+  char *contents = (char *)self->contents;
+  memmove(contents + index * element_size, contents + (index + 1) * element_size,
+          (self->size - index - 1) * element_size);
+  self->size--;
 }
 
 /// This is not what you're looking for, see `array_reserve`.
-static inline void _array__reserve(Array* self, size_t element_size, uint32_t new_capacity)
-{
-    if (new_capacity > self->capacity)
-    {
-        if (self->contents)
-        {
-            self->contents = ts_realloc(self->contents, new_capacity * element_size);
-        }
-        else
-        {
-            self->contents = ts_malloc(new_capacity * element_size);
-        }
-        self->capacity = new_capacity;
+static inline void _array__reserve(Array *self, size_t element_size, uint32_t new_capacity) {
+  if (new_capacity > self->capacity) {
+    if (self->contents) {
+      self->contents = ts_realloc(self->contents, new_capacity * element_size);
+    } else {
+      self->contents = ts_malloc(new_capacity * element_size);
     }
+    self->capacity = new_capacity;
+  }
 }
 
 /// This is not what you're looking for, see `array_assign`.
-static inline void _array__assign(Array* self, const Array* other, size_t element_size)
-{
-    _array__reserve(self, element_size, other->size);
-    self->size = other->size;
-    memcpy(self->contents, other->contents, self->size * element_size);
+static inline void _array__assign(Array *self, const Array *other, size_t element_size) {
+  _array__reserve(self, element_size, other->size);
+  self->size = other->size;
+  memcpy(self->contents, other->contents, self->size * element_size);
 }
 
 /// This is not what you're looking for, see `array_swap`.
-static inline void _array__swap(Array* self, Array* other)
-{
-    Array swap = *other;
-    *other = *self;
-    *self = swap;
+static inline void _array__swap(Array *self, Array *other) {
+  Array swap = *other;
+  *other = *self;
+  *self = swap;
 }
 
 /// This is not what you're looking for, see `array_push` or `array_grow_by`.
-static inline void _array__grow(Array* self, uint32_t count, size_t element_size)
-{
-    uint32_t new_size = self->size + count;
-    if (new_size > self->capacity)
-    {
-        uint32_t new_capacity = self->capacity * 2;
-        if (new_capacity < 8)
-            new_capacity = 8;
-        if (new_capacity < new_size)
-            new_capacity = new_size;
-        _array__reserve(self, element_size, new_capacity);
-    }
+static inline void _array__grow(Array *self, uint32_t count, size_t element_size) {
+  uint32_t new_size = self->size + count;
+  if (new_size > self->capacity) {
+    uint32_t new_capacity = self->capacity * 2;
+    if (new_capacity < 8) new_capacity = 8;
+    if (new_capacity < new_size) new_capacity = new_size;
+    _array__reserve(self, element_size, new_capacity);
+  }
 }
 
 /// This is not what you're looking for, see `array_splice`.
-static inline void _array__splice(Array* self, size_t element_size, uint32_t index, uint32_t old_count, uint32_t new_count, const void* elements)
-{
-    uint32_t new_size = self->size + new_count - old_count;
-    uint32_t old_end = index + old_count;
-    uint32_t new_end = index + new_count;
-    assert(old_end <= self->size);
+static inline void _array__splice(Array *self, size_t element_size,
+                                 uint32_t index, uint32_t old_count,
+                                 uint32_t new_count, const void *elements) {
+  uint32_t new_size = self->size + new_count - old_count;
+  uint32_t old_end = index + old_count;
+  uint32_t new_end = index + new_count;
+  assert(old_end <= self->size);
 
-    _array__reserve(self, element_size, new_size);
+  _array__reserve(self, element_size, new_size);
 
-    char* contents = (char*)self->contents;
-    if (self->size > old_end)
-    {
-        memmove(
-            contents + new_end * element_size,
-            contents + old_end * element_size,
-            (self->size - old_end) * element_size);
+  char *contents = (char *)self->contents;
+  if (self->size > old_end) {
+    memmove(
+      contents + new_end * element_size,
+      contents + old_end * element_size,
+      (self->size - old_end) * element_size
+    );
+  }
+  if (new_count > 0) {
+    if (elements) {
+      memcpy(
+        (contents + index * element_size),
+        elements,
+        new_count * element_size
+      );
+    } else {
+      memset(
+        (contents + index * element_size),
+        0,
+        new_count * element_size
+      );
     }
-    if (new_count > 0)
-    {
-        if (elements)
-        {
-            memcpy(
-                (contents + index * element_size),
-                elements,
-                new_count * element_size);
-        }
-        else
-        {
-            memset(
-                (contents + index * element_size),
-                0,
-                new_count * element_size);
-        }
-    }
-    self->size += new_count - old_count;
+  }
+  self->size += new_count - old_count;
 }
 
 /// A binary search routine, based on Rust's `std::slice::binary_search_by`.
 /// This is not what you're looking for, see `array_search_sorted_with` or `array_search_sorted_by`.
 #define _array__search_sorted(self, start, compare, suffix, needle, _index, _exists) \
-    do                                                                               \
-    {                                                                                \
-        *(_index) = start;                                                           \
-        *(_exists) = false;                                                          \
-        uint32_t size = (self)->size - *(_index);                                    \
-        if (size == 0)                                                               \
-            break;                                                                   \
-        int comparison;                                                              \
-        while (size > 1)                                                             \
-        {                                                                            \
-            uint32_t half_size = size / 2;                                           \
-            uint32_t mid_index = *(_index) + half_size;                              \
-            comparison = compare(&((self)->contents[mid_index] suffix), (needle));   \
-            if (comparison <= 0)                                                     \
-                *(_index) = mid_index;                                               \
-            size -= half_size;                                                       \
-        }                                                                            \
-        comparison = compare(&((self)->contents[*(_index)] suffix), (needle));       \
-        if (comparison == 0)                                                         \
-            *(_exists) = true;                                                       \
-        else if (comparison < 0)                                                     \
-            *(_index) += 1;                                                          \
-    } while (0)
+  do { \
+    *(_index) = start; \
+    *(_exists) = false; \
+    uint32_t size = (self)->size - *(_index); \
+    if (size == 0) break; \
+    int comparison; \
+    while (size > 1) { \
+      uint32_t half_size = size / 2; \
+      uint32_t mid_index = *(_index) + half_size; \
+      comparison = compare(&((self)->contents[mid_index] suffix), (needle)); \
+      if (comparison <= 0) *(_index) = mid_index; \
+      size -= half_size; \
+    } \
+    comparison = compare(&((self)->contents[*(_index)] suffix), (needle)); \
+    if (comparison == 0) *(_exists) = true; \
+    else if (comparison < 0) *(_index) += 1; \
+  } while (0)
 
 /// Helper macro for the `_sorted_by` routines below. This takes the left (existing)
 /// parameter by reference in order to work with the generic sorting function above.
@@ -310,4 +288,4 @@ static inline void _array__splice(Array* self, size_t element_size, uint32_t ind
 }
 #endif
 
-#endif // TREE_SITTER_ARRAY_H_
+#endif  // TREE_SITTER_ARRAY_H_

lsp-server/src/tree-sitter/tree_sitter/parser.h

@@ -9,7 +9,7 @@ extern "C" {
 #include <stdint.h>
 #include <stdlib.h>
 
-#define ts_builtin_sym_error ((TSSymbol) - 1)
+#define ts_builtin_sym_error ((TSSymbol)-1)
 #define ts_builtin_sym_end 0
 #define TREE_SITTER_SERIALIZATION_BUFFER_SIZE 1024
 
@@ -18,176 +18,155 @@ typedef uint16_t TSStateId;
 typedef uint16_t TSSymbol;
 typedef uint16_t TSFieldId;
 typedef struct TSLanguage TSLanguage;
-typedef struct TSLanguageMetadata
-{
-    uint8_t major_version;
-    uint8_t minor_version;
-    uint8_t patch_version;
+typedef struct TSLanguageMetadata {
+  uint8_t major_version;
+  uint8_t minor_version;
+  uint8_t patch_version;
 } TSLanguageMetadata;
 #endif
 
-typedef struct
-{
-    TSFieldId field_id;
-    uint8_t child_index;
-    bool inherited;
+typedef struct {
+  TSFieldId field_id;
+  uint8_t child_index;
+  bool inherited;
 } TSFieldMapEntry;
 
 // Used to index the field and supertype maps.
-typedef struct
-{
-    uint16_t index;
-    uint16_t length;
+typedef struct {
+  uint16_t index;
+  uint16_t length;
 } TSMapSlice;
 
-typedef struct
-{
-    bool visible;
-    bool named;
-    bool supertype;
+typedef struct {
+  bool visible;
+  bool named;
+  bool supertype;
 } TSSymbolMetadata;
 
 typedef struct TSLexer TSLexer;
 
-struct TSLexer
-{
-    int32_t lookahead;
-    TSSymbol result_symbol;
-    void (*advance)(TSLexer*, bool);
-    void (*mark_end)(TSLexer*);
-    uint32_t (*get_column)(TSLexer*);
-    bool (*is_at_included_range_start)(const TSLexer*);
-    bool (*eof)(const TSLexer*);
-    void (*log)(const TSLexer*, const char*, ...);
+struct TSLexer {
+  int32_t lookahead;
+  TSSymbol result_symbol;
+  void (*advance)(TSLexer *, bool);
+  void (*mark_end)(TSLexer *);
+  uint32_t (*get_column)(TSLexer *);
+  bool (*is_at_included_range_start)(const TSLexer *);
+  bool (*eof)(const TSLexer *);
+  void (*log)(const TSLexer *, const char *, ...);
 };
 
-typedef enum
-{
-    TSParseActionTypeShift,
-    TSParseActionTypeReduce,
-    TSParseActionTypeAccept,
-    TSParseActionTypeRecover,
+typedef enum {
+  TSParseActionTypeShift,
+  TSParseActionTypeReduce,
+  TSParseActionTypeAccept,
+  TSParseActionTypeRecover,
 } TSParseActionType;
 
-typedef union
-{
-    struct
-    {
-        uint8_t type;
-        TSStateId state;
-        bool extra;
-        bool repetition;
-    } shift;
-    struct
-    {
-        uint8_t type;
-        uint8_t child_count;
-        TSSymbol symbol;
-        int16_t dynamic_precedence;
-        uint16_t production_id;
-    } reduce;
+typedef union {
+  struct {
     uint8_t type;
+    TSStateId state;
+    bool extra;
+    bool repetition;
+  } shift;
+  struct {
+    uint8_t type;
+    uint8_t child_count;
+    TSSymbol symbol;
+    int16_t dynamic_precedence;
+    uint16_t production_id;
+  } reduce;
+  uint8_t type;
 } TSParseAction;
 
-typedef struct
-{
-    uint16_t lex_state;
-    uint16_t external_lex_state;
+typedef struct {
+  uint16_t lex_state;
+  uint16_t external_lex_state;
 } TSLexMode;
 
-typedef struct
-{
-    uint16_t lex_state;
-    uint16_t external_lex_state;
-    uint16_t reserved_word_set_id;
+typedef struct {
+  uint16_t lex_state;
+  uint16_t external_lex_state;
+  uint16_t reserved_word_set_id;
 } TSLexerMode;
 
-typedef union
-{
-    TSParseAction action;
-    struct
-    {
-        uint8_t count;
-        bool reusable;
-    } entry;
+typedef union {
+  TSParseAction action;
+  struct {
+    uint8_t count;
+    bool reusable;
+  } entry;
 } TSParseActionEntry;
 
-typedef struct
-{
-    int32_t start;
-    int32_t end;
+typedef struct {
+  int32_t start;
+  int32_t end;
 } TSCharacterRange;
 
-struct TSLanguage
-{
-    uint32_t abi_version;
-    uint32_t symbol_count;
-    uint32_t alias_count;
-    uint32_t token_count;
-    uint32_t external_token_count;
-    uint32_t state_count;
-    uint32_t large_state_count;
-    uint32_t production_id_count;
-    uint32_t field_count;
-    uint16_t max_alias_sequence_length;
-    const uint16_t* parse_table;
-    const uint16_t* small_parse_table;
-    const uint32_t* small_parse_table_map;
-    const TSParseActionEntry* parse_actions;
-    const char* const* symbol_names;
-    const char* const* field_names;
-    const TSMapSlice* field_map_slices;
-    const TSFieldMapEntry* field_map_entries;
-    const TSSymbolMetadata* symbol_metadata;
-    const TSSymbol* public_symbol_map;
-    const uint16_t* alias_map;
-    const TSSymbol* alias_sequences;
-    const TSLexerMode* lex_modes;
-    bool (*lex_fn)(TSLexer*, TSStateId);
-    bool (*keyword_lex_fn)(TSLexer*, TSStateId);
-    TSSymbol keyword_capture_token;
-    struct
-    {
-        const bool* states;
-        const TSSymbol* symbol_map;
-        void* (*create)(void);
-        void (*destroy)(void*);
-        bool (*scan)(void*, TSLexer*, const bool* symbol_whitelist);
-        unsigned (*serialize)(void*, char*);
-        void (*deserialize)(void*, const char*, unsigned);
-    } external_scanner;
-    const TSStateId* primary_state_ids;
-    const char* name;
-    const TSSymbol* reserved_words;
-    uint16_t max_reserved_word_set_size;
-    uint32_t supertype_count;
-    const TSSymbol* supertype_symbols;
-    const TSMapSlice* supertype_map_slices;
-    const TSSymbol* supertype_map_entries;
-    TSLanguageMetadata metadata;
+struct TSLanguage {
+  uint32_t abi_version;
+  uint32_t symbol_count;
+  uint32_t alias_count;
+  uint32_t token_count;
+  uint32_t external_token_count;
+  uint32_t state_count;
+  uint32_t large_state_count;
+  uint32_t production_id_count;
+  uint32_t field_count;
+  uint16_t max_alias_sequence_length;
+  const uint16_t *parse_table;
+  const uint16_t *small_parse_table;
+  const uint32_t *small_parse_table_map;
+  const TSParseActionEntry *parse_actions;
+  const char * const *symbol_names;
+  const char * const *field_names;
+  const TSMapSlice *field_map_slices;
+  const TSFieldMapEntry *field_map_entries;
+  const TSSymbolMetadata *symbol_metadata;
+  const TSSymbol *public_symbol_map;
+  const uint16_t *alias_map;
+  const TSSymbol *alias_sequences;
+  const TSLexerMode *lex_modes;
+  bool (*lex_fn)(TSLexer *, TSStateId);
+  bool (*keyword_lex_fn)(TSLexer *, TSStateId);
+  TSSymbol keyword_capture_token;
+  struct {
+    const bool *states;
+    const TSSymbol *symbol_map;
+    void *(*create)(void);
+    void (*destroy)(void *);
+    bool (*scan)(void *, TSLexer *, const bool *symbol_whitelist);
+    unsigned (*serialize)(void *, char *);
+    void (*deserialize)(void *, const char *, unsigned);
+  } external_scanner;
+  const TSStateId *primary_state_ids;
+  const char *name;
+  const TSSymbol *reserved_words;
+  uint16_t max_reserved_word_set_size;
+  uint32_t supertype_count;
+  const TSSymbol *supertype_symbols;
+  const TSMapSlice *supertype_map_slices;
+  const TSSymbol *supertype_map_entries;
+  TSLanguageMetadata metadata;
 };
 
-static inline bool set_contains(const TSCharacterRange* ranges, uint32_t len, int32_t lookahead)
-{
-    uint32_t index = 0;
-    uint32_t size = len - index;
-    while (size > 1)
-    {
-        uint32_t half_size = size / 2;
-        uint32_t mid_index = index + half_size;
-        const TSCharacterRange* range = &ranges[mid_index];
-        if (lookahead >= range->start && lookahead <= range->end)
-        {
-            return true;
-        }
-        else if (lookahead > range->end)
-        {
-            index = mid_index;
-        }
-        size -= half_size;
+static inline bool set_contains(const TSCharacterRange *ranges, uint32_t len, int32_t lookahead) {
+  uint32_t index = 0;
+  uint32_t size = len - index;
+  while (size > 1) {
+    uint32_t half_size = size / 2;
+    uint32_t mid_index = index + half_size;
+    const TSCharacterRange *range = &ranges[mid_index];
+    if (lookahead >= range->start && lookahead <= range->end) {
+      return true;
+    } else if (lookahead > range->end) {
+      index = mid_index;
     }
-    const TSCharacterRange* range = &ranges[index];
-    return (lookahead >= range->start && lookahead <= range->end);
+    size -= half_size;
+  }
+  const TSCharacterRange *range = &ranges[index];
+  return (lookahead >= range->start && lookahead <= range->end);
 }
 
 /*
@@ -200,49 +179,47 @@ static inline bool set_contains(const TSCharacterRange* ranges, uint32_t len, in
 #define UNUSED __attribute__((unused))
 #endif
 
-#define START_LEXER()            \
-    bool result = false;         \
-    bool skip = false;           \
-    UNUSED                       \
-    bool eof = false;            \
-    int32_t lookahead;           \
-    goto start;                  \
-    next_state:                  \
-    lexer->advance(lexer, skip); \
-    start:                       \
-    skip = false;                \
-    lookahead = lexer->lookahead;
+#define START_LEXER()           \
+  bool result = false;          \
+  bool skip = false;            \
+  UNUSED                        \
+  bool eof = false;             \
+  int32_t lookahead;            \
+  goto start;                   \
+  next_state:                   \
+  lexer->advance(lexer, skip);  \
+  start:                        \
+  skip = false;                 \
+  lookahead = lexer->lookahead;
 
 #define ADVANCE(state_value) \
-    {                        \
-        state = state_value; \
-        goto next_state;     \
-    }
+  {                          \
+    state = state_value;     \
+    goto next_state;         \
+  }
 
-#define ADVANCE_MAP(...)                                               \
-    {                                                                  \
-        static const uint16_t map[] = { __VA_ARGS__ };                 \
-        for (uint32_t i = 0; i < sizeof(map) / sizeof(map[0]); i += 2) \
-        {                                                              \
-            if (map[i] == lookahead)                                   \
-            {                                                          \
-                state = map[i + 1];                                    \
-                goto next_state;                                       \
-            }                                                          \
-        }                                                              \
-    }
+#define ADVANCE_MAP(...)                                              \
+  {                                                                   \
+    static const uint16_t map[] = { __VA_ARGS__ };                    \
+    for (uint32_t i = 0; i < sizeof(map) / sizeof(map[0]); i += 2) {  \
+      if (map[i] == lookahead) {                                      \
+        state = map[i + 1];                                           \
+        goto next_state;                                              \
+      }                                                               \
+    }                                                                 \
+  }
 
-#define SKIP(state_value)    \
-    {                        \
-        skip = true;         \
-        state = state_value; \
-        goto next_state;     \
-    }
+#define SKIP(state_value) \
+  {                       \
+    skip = true;          \
+    state = state_value;  \
+    goto next_state;      \
+  }
 
-#define ACCEPT_TOKEN(symbol_value)       \
-    result = true;                       \
-    lexer->result_symbol = symbol_value; \
-    lexer->mark_end(lexer);
+#define ACCEPT_TOKEN(symbol_value)     \
+  result = true;                       \
+  lexer->result_symbol = symbol_value; \
+  lexer->mark_end(lexer);
 
 #define END_STATE() return result;
 
@@ -256,66 +233,54 @@ static inline bool set_contains(const TSCharacterRange* ranges, uint32_t len, in
 
 #define ACTIONS(id) id
 
-#define SHIFT(state_value)                      \
-    {                                           \
-        {                                       \
-            .shift = {                          \
-                .type = TSParseActionTypeShift, \
-                .state = (state_value)          \
-            }                                   \
-        }                                       \
-    }
+#define SHIFT(state_value)            \
+  {{                                  \
+    .shift = {                        \
+      .type = TSParseActionTypeShift, \
+      .state = (state_value)          \
+    }                                 \
+  }}
 
-#define SHIFT_REPEAT(state_value)               \
-    {                                           \
-        {                                       \
-            .shift = {                          \
-                .type = TSParseActionTypeShift, \
-                .state = (state_value),         \
-                .repetition = true              \
-            }                                   \
-        }                                       \
-    }
+#define SHIFT_REPEAT(state_value)     \
+  {{                                  \
+    .shift = {                        \
+      .type = TSParseActionTypeShift, \
+      .state = (state_value),         \
+      .repetition = true              \
+    }                                 \
+  }}
 
-#define SHIFT_EXTRA()                           \
-    {                                           \
-        {                                       \
-            .shift = {                          \
-                .type = TSParseActionTypeShift, \
-                .extra = true                   \
-            }                                   \
-        }                                       \
-    }
+#define SHIFT_EXTRA()                 \
+  {{                                  \
+    .shift = {                        \
+      .type = TSParseActionTypeShift, \
+      .extra = true                   \
+    }                                 \
+  }}
 
 #define REDUCE(symbol_name, children, precedence, prod_id) \
-    {                                                      \
-        {                                                  \
-            .reduce = {                                    \
-                .type = TSParseActionTypeReduce,           \
-                .symbol = symbol_name,                     \
-                .child_count = children,                   \
-                .dynamic_precedence = precedence,          \
-                .production_id = prod_id                   \
-            },                                             \
-        }                                                  \
-    }
+  {{                                                       \
+    .reduce = {                                            \
+      .type = TSParseActionTypeReduce,                     \
+      .symbol = symbol_name,                               \
+      .child_count = children,                             \
+      .dynamic_precedence = precedence,                    \
+      .production_id = prod_id                             \
+    },                                                     \
+  }}
 
-#define RECOVER()                            \
-    {                                        \
-        {                                    \
-            .type = TSParseActionTypeRecover \
-        }                                    \
-    }
+#define RECOVER()                    \
+  {{                                 \
+    .type = TSParseActionTypeRecover \
+  }}
 
-#define ACCEPT_INPUT()                      \
-    {                                       \
-        {                                   \
-            .type = TSParseActionTypeAccept \
-        }                                   \
-    }
+#define ACCEPT_INPUT()              \
+  {{                                \
+    .type = TSParseActionTypeAccept \
+  }}
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif // TREE_SITTER_PARSER_H_
+#endif  // TREE_SITTER_PARSER_H_

lsp-server/src/utils/args_parser.cppm

@@ -52,7 +52,9 @@ namespace lsp::utils
     const ServerConfig& ArgsParser::Parse(int argc, char* argv[])
     {
         config_ = ServerConfig{};
-        bool use_stdio = false;
+        // Default to stderr so LSP stdio (stdout) stays clean.
+        config_.use_stderr = true;
+
         for (int i = 1; i < argc; ++i)
         {
             std::string arg = argv[i];
@@ -75,10 +77,14 @@ namespace lsp::utils
                 config_.log_level = spdlog::level::err;
             else if (arg == "--log=off")
                 config_.log_level = spdlog::level::off;
+            else if (arg == "--log-stderr")
+                config_.use_stderr = true;
+            else if (arg == "--log-stdout")
+                config_.use_stderr = false;
             else if (arg.find("--log-file=") == 0)
                 config_.log_file = arg.substr(std::strlen("--log-file="));
             else if (arg == "--use-stdio")
-                use_stdio = true;
+                config_.use_stderr = true;
             else if (arg.find("--threads=") == 0)
             {
                 auto value = arg.substr(std::strlen("--threads="));
@@ -90,9 +96,6 @@ namespace lsp::utils
             }
         }
 
-        if (!use_stdio)
-            config_.use_stderr = true;
-
         return config_;
     }
 
@@ -113,7 +116,7 @@ namespace lsp::utils
         }
         else
         {
-            auto console_logger = spdlog::stdout_logger_mt("console_logger");
+            auto console_logger = config.use_stderr ? spdlog::stderr_logger_mt("console_logger") : spdlog::stdout_logger_mt("console_logger");
             console_logger->set_level(config.log_level);
             spdlog::set_default_logger(console_logger);
         }
@@ -127,8 +130,10 @@ namespace lsp::utils
                   << "Options:\\n"
                   << "  --help                Show this help message\\n"
                   << "  --log=<level>         Set log level (trace, debug, info, warn, error, off)\\n"
+                  << "  --log-stderr          Output logs to stderr (default)\\n"
+                  << "  --log-stdout          Output logs to stdout\\n"
                   << "  --log-file=<path>     Output logs to specified file\\n"
-                  << "  --use-stdio           Use stdin/stdout for I/O (default: stderr)\\n"
+                  << "  --use-stdio           Alias for --log-stderr (keep stdout clean for LSP)\\n"
                   << "  --threads=<count>     Number of worker threads\\n"
                   << "  --interpreter=<path>  Custom interpreter path\\n";
     }

lsp-server/src/utils/string.cpp

@@ -1,130 +0,0 @@
-module;
-
-import std;
-
-module lsp.utils.string;
-
-namespace lsp::utils
-{
-    std::string Trim(const std::string& str)
-    {
-        std::size_t first = str.find_first_not_of(" \t\n\r");
-        if (first == std::string::npos)
-            return "";
-        std::size_t last = str.find_last_not_of(" \t\n\r");
-        return str.substr(first, last - first + 1);
-    }
-
-    std::string ToLower(const std::string& str)
-    {
-        std::string result = str;
-        std::transform(result.begin(), result.end(), result.begin(), [](unsigned char c) { return std::tolower(c); });
-        return result;
-    }
-
-    std::string ToUpper(const std::string& str)
-    {
-        std::string result = str;
-        std::transform(result.begin(), result.end(), result.begin(), [](unsigned char c) { return std::toupper(c); });
-        return result;
-    }
-
-    bool StartsWith(const std::string& str, const std::string& prefix)
-    {
-        if (prefix.size() > str.size())
-            return false;
-        return str.compare(0, prefix.size(), prefix) == 0;
-    }
-
-    bool EndsWith(const std::string& str, const std::string& suffix)
-    {
-        if (suffix.size() > str.size())
-            return false;
-        return str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;
-    }
-
-    // ==================== 大小写不敏感比较 ====================
-    bool IEquals(const std::string& a, const std::string& b)
-    {
-        if (a.size() != b.size())
-            return false;
-
-        return std::equal(a.begin(), a.end(), b.begin(), [](unsigned char ca, unsigned char cb) {
-            return std::tolower(ca) == std::tolower(cb);
-        });
-    }
-
-    bool IStartsWith(const std::string& str, const std::string& prefix)
-    {
-        if (prefix.size() > str.size())
-            return false;
-
-        for (std::size_t i = 0; i < prefix.size(); ++i)
-        {
-            if (std::tolower(static_cast<unsigned char>(str[i])) !=
-                std::tolower(static_cast<unsigned char>(prefix[i])))
-                return false;
-        }
-        return true;
-    }
-
-    bool IEndsWith(const std::string& str, const std::string& suffix)
-    {
-        if (suffix.size() > str.size())
-            return false;
-
-        std::size_t offset = str.size() - suffix.size();
-        for (std::size_t i = 0; i < suffix.size(); ++i)
-        {
-            if (std::tolower(static_cast<unsigned char>(str[offset + i])) !=
-                std::tolower(static_cast<unsigned char>(suffix[i])))
-                return false;
-        }
-        return true;
-    }
-
-    int ICompare(const std::string& a, const std::string& b)
-    {
-        std::size_t min_len = std::min(a.size(), b.size());
-
-        for (std::size_t i = 0; i < min_len; ++i)
-        {
-            int ca = std::tolower(static_cast<unsigned char>(a[i]));
-            int cb = std::tolower(static_cast<unsigned char>(b[i]));
-
-            if (ca != cb)
-                return ca - cb;
-        }
-
-        // 长度不同
-        if (a.size() < b.size())
-            return -1;
-        if (a.size() > b.size())
-            return 1;
-
-        return 0;
-    }
-
-    std::size_t IHash(const std::string& str)
-    {
-        std::size_t hash = 0;
-        for (unsigned char c : str)
-            hash = hash * 31 + std::tolower(c);
-        return hash;
-    }
-
-    std::size_t IHasher::operator()(const std::string& key) const
-    {
-        return IHash(key);
-    }
-
-    bool IEqualTo::operator()(const std::string& a, const std::string& b) const
-    {
-        return IEquals(a, b);
-    }
-
-    bool ILess::operator()(const std::string& a, const std::string& b) const
-    {
-        return ICompare(a, b) < 0;
-    }
-}

lsp-server/src/utils/string.cppm

@@ -38,3 +38,126 @@ export namespace lsp::utils
         bool operator()(const std::string& a, const std::string& b) const;
     };
 }
+
+namespace lsp::utils
+{
+    std::string Trim(const std::string& str)
+    {
+        std::size_t first = str.find_first_not_of(" \t\n\r");
+        if (first == std::string::npos)
+            return "";
+        std::size_t last = str.find_last_not_of(" \t\n\r");
+        return str.substr(first, last - first + 1);
+    }
+
+    std::string ToLower(const std::string& str)
+    {
+        std::string result = str;
+        std::transform(result.begin(), result.end(), result.begin(), [](unsigned char c) { return std::tolower(c); });
+        return result;
+    }
+
+    std::string ToUpper(const std::string& str)
+    {
+        std::string result = str;
+        std::transform(result.begin(), result.end(), result.begin(), [](unsigned char c) { return std::toupper(c); });
+        return result;
+    }
+
+    bool StartsWith(const std::string& str, const std::string& prefix)
+    {
+        if (prefix.size() > str.size())
+            return false;
+        return str.compare(0, prefix.size(), prefix) == 0;
+    }
+
+    bool EndsWith(const std::string& str, const std::string& suffix)
+    {
+        if (suffix.size() > str.size())
+            return false;
+        return str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;
+    }
+
+    bool IEquals(const std::string& a, const std::string& b)
+    {
+        if (a.size() != b.size())
+            return false;
+
+        return std::equal(a.begin(), a.end(), b.begin(), [](unsigned char ca, unsigned char cb) {
+            return std::tolower(ca) == std::tolower(cb);
+        });
+    }
+
+    bool IStartsWith(const std::string& str, const std::string& prefix)
+    {
+        if (prefix.size() > str.size())
+            return false;
+
+        for (std::size_t i = 0; i < prefix.size(); ++i)
+        {
+            if (std::tolower(static_cast<unsigned char>(str[i])) !=
+                std::tolower(static_cast<unsigned char>(prefix[i])))
+                return false;
+        }
+        return true;
+    }
+
+    bool IEndsWith(const std::string& str, const std::string& suffix)
+    {
+        if (suffix.size() > str.size())
+            return false;
+
+        std::size_t offset = str.size() - suffix.size();
+        for (std::size_t i = 0; i < suffix.size(); ++i)
+        {
+            if (std::tolower(static_cast<unsigned char>(str[offset + i])) !=
+                std::tolower(static_cast<unsigned char>(suffix[i])))
+                return false;
+        }
+        return true;
+    }
+
+    int ICompare(const std::string& a, const std::string& b)
+    {
+        std::size_t min_len = std::min(a.size(), b.size());
+
+        for (std::size_t i = 0; i < min_len; ++i)
+        {
+            int ca = std::tolower(static_cast<unsigned char>(a[i]));
+            int cb = std::tolower(static_cast<unsigned char>(b[i]));
+
+            if (ca != cb)
+                return ca - cb;
+        }
+
+        if (a.size() < b.size())
+            return -1;
+        if (a.size() > b.size())
+            return 1;
+
+        return 0;
+    }
+
+    std::size_t IHash(const std::string& str)
+    {
+        std::size_t hash = 0;
+        for (unsigned char c : str)
+            hash = hash * 31 + std::tolower(c);
+        return hash;
+    }
+
+    std::size_t IHasher::operator()(const std::string& key) const
+    {
+        return IHash(key);
+    }
+
+    bool IEqualTo::operator()(const std::string& a, const std::string& b) const
+    {
+        return IEquals(a, b);
+    }
+
+    bool ILess::operator()(const std::string& a, const std::string& b) const
+    {
+        return ICompare(a, b) < 0;
+    }
+}

lsp-server/test/test_ast/CMakeLists.txt

@@ -18,10 +18,10 @@ endif()
 set(CMAKE_EXPERIMENTAL_CXX_MODULE_DYNDEP 1)
 
 set(SOURCES
+    main.cc
     test.cppm
     debug_printer.cppm
     ../../src/utils/string.cppm
-    ../../src/utils/string.cpp
     ../../src/tree-sitter/scanner.c
     ../../src/tree-sitter/parser.c)
 

lsp-server/test/test_ast/debug_printer.cppm

@@ -135,6 +135,7 @@ export namespace lsp::language::ast::debug
         void VisitEchoExpression(EchoExpression& node) override;
         void VisitRaiseExpression(RaiseExpression& node) override;
         void VisitInheritedExpression(InheritedExpression& node) override;
+        void VisitRdoExpression(RdoExpression& node) override;
         void VisitTSSQLExpression(TSSQLExpression& node) override;
         void VisitColumnReference(ColumnReference& node) override;
 
@@ -2082,6 +2083,26 @@ export namespace lsp::language::ast::debug
         }
     }
 
+    void DebugPrinter::VisitRdoExpression(RdoExpression& node)
+    {
+        PrintIndent();
+        PrintColored("RdoExpression", Color::BrightCyan);
+
+        if (options_.show_location)
+        {
+            os_ << " ";
+            PrintLocation(node.span);
+        }
+        os_ << "\n";
+
+        if (node.call)
+        {
+            IncreaseIndent();
+            PrintExpression(node.call.value().get(), "Call", true);
+            DecreaseIndent();
+        }
+    }
+
     void DebugPrinter::VisitTSSQLExpression(TSSQLExpression& node)
     {
         PrintIndent();

lsp-server/test/test_ast/main.cc

@@ -0,0 +1,6 @@
+import lsp.test.ast.main;
+
+int main(int argc, char* argv[])
+{
+    return Run(argc, argv);
+}

lsp-server/test/test_ast/test.cppm

@@ -120,7 +120,7 @@ void PrintUsage(const char* program_name)
     std::cout << "  " << program_name << " test.tsf -s -n  # Show source without colors\n";
 }
 
-int main(int argc, char* argv[])
+export int Run(int argc, char* argv[])
 {
     if (argc < 2)
     {

lsp-server/test/test_lsp_any/CMakeLists.txt

@@ -13,6 +13,7 @@ if(UNIX AND NOT APPLE)
 endif()
 
 set(SOURCES
+    main.cc
     test_main.cppm)
 
 add_executable(${PROJECT_NAME} ${SOURCES})

lsp-server/test/test_lsp_any/main.cc

@@ -0,0 +1,6 @@
+import lsp.test.lsp_any.main;
+
+int main()
+{
+    return Run();
+}

lsp-server/test/test_lsp_any/test_main.cppm

@@ -10,7 +10,7 @@ import lsp.test.lsp_any.transformer;
 import lsp.test.lsp_any.facade;
 import lsp.test.lsp_any.common;
 
-int main()
+export int Run()
 {
     lsp::test::TestRunner runner;
 

lsp-server/test/test_module/CMakeLists.txt

@@ -12,7 +12,7 @@ endif()
 
 set(CMAKE_EXPERIMENTAL_CXX_MODULE_DYNDEP 1)
 
-add_executable(test_module main.cppm)
+add_executable(test_module main.cppm main.cc)
 target_sources(
   test_module
   PRIVATE

lsp-server/test/test_module/main.cc

@@ -0,0 +1,6 @@
+import lsp.test.module_demo.main;
+
+int main()
+{
+    return Run();
+}

lsp-server/test/test_module/main.cppm

@@ -7,7 +7,7 @@ import std;
 import math;
 import math2;
 
-int main()
+export int Run()
 {
     std::cout << "hello std module\n";
     std::vector<int> v{ 1, 2, 3 };

lsp-server/test/test_scheduler/CMakeLists.txt

@@ -15,6 +15,7 @@ if(UNIX AND NOT APPLE)
 endif()
 
 set(SOURCES
+    main.cc
     test_async_executor.cppm)
 
 add_executable(${PROJECT_NAME} ${SOURCES})

lsp-server/test/test_scheduler/main.cc

@@ -0,0 +1,6 @@
+import lsp.test.scheduler.async_executor;
+
+int main()
+{
+    return Run();
+}

lsp-server/test/test_scheduler/test_async_executor.cppm

@@ -55,7 +55,7 @@ namespace
     };
 }
 
-int main()
+export int Run()
 {
     SchedulerTestSuite suite;
 

lsp-server/test/test_semantic/CMakeLists.txt

@@ -17,9 +17,9 @@ endif()
 set(CMAKE_EXPERIMENTAL_CXX_MODULE_DYNDEP 1)
 
 set(SOURCES
+    main.cc
     test_semantic.cppm
     ../../src/utils/string.cppm
-    ../../src/utils/string.cpp
     ../../src/language/symbol/internal/builder.cppm
     ../../src/language/symbol/internal/store.cppm
     ../../src/language/symbol/internal/table.cppm

lsp-server/test/test_semantic/main.cc

@@ -0,0 +1,6 @@
+import lsp.test.semantic.main;
+
+int main(int argc, char** argv)
+{
+    return Run(argc, argv);
+}

lsp-server/test/test_semantic/test_semantic.cppm

@@ -436,7 +436,7 @@ namespace
     }
 }
 
-int main(int argc, char** argv)
+export int Run(int argc, char** argv)
 {
     try
     {

lsp-server/test/test_symbol/CMakeLists.txt

@@ -18,9 +18,9 @@ endif()
 set(CMAKE_EXPERIMENTAL_CXX_MODULE_DYNDEP 1)
 
 set(SOURCES
+    main.cc
     test.cppm
     ../../src/utils/string.cppm
-    ../../src/utils/string.cpp
     ../../src/language/symbol/internal/builder.cppm
     ../../src/language/symbol/internal/store.cppm
     ../../src/language/symbol/internal/table.cppm

lsp-server/test/test_symbol/main.cc

@@ -0,0 +1,6 @@
+import lsp.test.symbol.main;
+
+int main(int argc, char* argv[])
+{
+    return Run(argc, argv);
+}

lsp-server/test/test_symbol/test.cppm

@@ -1050,7 +1050,7 @@ void AnalyzeFile(const Options& options)
 
 // ==================== 主程序 ====================
 
-int main(int argc, char* argv[])
+export int Run(int argc, char* argv[])
 {
     Options options;
 

lsp-server/test/test_tree_sitter/grammar.js

@@ -1151,6 +1151,7 @@ module.exports = grammar({
         $.echo_expression,
         $.raise_expression,
         $.inherited_expression,
+        $.rdo_expression,
       ),
 
     new_expression: ($) => seq(kw("new"), field("constructor", $.expression)),
@@ -1162,7 +1163,13 @@ module.exports = grammar({
     inherited_expression: ($) =>
       prec.right(
         kPrec.kCall,
-        seq(kw("inherited"), optional(field("class", $.call_expression))),
+        seq(kw("inherited"), optional(field("call", $.call_expression))),
+      ),
+
+    rdo_expression: ($) =>
+      prec.right(
+        kPrec.kCall,
+        seq(choice(kw("rdo"), kw("rdo2")), optional(field("call", $.call_expression))),
       ),
 
     array_expression: ($) =>

lsp-server/test/test_tree_sitter/src/grammar.json

@@ -6754,6 +6754,10 @@
         {
           "type": "SYMBOL",
           "name": "inherited_expression"
+        },
+        {
+          "type": "SYMBOL",
+          "name": "rdo_expression"
         }
       ]
     },
@@ -6864,7 +6868,55 @@
             "members": [
               {
                 "type": "FIELD",
-                "name": "class",
+                "name": "call",
+                "content": {
+                  "type": "SYMBOL",
+                  "name": "call_expression"
+                }
+              },
+              {
+                "type": "BLANK"
+              }
+            ]
+          }
+        ]
+      }
+    },
+    "rdo_expression": {
+      "type": "PREC_RIGHT",
+      "value": 18,
+      "content": {
+        "type": "SEQ",
+        "members": [
+          {
+            "type": "CHOICE",
+            "members": [
+              {
+                "type": "ALIAS",
+                "content": {
+                  "type": "PATTERN",
+                  "value": "(?i)rdo"
+                },
+                "named": false,
+                "value": "rdo"
+              },
+              {
+                "type": "ALIAS",
+                "content": {
+                  "type": "PATTERN",
+                  "value": "(?i)rdo2"
+                },
+                "named": false,
+                "value": "rdo2"
+              }
+            ]
+          },
+          {
+            "type": "CHOICE",
+            "members": [
+              {
+                "type": "FIELD",
+                "name": "call",
                 "content": {
                   "type": "SYMBOL",
                   "name": "call_expression"

lsp-server/test/test_tree_sitter/src/node-types.json

@@ -2256,6 +2256,10 @@
           "type": "raise_expression",
           "named": true
         },
+        {
+          "type": "rdo_expression",
+          "named": true
+        },
         {
           "type": "select_expression",
           "named": true
@@ -3600,7 +3604,7 @@
     "type": "inherited_expression",
     "named": true,
     "fields": {
-      "class": {
+      "call": {
         "multiple": false,
         "required": false,
         "types": [
@@ -4863,6 +4867,22 @@
       }
     }
   },
+  {
+    "type": "rdo_expression",
+    "named": true,
+    "fields": {
+      "call": {
+        "multiple": false,
+        "required": false,
+        "types": [
+          {
+            "type": "call_expression",
+            "named": true
+          }
+        ]
+      }
+    }
+  },
   {
     "type": "reference_modifier",
     "named": true,
@@ -7001,6 +7021,14 @@
     "type": "raise",
     "named": false
   },
+  {
+    "type": "rdo",
+    "named": false
+  },
+  {
+    "type": "rdo2",
+    "named": false
+  },
   {
     "type": "read",
     "named": false

lsp-server/test/test_tree_sitter/src/tree_sitter/alloc.h

@@ -12,37 +12,37 @@ extern "C" {
 // Allow clients to override allocation functions
 #ifdef TREE_SITTER_REUSE_ALLOCATOR
 
-extern void* (*ts_current_malloc)(size_t size);
-extern void* (*ts_current_calloc)(size_t count, size_t size);
-extern void* (*ts_current_realloc)(void* ptr, size_t size);
-extern void (*ts_current_free)(void* ptr);
+extern void *(*ts_current_malloc)(size_t size);
+extern void *(*ts_current_calloc)(size_t count, size_t size);
+extern void *(*ts_current_realloc)(void *ptr, size_t size);
+extern void (*ts_current_free)(void *ptr);
 
 #ifndef ts_malloc
-#define ts_malloc ts_current_malloc
+#define ts_malloc  ts_current_malloc
 #endif
 #ifndef ts_calloc
-#define ts_calloc ts_current_calloc
+#define ts_calloc  ts_current_calloc
 #endif
 #ifndef ts_realloc
 #define ts_realloc ts_current_realloc
 #endif
 #ifndef ts_free
-#define ts_free ts_current_free
+#define ts_free    ts_current_free
 #endif
 
 #else
 
 #ifndef ts_malloc
-#define ts_malloc malloc
+#define ts_malloc  malloc
 #endif
 #ifndef ts_calloc
-#define ts_calloc calloc
+#define ts_calloc  calloc
 #endif
 #ifndef ts_realloc
 #define ts_realloc realloc
 #endif
 #ifndef ts_free
-#define ts_free free
+#define ts_free    free
 #endif
 
 #endif

lsp-server/test/test_tree_sitter/src/tree_sitter/array.h

@@ -21,25 +21,24 @@ extern "C" {
 #pragma GCC diagnostic ignored "-Wunused-variable"
 #endif
 
-#define Array(T)           \
-    struct                 \
-    {                      \
-        T* contents;       \
-        uint32_t size;     \
-        uint32_t capacity; \
-    }
+#define Array(T)       \
+  struct {             \
+    T *contents;       \
+    uint32_t size;     \
+    uint32_t capacity; \
+  }
 
 /// Initialize an array.
 #define array_init(self) \
-    ((self)->size = 0, (self)->capacity = 0, (self)->contents = NULL)
+  ((self)->size = 0, (self)->capacity = 0, (self)->contents = NULL)
 
 /// Create an empty array.
 #define array_new() \
-    { NULL, 0, 0 }
+  { NULL, 0, 0 }
 
 /// Get a pointer to the element at a given `index` in the array.
 #define array_get(self, _index) \
-    (assert((uint32_t)(_index) < (self)->size), &(self)->contents[_index])
+  (assert((uint32_t)(_index) < (self)->size), &(self)->contents[_index])
 
 /// Get a pointer to the first element in the array.
 #define array_front(self) array_get(self, 0)
@@ -54,64 +53,66 @@ extern "C" {
 /// Reserve `new_capacity` elements of space in the array. If `new_capacity` is
 /// less than the array's current capacity, this function has no effect.
 #define array_reserve(self, new_capacity) \
-    _array__reserve((Array*)(self), array_elem_size(self), new_capacity)
+  _array__reserve((Array *)(self), array_elem_size(self), new_capacity)
 
 /// Free any memory allocated for this array. Note that this does not free any
 /// memory allocated for the array's contents.
-#define array_delete(self) _array__delete((Array*)(self))
+#define array_delete(self) _array__delete((Array *)(self))
 
 /// Push a new `element` onto the end of the array.
 #define array_push(self, element)                            \
-    (_array__grow((Array*)(self), 1, array_elem_size(self)), \
-     (self)->contents[(self)->size++] = (element))
+  (_array__grow((Array *)(self), 1, array_elem_size(self)), \
+   (self)->contents[(self)->size++] = (element))
 
 /// Increase the array's size by `count` elements.
 /// New elements are zero-initialized.
-#define array_grow_by(self, count)                                                   \
-    do                                                                               \
-    {                                                                                \
-        if ((count) == 0)                                                            \
-            break;                                                                   \
-        _array__grow((Array*)(self), count, array_elem_size(self));                  \
-        memset((self)->contents + (self)->size, 0, (count) * array_elem_size(self)); \
-        (self)->size += (count);                                                     \
-    } while (0)
+#define array_grow_by(self, count) \
+  do { \
+    if ((count) == 0) break; \
+    _array__grow((Array *)(self), count, array_elem_size(self)); \
+    memset((self)->contents + (self)->size, 0, (count) * array_elem_size(self)); \
+    (self)->size += (count); \
+  } while (0)
 
 /// Append all elements from one array to the end of another.
-#define array_push_all(self, other) \
-    array_extend((self), (other)->size, (other)->contents)
+#define array_push_all(self, other)                                       \
+  array_extend((self), (other)->size, (other)->contents)
 
 /// Append `count` elements to the end of the array, reading their values from the
 /// `contents` pointer.
-#define array_extend(self, count, contents) \
-    _array__splice(                         \
-        (Array*)(self), array_elem_size(self), (self)->size, 0, count, contents)
+#define array_extend(self, count, contents)                    \
+  _array__splice(                                               \
+    (Array *)(self), array_elem_size(self), (self)->size, \
+    0, count,  contents                                        \
+  )
 
 /// Remove `old_count` elements from the array starting at the given `index`. At
 /// the same index, insert `new_count` new elements, reading their values from the
 /// `new_contents` pointer.
-#define array_splice(self, _index, old_count, new_count, new_contents) \
-    _array__splice(                                                    \
-        (Array*)(self), array_elem_size(self), _index, old_count, new_count, new_contents)
+#define array_splice(self, _index, old_count, new_count, new_contents)  \
+  _array__splice(                                                       \
+    (Array *)(self), array_elem_size(self), _index,                \
+    old_count, new_count, new_contents                                 \
+  )
 
 /// Insert one `element` into the array at the given `index`.
 #define array_insert(self, _index, element) \
-    _array__splice((Array*)(self), array_elem_size(self), _index, 0, 1, &(element))
+  _array__splice((Array *)(self), array_elem_size(self), _index, 0, 1, &(element))
 
 /// Remove one element from the array at the given `index`.
 #define array_erase(self, _index) \
-    _array__erase((Array*)(self), array_elem_size(self), _index)
+  _array__erase((Array *)(self), array_elem_size(self), _index)
 
 /// Pop the last element off the array, returning the element by value.
 #define array_pop(self) ((self)->contents[--(self)->size])
 
 /// Assign the contents of one array to another, reallocating if necessary.
 #define array_assign(self, other) \
-    _array__assign((Array*)(self), (const Array*)(other), array_elem_size(self))
+  _array__assign((Array *)(self), (const Array *)(other), array_elem_size(self))
 
 /// Swap one array with another
 #define array_swap(self, other) \
-    _array__swap((Array*)(self), (Array*)(other))
+  _array__swap((Array *)(self), (Array *)(other))
 
 /// Get the size of the array contents
 #define array_elem_size(self) (sizeof *(self)->contents)
@@ -125,176 +126,153 @@ extern "C" {
 /// `needle` should be inserted in order to preserve the sorting, and `exists`
 /// is set to false.
 #define array_search_sorted_with(self, compare, needle, _index, _exists) \
-    _array__search_sorted(self, 0, compare, , needle, _index, _exists)
+  _array__search_sorted(self, 0, compare, , needle, _index, _exists)
 
 /// Search a sorted array for a given `needle` value, using integer comparisons
 /// of a given struct field (specified with a leading dot) to determine the order.
 ///
 /// See also `array_search_sorted_with`.
 #define array_search_sorted_by(self, field, needle, _index, _exists) \
-    _array__search_sorted(self, 0, _compare_int, field, needle, _index, _exists)
+  _array__search_sorted(self, 0, _compare_int, field, needle, _index, _exists)
 
 /// Insert a given `value` into a sorted array, using the given `compare`
 /// callback to determine the order.
-#define array_insert_sorted_with(self, compare, value)                        \
-    do                                                                        \
-    {                                                                         \
-        unsigned _index, _exists;                                             \
-        array_search_sorted_with(self, compare, &(value), &_index, &_exists); \
-        if (!_exists)                                                         \
-            array_insert(self, _index, value);                                \
-    } while (0)
+#define array_insert_sorted_with(self, compare, value) \
+  do { \
+    unsigned _index, _exists; \
+    array_search_sorted_with(self, compare, &(value), &_index, &_exists); \
+    if (!_exists) array_insert(self, _index, value); \
+  } while (0)
 
 /// Insert a given `value` into a sorted array, using integer comparisons of
 /// a given struct field (specified with a leading dot) to determine the order.
 ///
 /// See also `array_search_sorted_by`.
-#define array_insert_sorted_by(self, field, value)                            \
-    do                                                                        \
-    {                                                                         \
-        unsigned _index, _exists;                                             \
-        array_search_sorted_by(self, field, (value)field, &_index, &_exists); \
-        if (!_exists)                                                         \
-            array_insert(self, _index, value);                                \
-    } while (0)
+#define array_insert_sorted_by(self, field, value) \
+  do { \
+    unsigned _index, _exists; \
+    array_search_sorted_by(self, field, (value) field, &_index, &_exists); \
+    if (!_exists) array_insert(self, _index, value); \
+  } while (0)
 
 // Private
 
 typedef Array(void) Array;
 
 /// This is not what you're looking for, see `array_delete`.
-static inline void _array__delete(Array* self)
-{
-    if (self->contents)
-    {
-        ts_free(self->contents);
-        self->contents = NULL;
-        self->size = 0;
-        self->capacity = 0;
-    }
+static inline void _array__delete(Array *self) {
+  if (self->contents) {
+    ts_free(self->contents);
+    self->contents = NULL;
+    self->size = 0;
+    self->capacity = 0;
+  }
 }
 
 /// This is not what you're looking for, see `array_erase`.
-static inline void _array__erase(Array* self, size_t element_size, uint32_t index)
-{
-    assert(index < self->size);
-    char* contents = (char*)self->contents;
-    memmove(contents + index * element_size, contents + (index + 1) * element_size, (self->size - index - 1) * element_size);
-    self->size--;
+static inline void _array__erase(Array *self, size_t element_size,
+                                uint32_t index) {
+  assert(index < self->size);
+  char *contents = (char *)self->contents;
+  memmove(contents + index * element_size, contents + (index + 1) * element_size,
+          (self->size - index - 1) * element_size);
+  self->size--;
 }
 
 /// This is not what you're looking for, see `array_reserve`.
-static inline void _array__reserve(Array* self, size_t element_size, uint32_t new_capacity)
-{
-    if (new_capacity > self->capacity)
-    {
-        if (self->contents)
-        {
-            self->contents = ts_realloc(self->contents, new_capacity * element_size);
-        }
-        else
-        {
-            self->contents = ts_malloc(new_capacity * element_size);
-        }
-        self->capacity = new_capacity;
+static inline void _array__reserve(Array *self, size_t element_size, uint32_t new_capacity) {
+  if (new_capacity > self->capacity) {
+    if (self->contents) {
+      self->contents = ts_realloc(self->contents, new_capacity * element_size);
+    } else {
+      self->contents = ts_malloc(new_capacity * element_size);
     }
+    self->capacity = new_capacity;
+  }
 }
 
 /// This is not what you're looking for, see `array_assign`.
-static inline void _array__assign(Array* self, const Array* other, size_t element_size)
-{
-    _array__reserve(self, element_size, other->size);
-    self->size = other->size;
-    memcpy(self->contents, other->contents, self->size * element_size);
+static inline void _array__assign(Array *self, const Array *other, size_t element_size) {
+  _array__reserve(self, element_size, other->size);
+  self->size = other->size;
+  memcpy(self->contents, other->contents, self->size * element_size);
 }
 
 /// This is not what you're looking for, see `array_swap`.
-static inline void _array__swap(Array* self, Array* other)
-{
-    Array swap = *other;
-    *other = *self;
-    *self = swap;
+static inline void _array__swap(Array *self, Array *other) {
+  Array swap = *other;
+  *other = *self;
+  *self = swap;
 }
 
 /// This is not what you're looking for, see `array_push` or `array_grow_by`.
-static inline void _array__grow(Array* self, uint32_t count, size_t element_size)
-{
-    uint32_t new_size = self->size + count;
-    if (new_size > self->capacity)
-    {
-        uint32_t new_capacity = self->capacity * 2;
-        if (new_capacity < 8)
-            new_capacity = 8;
-        if (new_capacity < new_size)
-            new_capacity = new_size;
-        _array__reserve(self, element_size, new_capacity);
-    }
+static inline void _array__grow(Array *self, uint32_t count, size_t element_size) {
+  uint32_t new_size = self->size + count;
+  if (new_size > self->capacity) {
+    uint32_t new_capacity = self->capacity * 2;
+    if (new_capacity < 8) new_capacity = 8;
+    if (new_capacity < new_size) new_capacity = new_size;
+    _array__reserve(self, element_size, new_capacity);
+  }
 }
 
 /// This is not what you're looking for, see `array_splice`.
-static inline void _array__splice(Array* self, size_t element_size, uint32_t index, uint32_t old_count, uint32_t new_count, const void* elements)
-{
-    uint32_t new_size = self->size + new_count - old_count;
-    uint32_t old_end = index + old_count;
-    uint32_t new_end = index + new_count;
-    assert(old_end <= self->size);
+static inline void _array__splice(Array *self, size_t element_size,
+                                 uint32_t index, uint32_t old_count,
+                                 uint32_t new_count, const void *elements) {
+  uint32_t new_size = self->size + new_count - old_count;
+  uint32_t old_end = index + old_count;
+  uint32_t new_end = index + new_count;
+  assert(old_end <= self->size);
 
-    _array__reserve(self, element_size, new_size);
+  _array__reserve(self, element_size, new_size);
 
-    char* contents = (char*)self->contents;
-    if (self->size > old_end)
-    {
-        memmove(
-            contents + new_end * element_size,
-            contents + old_end * element_size,
-            (self->size - old_end) * element_size);
+  char *contents = (char *)self->contents;
+  if (self->size > old_end) {
+    memmove(
+      contents + new_end * element_size,
+      contents + old_end * element_size,
+      (self->size - old_end) * element_size
+    );
+  }
+  if (new_count > 0) {
+    if (elements) {
+      memcpy(
+        (contents + index * element_size),
+        elements,
+        new_count * element_size
+      );
+    } else {
+      memset(
+        (contents + index * element_size),
+        0,
+        new_count * element_size
+      );
     }
-    if (new_count > 0)
-    {
-        if (elements)
-        {
-            memcpy(
-                (contents + index * element_size),
-                elements,
-                new_count * element_size);
-        }
-        else
-        {
-            memset(
-                (contents + index * element_size),
-                0,
-                new_count * element_size);
-        }
-    }
-    self->size += new_count - old_count;
+  }
+  self->size += new_count - old_count;
 }
 
 /// A binary search routine, based on Rust's `std::slice::binary_search_by`.
 /// This is not what you're looking for, see `array_search_sorted_with` or `array_search_sorted_by`.
 #define _array__search_sorted(self, start, compare, suffix, needle, _index, _exists) \
-    do                                                                               \
-    {                                                                                \
-        *(_index) = start;                                                           \
-        *(_exists) = false;                                                          \
-        uint32_t size = (self)->size - *(_index);                                    \
-        if (size == 0)                                                               \
-            break;                                                                   \
-        int comparison;                                                              \
-        while (size > 1)                                                             \
-        {                                                                            \
-            uint32_t half_size = size / 2;                                           \
-            uint32_t mid_index = *(_index) + half_size;                              \
-            comparison = compare(&((self)->contents[mid_index] suffix), (needle));   \
-            if (comparison <= 0)                                                     \
-                *(_index) = mid_index;                                               \
-            size -= half_size;                                                       \
-        }                                                                            \
-        comparison = compare(&((self)->contents[*(_index)] suffix), (needle));       \
-        if (comparison == 0)                                                         \
-            *(_exists) = true;                                                       \
-        else if (comparison < 0)                                                     \
-            *(_index) += 1;                                                          \
-    } while (0)
+  do { \
+    *(_index) = start; \
+    *(_exists) = false; \
+    uint32_t size = (self)->size - *(_index); \
+    if (size == 0) break; \
+    int comparison; \
+    while (size > 1) { \
+      uint32_t half_size = size / 2; \
+      uint32_t mid_index = *(_index) + half_size; \
+      comparison = compare(&((self)->contents[mid_index] suffix), (needle)); \
+      if (comparison <= 0) *(_index) = mid_index; \
+      size -= half_size; \
+    } \
+    comparison = compare(&((self)->contents[*(_index)] suffix), (needle)); \
+    if (comparison == 0) *(_exists) = true; \
+    else if (comparison < 0) *(_index) += 1; \
+  } while (0)
 
 /// Helper macro for the `_sorted_by` routines below. This takes the left (existing)
 /// parameter by reference in order to work with the generic sorting function above.
@@ -310,4 +288,4 @@ static inline void _array__splice(Array* self, size_t element_size, uint32_t ind
 }
 #endif
 
-#endif // TREE_SITTER_ARRAY_H_
+#endif  // TREE_SITTER_ARRAY_H_

lsp-server/test/test_tree_sitter/src/tree_sitter/parser.h

@@ -9,7 +9,7 @@ extern "C" {
 #include <stdint.h>
 #include <stdlib.h>
 
-#define ts_builtin_sym_error ((TSSymbol) - 1)
+#define ts_builtin_sym_error ((TSSymbol)-1)
 #define ts_builtin_sym_end 0
 #define TREE_SITTER_SERIALIZATION_BUFFER_SIZE 1024
 
@@ -18,176 +18,155 @@ typedef uint16_t TSStateId;
 typedef uint16_t TSSymbol;
 typedef uint16_t TSFieldId;
 typedef struct TSLanguage TSLanguage;
-typedef struct TSLanguageMetadata
-{
-    uint8_t major_version;
-    uint8_t minor_version;
-    uint8_t patch_version;
+typedef struct TSLanguageMetadata {
+  uint8_t major_version;
+  uint8_t minor_version;
+  uint8_t patch_version;
 } TSLanguageMetadata;
 #endif
 
-typedef struct
-{
-    TSFieldId field_id;
-    uint8_t child_index;
-    bool inherited;
+typedef struct {
+  TSFieldId field_id;
+  uint8_t child_index;
+  bool inherited;
 } TSFieldMapEntry;
 
 // Used to index the field and supertype maps.
-typedef struct
-{
-    uint16_t index;
-    uint16_t length;
+typedef struct {
+  uint16_t index;
+  uint16_t length;
 } TSMapSlice;
 
-typedef struct
-{
-    bool visible;
-    bool named;
-    bool supertype;
+typedef struct {
+  bool visible;
+  bool named;
+  bool supertype;
 } TSSymbolMetadata;
 
 typedef struct TSLexer TSLexer;
 
-struct TSLexer
-{
-    int32_t lookahead;
-    TSSymbol result_symbol;
-    void (*advance)(TSLexer*, bool);
-    void (*mark_end)(TSLexer*);
-    uint32_t (*get_column)(TSLexer*);
-    bool (*is_at_included_range_start)(const TSLexer*);
-    bool (*eof)(const TSLexer*);
-    void (*log)(const TSLexer*, const char*, ...);
+struct TSLexer {
+  int32_t lookahead;
+  TSSymbol result_symbol;
+  void (*advance)(TSLexer *, bool);
+  void (*mark_end)(TSLexer *);
+  uint32_t (*get_column)(TSLexer *);
+  bool (*is_at_included_range_start)(const TSLexer *);
+  bool (*eof)(const TSLexer *);
+  void (*log)(const TSLexer *, const char *, ...);
 };
 
-typedef enum
-{
-    TSParseActionTypeShift,
-    TSParseActionTypeReduce,
-    TSParseActionTypeAccept,
-    TSParseActionTypeRecover,
+typedef enum {
+  TSParseActionTypeShift,
+  TSParseActionTypeReduce,
+  TSParseActionTypeAccept,
+  TSParseActionTypeRecover,
 } TSParseActionType;
 
-typedef union
-{
-    struct
-    {
-        uint8_t type;
-        TSStateId state;
-        bool extra;
-        bool repetition;
-    } shift;
-    struct
-    {
-        uint8_t type;
-        uint8_t child_count;
-        TSSymbol symbol;
-        int16_t dynamic_precedence;
-        uint16_t production_id;
-    } reduce;
+typedef union {
+  struct {
     uint8_t type;
+    TSStateId state;
+    bool extra;
+    bool repetition;
+  } shift;
+  struct {
+    uint8_t type;
+    uint8_t child_count;
+    TSSymbol symbol;
+    int16_t dynamic_precedence;
+    uint16_t production_id;
+  } reduce;
+  uint8_t type;
 } TSParseAction;
 
-typedef struct
-{
-    uint16_t lex_state;
-    uint16_t external_lex_state;
+typedef struct {
+  uint16_t lex_state;
+  uint16_t external_lex_state;
 } TSLexMode;
 
-typedef struct
-{
-    uint16_t lex_state;
-    uint16_t external_lex_state;
-    uint16_t reserved_word_set_id;
+typedef struct {
+  uint16_t lex_state;
+  uint16_t external_lex_state;
+  uint16_t reserved_word_set_id;
 } TSLexerMode;
 
-typedef union
-{
-    TSParseAction action;
-    struct
-    {
-        uint8_t count;
-        bool reusable;
-    } entry;
+typedef union {
+  TSParseAction action;
+  struct {
+    uint8_t count;
+    bool reusable;
+  } entry;
 } TSParseActionEntry;
 
-typedef struct
-{
-    int32_t start;
-    int32_t end;
+typedef struct {
+  int32_t start;
+  int32_t end;
 } TSCharacterRange;
 
-struct TSLanguage
-{
-    uint32_t abi_version;
-    uint32_t symbol_count;
-    uint32_t alias_count;
-    uint32_t token_count;
-    uint32_t external_token_count;
-    uint32_t state_count;
-    uint32_t large_state_count;
-    uint32_t production_id_count;
-    uint32_t field_count;
-    uint16_t max_alias_sequence_length;
-    const uint16_t* parse_table;
-    const uint16_t* small_parse_table;
-    const uint32_t* small_parse_table_map;
-    const TSParseActionEntry* parse_actions;
-    const char* const* symbol_names;
-    const char* const* field_names;
-    const TSMapSlice* field_map_slices;
-    const TSFieldMapEntry* field_map_entries;
-    const TSSymbolMetadata* symbol_metadata;
-    const TSSymbol* public_symbol_map;
-    const uint16_t* alias_map;
-    const TSSymbol* alias_sequences;
-    const TSLexerMode* lex_modes;
-    bool (*lex_fn)(TSLexer*, TSStateId);
-    bool (*keyword_lex_fn)(TSLexer*, TSStateId);
-    TSSymbol keyword_capture_token;
-    struct
-    {
-        const bool* states;
-        const TSSymbol* symbol_map;
-        void* (*create)(void);
-        void (*destroy)(void*);
-        bool (*scan)(void*, TSLexer*, const bool* symbol_whitelist);
-        unsigned (*serialize)(void*, char*);
-        void (*deserialize)(void*, const char*, unsigned);
-    } external_scanner;
-    const TSStateId* primary_state_ids;
-    const char* name;
-    const TSSymbol* reserved_words;
-    uint16_t max_reserved_word_set_size;
-    uint32_t supertype_count;
-    const TSSymbol* supertype_symbols;
-    const TSMapSlice* supertype_map_slices;
-    const TSSymbol* supertype_map_entries;
-    TSLanguageMetadata metadata;
+struct TSLanguage {
+  uint32_t abi_version;
+  uint32_t symbol_count;
+  uint32_t alias_count;
+  uint32_t token_count;
+  uint32_t external_token_count;
+  uint32_t state_count;
+  uint32_t large_state_count;
+  uint32_t production_id_count;
+  uint32_t field_count;
+  uint16_t max_alias_sequence_length;
+  const uint16_t *parse_table;
+  const uint16_t *small_parse_table;
+  const uint32_t *small_parse_table_map;
+  const TSParseActionEntry *parse_actions;
+  const char * const *symbol_names;
+  const char * const *field_names;
+  const TSMapSlice *field_map_slices;
+  const TSFieldMapEntry *field_map_entries;
+  const TSSymbolMetadata *symbol_metadata;
+  const TSSymbol *public_symbol_map;
+  const uint16_t *alias_map;
+  const TSSymbol *alias_sequences;
+  const TSLexerMode *lex_modes;
+  bool (*lex_fn)(TSLexer *, TSStateId);
+  bool (*keyword_lex_fn)(TSLexer *, TSStateId);
+  TSSymbol keyword_capture_token;
+  struct {
+    const bool *states;
+    const TSSymbol *symbol_map;
+    void *(*create)(void);
+    void (*destroy)(void *);
+    bool (*scan)(void *, TSLexer *, const bool *symbol_whitelist);
+    unsigned (*serialize)(void *, char *);
+    void (*deserialize)(void *, const char *, unsigned);
+  } external_scanner;
+  const TSStateId *primary_state_ids;
+  const char *name;
+  const TSSymbol *reserved_words;
+  uint16_t max_reserved_word_set_size;
+  uint32_t supertype_count;
+  const TSSymbol *supertype_symbols;
+  const TSMapSlice *supertype_map_slices;
+  const TSSymbol *supertype_map_entries;
+  TSLanguageMetadata metadata;
 };
 
-static inline bool set_contains(const TSCharacterRange* ranges, uint32_t len, int32_t lookahead)
-{
-    uint32_t index = 0;
-    uint32_t size = len - index;
-    while (size > 1)
-    {
-        uint32_t half_size = size / 2;
-        uint32_t mid_index = index + half_size;
-        const TSCharacterRange* range = &ranges[mid_index];
-        if (lookahead >= range->start && lookahead <= range->end)
-        {
-            return true;
-        }
-        else if (lookahead > range->end)
-        {
-            index = mid_index;
-        }
-        size -= half_size;
+static inline bool set_contains(const TSCharacterRange *ranges, uint32_t len, int32_t lookahead) {
+  uint32_t index = 0;
+  uint32_t size = len - index;
+  while (size > 1) {
+    uint32_t half_size = size / 2;
+    uint32_t mid_index = index + half_size;
+    const TSCharacterRange *range = &ranges[mid_index];
+    if (lookahead >= range->start && lookahead <= range->end) {
+      return true;
+    } else if (lookahead > range->end) {
+      index = mid_index;
     }
-    const TSCharacterRange* range = &ranges[index];
-    return (lookahead >= range->start && lookahead <= range->end);
+    size -= half_size;
+  }
+  const TSCharacterRange *range = &ranges[index];
+  return (lookahead >= range->start && lookahead <= range->end);
 }
 
 /*
@@ -200,49 +179,47 @@ static inline bool set_contains(const TSCharacterRange* ranges, uint32_t len, in
 #define UNUSED __attribute__((unused))
 #endif
 
-#define START_LEXER()            \
-    bool result = false;         \
-    bool skip = false;           \
-    UNUSED                       \
-    bool eof = false;            \
-    int32_t lookahead;           \
-    goto start;                  \
-    next_state:                  \
-    lexer->advance(lexer, skip); \
-    start:                       \
-    skip = false;                \
-    lookahead = lexer->lookahead;
+#define START_LEXER()           \
+  bool result = false;          \
+  bool skip = false;            \
+  UNUSED                        \
+  bool eof = false;             \
+  int32_t lookahead;            \
+  goto start;                   \
+  next_state:                   \
+  lexer->advance(lexer, skip);  \
+  start:                        \
+  skip = false;                 \
+  lookahead = lexer->lookahead;
 
 #define ADVANCE(state_value) \
-    {                        \
-        state = state_value; \
-        goto next_state;     \
-    }
+  {                          \
+    state = state_value;     \
+    goto next_state;         \
+  }
 
-#define ADVANCE_MAP(...)                                               \
-    {                                                                  \
-        static const uint16_t map[] = { __VA_ARGS__ };                 \
-        for (uint32_t i = 0; i < sizeof(map) / sizeof(map[0]); i += 2) \
-        {                                                              \
-            if (map[i] == lookahead)                                   \
-            {                                                          \
-                state = map[i + 1];                                    \
-                goto next_state;                                       \
-            }                                                          \
-        }                                                              \
-    }
+#define ADVANCE_MAP(...)                                              \
+  {                                                                   \
+    static const uint16_t map[] = { __VA_ARGS__ };                    \
+    for (uint32_t i = 0; i < sizeof(map) / sizeof(map[0]); i += 2) {  \
+      if (map[i] == lookahead) {                                      \
+        state = map[i + 1];                                           \
+        goto next_state;                                              \
+      }                                                               \
+    }                                                                 \
+  }
 
-#define SKIP(state_value)    \
-    {                        \
-        skip = true;         \
-        state = state_value; \
-        goto next_state;     \
-    }
+#define SKIP(state_value) \
+  {                       \
+    skip = true;          \
+    state = state_value;  \
+    goto next_state;      \
+  }
 
-#define ACCEPT_TOKEN(symbol_value)       \
-    result = true;                       \
-    lexer->result_symbol = symbol_value; \
-    lexer->mark_end(lexer);
+#define ACCEPT_TOKEN(symbol_value)     \
+  result = true;                       \
+  lexer->result_symbol = symbol_value; \
+  lexer->mark_end(lexer);
 
 #define END_STATE() return result;
 
@@ -256,66 +233,54 @@ static inline bool set_contains(const TSCharacterRange* ranges, uint32_t len, in
 
 #define ACTIONS(id) id
 
-#define SHIFT(state_value)                      \
-    {                                           \
-        {                                       \
-            .shift = {                          \
-                .type = TSParseActionTypeShift, \
-                .state = (state_value)          \
-            }                                   \
-        }                                       \
-    }
+#define SHIFT(state_value)            \
+  {{                                  \
+    .shift = {                        \
+      .type = TSParseActionTypeShift, \
+      .state = (state_value)          \
+    }                                 \
+  }}
 
-#define SHIFT_REPEAT(state_value)               \
-    {                                           \
-        {                                       \
-            .shift = {                          \
-                .type = TSParseActionTypeShift, \
-                .state = (state_value),         \
-                .repetition = true              \
-            }                                   \
-        }                                       \
-    }
+#define SHIFT_REPEAT(state_value)     \
+  {{                                  \
+    .shift = {                        \
+      .type = TSParseActionTypeShift, \
+      .state = (state_value),         \
+      .repetition = true              \
+    }                                 \
+  }}
 
-#define SHIFT_EXTRA()                           \
-    {                                           \
-        {                                       \
-            .shift = {                          \
-                .type = TSParseActionTypeShift, \
-                .extra = true                   \
-            }                                   \
-        }                                       \
-    }
+#define SHIFT_EXTRA()                 \
+  {{                                  \
+    .shift = {                        \
+      .type = TSParseActionTypeShift, \
+      .extra = true                   \
+    }                                 \
+  }}
 
 #define REDUCE(symbol_name, children, precedence, prod_id) \
-    {                                                      \
-        {                                                  \
-            .reduce = {                                    \
-                .type = TSParseActionTypeReduce,           \
-                .symbol = symbol_name,                     \
-                .child_count = children,                   \
-                .dynamic_precedence = precedence,          \
-                .production_id = prod_id                   \
-            },                                             \
-        }                                                  \
-    }
+  {{                                                       \
+    .reduce = {                                            \
+      .type = TSParseActionTypeReduce,                     \
+      .symbol = symbol_name,                               \
+      .child_count = children,                             \
+      .dynamic_precedence = precedence,                    \
+      .production_id = prod_id                             \
+    },                                                     \
+  }}
 
-#define RECOVER()                            \
-    {                                        \
-        {                                    \
-            .type = TSParseActionTypeRecover \
-        }                                    \
-    }
+#define RECOVER()                    \
+  {{                                 \
+    .type = TSParseActionTypeRecover \
+  }}
 
-#define ACCEPT_INPUT()                      \
-    {                                       \
-        {                                   \
-            .type = TSParseActionTypeAccept \
-        }                                   \
-    }
+#define ACCEPT_INPUT()              \
+  {{                                \
+    .type = TSParseActionTypeAccept \
+  }}
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif // TREE_SITTER_PARSER_H_
+#endif  // TREE_SITTER_PARSER_H_