diff --git a/lsp-server/src/language/ast/deserializer.cpp b/lsp-server/src/language/ast/deserializer.cpp
index 7bc690a..f98a278 100644
--- a/lsp-server/src/language/ast/deserializer.cpp
+++ b/lsp-server/src/language/ast/deserializer.cpp
@@ -1,3 +1,4 @@
+#include <iostream>
 #include "./deserializer.hpp"
 
 extern "C" {
@@ -486,15 +487,7 @@ namespace lsp::language::ast
                      auto result = ParseUsesClause(node, source);
                      return result.IsOk() ? Result<ASTNode>::Ok(std::move(result).Unwrap()) : Result<ASTNode>::Err(result.error, result.severity);
                  } },
-                { "modifier_method", [](TSNode node, const std::string& source) -> Result<ASTNode> {
-                     auto result = ParseExternalMethod(node, source);
-                     return result.IsOk() ? Result<ASTNode>::Ok(std::move(result).Unwrap()) : Result<ASTNode>::Err(result.error, result.severity);
-                 } },
-                { "operator_method", [](TSNode node, const std::string& source) -> Result<ASTNode> {
-                     auto result = ParseExternalMethod(node, source);
-                     return result.IsOk() ? Result<ASTNode>::Ok(std::move(result).Unwrap()) : Result<ASTNode>::Err(result.error, result.severity);
-                 } },
-                { "normal_method", [](TSNode node, const std::string& source) -> Result<ASTNode> {
+                { "external_method_statement", [](TSNode node, const std::string& source) -> Result<ASTNode> {
                      auto result = ParseExternalMethod(node, source);
                      return result.IsOk() ? Result<ASTNode>::Ok(std::move(result).Unwrap()) : Result<ASTNode>::Err(result.error, result.severity);
                  } },
@@ -512,7 +505,7 @@ namespace lsp::language::ast
     Result<FunctionDefinition> ParseFunctionDefinition(TSNode node, const std::string& source)
     {
         std::string node_type = std::string(ts::Type(node));
-        if (node_type != "function_definition_statement" || node_type != "function_definition_statement_with_overload")
+        if (node_type != "function_definition_statement" && node_type != "function_definition_statement_with_overload")
             return Result<FunctionDefinition>::Err("Not a function definition");
 
         FunctionDefinition def;
@@ -535,8 +528,7 @@ namespace lsp::language::ast
         {
             auto block_result = detail::ParseBlock(body_node, source);
             if (block_result.IsErr())
-                return Result<FunctionDefinition>::Err("Failed to extract body: " + block_result.error,
-                                                       block_result.severity);
+                return Result<FunctionDefinition>::Err("Failed to extract body: " + block_result.error, block_result.severity);
             def.body = std::move(block_result).Unwrap();
         }
 
@@ -639,8 +631,7 @@ namespace lsp::language::ast
         {
             auto block_result = detail::ParseBlock(body_node, source);
             if (block_result.IsErr())
-                return Result<Method>::Err("Failed to extract body: " + block_result.error,
-                                           block_result.severity);
+                return Result<Method>::Err("Failed to extract body: " + block_result.error, block_result.severity);
             method.body = std::move(block_result).Unwrap();
         }
 
@@ -651,6 +642,12 @@ namespace lsp::language::ast
     {
         std::string node_type = std::string(ts::Type(node));
 
+        if (node_type == "external_method_statement")
+        {
+            auto result = ParseExternalMethod(ts::Children(node)[0], source);
+            return result.IsOk() ? Result<ExternalMethod>::Ok(std::move(result).Unwrap()) : Result<ExternalMethod>::Err(result.error, result.severity);
+        }
+
         // 检查节点类型
         bool is_modifier = (node_type == "modifier_method");
         bool is_operator = (node_type == "operator_method");