2481 lines
88 KiB
C++
2481 lines
88 KiB
C++
#include <mutex>
|
|
#include "../../utils/string.hpp"
|
|
#include "./tree_sitter_utils.hpp"
|
|
#include "./detail.hpp"
|
|
|
|
namespace lsp::language::ast::detail
|
|
{
|
|
void RegisterStatementParsers()
|
|
{
|
|
static std::once_flag once;
|
|
std::call_once(once, [] {
|
|
auto& registry = StatementParserRegistry::Instance();
|
|
|
|
// 直接注册，不需要适配器
|
|
registry.Register("unit", ParseUnitDefinition);
|
|
registry.Register("var_statement", ParseVarStatement);
|
|
registry.Register("static_statement", ParseStaticStatement);
|
|
registry.Register("global_statement", ParseGlobalStatement);
|
|
registry.Register("const_statement", ParseConstStatement);
|
|
registry.Register("assignment_statement", ParseAssignmentStatement);
|
|
registry.Register("expression_statement", ParseExpressionStatement);
|
|
registry.Register("break_statement", ParseBreakStatement);
|
|
registry.Register("continue_statement", ParseContinueStatement);
|
|
registry.Register("return_statement", ParseReturnStatement);
|
|
registry.Register("uses_statement", ParseUsesStatement);
|
|
registry.Register("inherited_statement", ParseInheritedStatement);
|
|
registry.Register("single_suite", ParseSingleSuite);
|
|
registry.Register("block_suite", ParseBlockSuite);
|
|
registry.Register("if_statement", ParseIfStatement);
|
|
registry.Register("for_in_statement", ParseForInStatement);
|
|
registry.Register("for_to_statement", ParseForToStatement);
|
|
registry.Register("while_statement", ParseWhileStatement);
|
|
registry.Register("repeat_statement", ParseRepeatStatement);
|
|
registry.Register("case_statement", ParseCaseStatement);
|
|
registry.Register("try_statement", ParseTryStatement);
|
|
registry.Register("function_declaration_statement", ParseFunctionDeclaration);
|
|
registry.Register("function_definition_statement", ParseFunctionDefinition);
|
|
registry.Register("function_definition_with_overload_statement", ParseFunctionDefinition);
|
|
registry.Register("class_definition_statement", ParseClassDefinition);
|
|
registry.Register("external_method_statement", ParseExternalMethodStatement);
|
|
registry.Register("matrix_iteration_statement", ParseMatrixIterationStatement);
|
|
|
|
registry.Register("anonymous_function_statement",
|
|
[](TSNode n, ParseContext& ctx) -> StatementPtr {
|
|
auto expr = ParseAnonymousFunctionExpression(n, ctx);
|
|
if (!expr)
|
|
return nullptr;
|
|
Location loc = ts::NodeLocation(n);
|
|
auto stmt = MakeNode<ExpressionStatement>();
|
|
stmt->kind = NodeKind::kExpressionStatement;
|
|
stmt->span = loc;
|
|
stmt->expression = std::move(expr);
|
|
return stmt;
|
|
});
|
|
|
|
registry.Register("tslx_open_tag", ParseTSLXOpenTag);
|
|
registry.Register("tslx_close_tag", ParseTSLXCloseTag);
|
|
registry.Register("tslx_output_tag", ParseTSLXOutputTag);
|
|
registry.Register("tslx_expression_tag", ParseTSLXExpressionTag);
|
|
registry.Register("html_self_closing_tag", ParseHTMLSelfClosingTag);
|
|
registry.Register("html_paired_tag", ParseHTMLPairedTag);
|
|
registry.Register("html_comment", ParseHTMLComment);
|
|
});
|
|
}
|
|
|
|
BinaryOperator ParseBinaryOperator(const std::string& op_text)
|
|
{
|
|
static const std::unordered_map<std::string, BinaryOperator, utils::IHasher, utils::IEqualTo> op_map = {
|
|
// Arithmetic
|
|
{ "+", BinaryOperator::kAdd },
|
|
{ "-", BinaryOperator::kSubtract },
|
|
{ "*", BinaryOperator::kMultiply },
|
|
{ "/", BinaryOperator::kDivide },
|
|
{ "\\", BinaryOperator::kIntDivide },
|
|
{ "%", BinaryOperator::kModulo },
|
|
{ "mod", BinaryOperator::kModulo },
|
|
{ "div", BinaryOperator::kIntDivide },
|
|
{ "^", BinaryOperator::kPower },
|
|
{ "~", BinaryOperator::kLogarithm },
|
|
|
|
// Comparison
|
|
{ "=", BinaryOperator::kEqual },
|
|
{ "<>", BinaryOperator::kNotEqual },
|
|
{ ">", BinaryOperator::kGreater },
|
|
{ ">=", BinaryOperator::kGreaterEqual },
|
|
{ "<", BinaryOperator::kLess },
|
|
{ "<=", BinaryOperator::kLessEqual },
|
|
{ ".=", BinaryOperator::kDotEqual },
|
|
{ ".<>", BinaryOperator::kDotNotEqual },
|
|
{ ".>", BinaryOperator::kDotGreater },
|
|
{ ".>=", BinaryOperator::kDotGreaterEqual },
|
|
{ ".<", BinaryOperator::kDotLess },
|
|
{ ".<=", BinaryOperator::kDotLessEqual },
|
|
{ "like", BinaryOperator::kLike },
|
|
{ "is", BinaryOperator::kIs },
|
|
{ "in", BinaryOperator::kIn },
|
|
|
|
// Logical
|
|
{ "or", BinaryOperator::kLogicalOr },
|
|
{ "and", BinaryOperator::kLogicalAnd },
|
|
{ ".||", BinaryOperator::kDotLogicalOr },
|
|
{ "||", BinaryOperator::kDotLogicalOr },
|
|
{ ".&&", BinaryOperator::kDotLogicalAnd },
|
|
{ "&&", BinaryOperator::kDotLogicalAnd },
|
|
|
|
// Bitwise
|
|
{ ".|", BinaryOperator::kBitwiseOr },
|
|
{ ".&", BinaryOperator::kBitwiseAnd },
|
|
{ ".^", BinaryOperator::kBitwiseXor },
|
|
{ "shl", BinaryOperator::kShl },
|
|
{ "shr", BinaryOperator::kShr },
|
|
{ "rol", BinaryOperator::kRol },
|
|
{ "ror", BinaryOperator::kRor },
|
|
|
|
// Matrix
|
|
{ ":*", BinaryOperator::kMatrixMultiply },
|
|
{ ":/", BinaryOperator::kMatrixDivide },
|
|
{ ":\\", BinaryOperator::kMatrixIntDivide },
|
|
{ ":^", BinaryOperator::kMatrixPower },
|
|
{ ":|", BinaryOperator::kMatrixConcat },
|
|
{ "|", BinaryOperator::kMatrixConcatVertical },
|
|
|
|
// Set
|
|
{ "union", BinaryOperator::kUnion },
|
|
{ "union2", BinaryOperator::kUnion2 },
|
|
{ "intersect", BinaryOperator::kIntersect },
|
|
{ "outersect", BinaryOperator::kOutersect },
|
|
{ "minus", BinaryOperator::kMinus },
|
|
|
|
// Other
|
|
{ "$", BinaryOperator::kConcatenation },
|
|
{ "->", BinaryOperator::kRange },
|
|
};
|
|
|
|
auto it = op_map.find(op_text);
|
|
if (it != op_map.end())
|
|
return it->second;
|
|
|
|
return BinaryOperator::kAdd; // 默认值
|
|
}
|
|
|
|
UnaryOperator ParseUnaryOperator(const std::string& op_text)
|
|
{
|
|
static const std::unordered_map<std::string, UnaryOperator, utils::IHasher, utils::IEqualTo> op_map = {
|
|
{ "+", UnaryOperator::kPlus },
|
|
{ "-", UnaryOperator::kMinus },
|
|
{ "not", UnaryOperator::kNot },
|
|
{ ".!", UnaryOperator::kBitwiseNot },
|
|
{ ".!!", UnaryOperator::kDotNot },
|
|
{ "`", UnaryOperator::kMatrixTranspose },
|
|
{ "!", UnaryOperator::kDerivative },
|
|
{ "@", UnaryOperator::kExprAt },
|
|
{ "&", UnaryOperator::kExprRef },
|
|
};
|
|
|
|
auto it = op_map.find(op_text);
|
|
return it != op_map.end() ? it->second : UnaryOperator::kPlus;
|
|
}
|
|
|
|
AssignmentOperator ParseAssignmentOperator(const std::string& op_text)
|
|
{
|
|
static const std::unordered_map<std::string, AssignmentOperator, utils::IHasher, utils::IEqualTo> op_map = {
|
|
{ ":=", AssignmentOperator::kAssign },
|
|
{ "+=", AssignmentOperator::kAddAssign },
|
|
{ "-=", AssignmentOperator::kSubtractAssign },
|
|
{ "*=", AssignmentOperator::kMultiplyAssign },
|
|
{ "/=", AssignmentOperator::kDivideAssign },
|
|
{ "\\=", AssignmentOperator::kIntDivideAssign },
|
|
{ "^=", AssignmentOperator::kPowerAssign },
|
|
{ "~=", AssignmentOperator::kLogarithmAssign },
|
|
{ "%=", AssignmentOperator::kModuloAssign },
|
|
{ "div=", AssignmentOperator::kDivAssign },
|
|
{ "|=", AssignmentOperator::kBitwiseOrAssign },
|
|
{ "&=", AssignmentOperator::kBitwiseAndAssign },
|
|
{ ":*=", AssignmentOperator::kMatrixMultiplyAssign },
|
|
{ ":/=", AssignmentOperator::kMatrixDivideAssign },
|
|
{ ":\\=", AssignmentOperator::kMatrixIntDivideAssign },
|
|
{ ":^=", AssignmentOperator::kMatrixPowerAssign },
|
|
{ ":|=", AssignmentOperator::kMatrixConcatAssign },
|
|
{ "::=", AssignmentOperator::kConcatAssign },
|
|
{ ".|=", AssignmentOperator::kDotBitwiseOrAssign },
|
|
{ ".&=", AssignmentOperator::kDotBitwiseAndAssign },
|
|
{ ".||=", AssignmentOperator::kDotLogicalOrAssign },
|
|
{ ".&&=", AssignmentOperator::kDotLogicalAndAssign },
|
|
{ ".^=", AssignmentOperator::kDotBitwiseXorAssign },
|
|
{ "union=", AssignmentOperator::kUnionAssign },
|
|
{ "union2=", AssignmentOperator::kUnion2Assign },
|
|
{ "intersect=", AssignmentOperator::kIntersectAssign },
|
|
{ "outersect=", AssignmentOperator::kOutersectAssign },
|
|
{ "minus=", AssignmentOperator::kMinusAssign },
|
|
};
|
|
|
|
auto it = op_map.find(op_text);
|
|
return it != op_map.end() ? it->second : AssignmentOperator::kAssign;
|
|
}
|
|
|
|
// ===== 基础辅助函数 =====
|
|
|
|
bool IsSyntaxErrorNode(TSNode node)
|
|
{
|
|
if (ts_node_is_error(node))
|
|
return true;
|
|
|
|
std::string_view type = ts_node_type(node);
|
|
return type == "ERROR" || type == "MISSING";
|
|
}
|
|
|
|
std::vector<ParseError> CollectSyntaxErrors(TSNode node, std::string_view source)
|
|
{
|
|
std::vector<ParseError> errors;
|
|
|
|
if (IsSyntaxErrorNode(node))
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
std::string type = ts_node_type(node);
|
|
|
|
if (ts_node_is_missing(node))
|
|
{
|
|
errors.push_back(ParseError::Missing(loc, type));
|
|
}
|
|
else
|
|
{
|
|
std::string context;
|
|
TSNode parent = ts_node_parent(node);
|
|
if (!ts_node_is_null(parent))
|
|
context = ts_node_type(parent);
|
|
errors.push_back(ParseError::Unexpected(loc, type, context));
|
|
}
|
|
}
|
|
|
|
uint32_t count = ts_node_child_count(node);
|
|
for (uint32_t i = 0; i < count; i++)
|
|
{
|
|
TSNode child = ts_node_child(node, i);
|
|
auto child_errors = CollectSyntaxErrors(child, source);
|
|
errors.insert(errors.end(),
|
|
std::make_move_iterator(child_errors.begin()),
|
|
std::make_move_iterator(child_errors.end()));
|
|
}
|
|
|
|
return errors;
|
|
}
|
|
|
|
// ===== 通用解析函数 =====
|
|
|
|
Signature ParseSignature(TSNode node, ParseContext& ctx)
|
|
{
|
|
Signature sig;
|
|
|
|
TSNode params_node = ts_node_child_by_field_name(node, "parameters", 10);
|
|
if (!ts_node_is_null(params_node))
|
|
sig.parameters = ParseParameters(params_node, ctx);
|
|
TSNode return_node = ts_node_child_by_field_name(node, "return_type", 11);
|
|
if (!ts_node_is_null(return_node))
|
|
{
|
|
TSNode type_name_node = ts_node_child_by_field_name(return_node, "type_name", 9);
|
|
if (!ts_node_is_null(type_name_node))
|
|
sig.return_type = TypeAnnotation{ .name = ts::Text(type_name_node, ctx.Source()), .location = ts::NodeLocation(type_name_node) };
|
|
}
|
|
|
|
return sig;
|
|
}
|
|
|
|
std::vector<Parameter> ParseParameters(TSNode params_node, ParseContext& ctx)
|
|
{
|
|
std::vector<Parameter> all_params;
|
|
|
|
uint32_t count = ts_node_child_count(params_node);
|
|
for (uint32_t i = 0; i < count; i++)
|
|
{
|
|
const char* field_name = ts_node_field_name_for_child(params_node, i);
|
|
if (!field_name || std::string_view(field_name) != "parameter")
|
|
continue;
|
|
|
|
TSNode param_node = ts_node_child(params_node, i);
|
|
bool is_var = false;
|
|
bool is_out = false;
|
|
|
|
uint32_t param_count = ts_node_child_count(param_node);
|
|
for (uint32_t j = 0; j < param_count; j++)
|
|
{
|
|
TSNode child = ts_node_child(param_node, j);
|
|
std::string text = ts::Text(child, ctx.Source());
|
|
if (text == "var")
|
|
is_var = true;
|
|
if (text == "out")
|
|
is_out = true;
|
|
}
|
|
|
|
for (uint32_t j = 0; j < param_count; j++)
|
|
{
|
|
const char* field = ts_node_field_name_for_child(param_node, j);
|
|
|
|
if (!field || std::string_view(field) != "name")
|
|
continue;
|
|
|
|
TSNode child = ts_node_child(param_node, j);
|
|
|
|
Parameter param;
|
|
param.name = ts::Text(child, ctx.Source());
|
|
param.type = std::nullopt;
|
|
param.is_var = is_var;
|
|
param.is_out = is_out;
|
|
param.location = ts::NodeLocation(child);
|
|
|
|
all_params.push_back(std::move(param));
|
|
}
|
|
|
|
if (!all_params.empty())
|
|
{
|
|
TSNode type_node = ts_node_child_by_field_name(param_node, "type_name", 9);
|
|
if (!ts_node_is_null(type_node))
|
|
all_params.back().type = TypeAnnotation{ .name = ts::Text(type_node, ctx.Source()), .location = ts::NodeLocation(type_node) };
|
|
TSNode default_node = ts_node_child_by_field_name(param_node, "default", 7);
|
|
if (!ts_node_is_null(default_node))
|
|
all_params.back().default_value = ParseExpression(default_node, ctx);
|
|
}
|
|
}
|
|
|
|
return all_params;
|
|
}
|
|
|
|
// ===== 表达式解析 =====
|
|
|
|
ExpressionPtr ParseExpression(TSNode node, ParseContext& ctx)
|
|
{
|
|
std::string_view node_type = ts_node_type(node);
|
|
|
|
if (node_type == "expression")
|
|
{
|
|
uint32_t count = ts_node_child_count(node);
|
|
for (uint32_t i = 0; i < count; i++)
|
|
{
|
|
TSNode child = ts_node_child(node, i);
|
|
if (ts_node_is_named(child))
|
|
return ParseExpression(child, ctx);
|
|
}
|
|
return ctx.ReportNullNode<Expression>(ts::NodeLocation(node), "sub expression");
|
|
}
|
|
|
|
// 二元表达式
|
|
if (node_type == "binary_expression")
|
|
return ParseBinaryExpression(node, ctx);
|
|
|
|
// 一元表达式
|
|
if (node_type == "unary_expression" ||
|
|
node_type == "prefix_increment_expression" ||
|
|
node_type == "prefix_decrement_expression" ||
|
|
node_type == "postfix_increment_expression" ||
|
|
node_type == "postfix_decrement_expression" ||
|
|
node_type == "function_pointer_expression" ||
|
|
node_type == "expr_expression")
|
|
{
|
|
return ParseUnaryExpression(node, ctx);
|
|
}
|
|
|
|
// 三元表达式
|
|
if (node_type == "ternary_expression")
|
|
return ParseTernaryExpression(node, ctx);
|
|
|
|
// 函数调用
|
|
if (node_type == "call")
|
|
return ParseCallExpression(node, ctx);
|
|
|
|
// 属性访问
|
|
if (node_type == "attribute")
|
|
return ParseAttributeExpression(node, ctx);
|
|
|
|
// 下标访问
|
|
if (node_type == "subscript")
|
|
return ParseSubscriptExpression(node, ctx);
|
|
|
|
// 数组
|
|
if (node_type == "array")
|
|
return ParseArrayExpression(node, ctx);
|
|
|
|
// 匿名函数
|
|
if (node_type == "anonymous_function_expression")
|
|
return ParseAnonymousFunctionExpression(node, ctx);
|
|
|
|
// 赋值表达式
|
|
if (node_type == "assignment_expression" || node_type == "augmented_assignment_expression")
|
|
return ParseAssignmentExpression(node, ctx);
|
|
|
|
// 内置表达式
|
|
if (node_type == "echo_expression")
|
|
return ParseEchoExpression(node, ctx);
|
|
if (node_type == "raise_expression")
|
|
return ParseRaiseExpression(node, ctx);
|
|
if (node_type == "new_expression")
|
|
return ParseNewExpression(node, ctx);
|
|
if (node_type == "inherited_expression")
|
|
return ParseInheritedExpression(node, ctx);
|
|
|
|
// TSSQL 选择表达式
|
|
if (node_type == "select_expression" ||
|
|
node_type == "sselect_expression" ||
|
|
node_type == "vselect_expression" ||
|
|
node_type == "mselect_expression" ||
|
|
node_type == "update_expression" ||
|
|
node_type == "delete_expression" ||
|
|
node_type == "insert_expression")
|
|
{
|
|
return ParseTSSQLExpression(node, ctx);
|
|
}
|
|
|
|
// 主表达式(标识符、字面量等)
|
|
return ParsePrimaryExpression(node, ctx);
|
|
}
|
|
|
|
ExpressionPtr ParseTSSQLExpression(TSNode node, ParseContext& ctx)
|
|
{
|
|
std::string_view node_type = ts_node_type(node);
|
|
Location loc = ts::NodeLocation(node);
|
|
|
|
auto expr = MakeNode<TSSQLExpression>();
|
|
expr->span = loc;
|
|
expr->raw_sql = ts::Text(node, ctx.Source());
|
|
|
|
// 根据节点类型设置SQL类型
|
|
if (node_type == "select_expression")
|
|
expr->sql_type = TSSQLExpressionType::kSelect;
|
|
else if (node_type == "sselect_expression")
|
|
expr->sql_type = TSSQLExpressionType::kSSelect;
|
|
else if (node_type == "vselect_expression")
|
|
expr->sql_type = TSSQLExpressionType::kVSelect;
|
|
else if (node_type == "mselect_expression")
|
|
expr->sql_type = TSSQLExpressionType::kMSelect;
|
|
else if (node_type == "update_expression")
|
|
expr->sql_type = TSSQLExpressionType::kUpdate;
|
|
else if (node_type == "delete_expression")
|
|
expr->sql_type = TSSQLExpressionType::kDelete;
|
|
else if (node_type == "insert_expression")
|
|
expr->sql_type = TSSQLExpressionType::kInsert;
|
|
else
|
|
expr->sql_type = TSSQLExpressionType::kSelect;
|
|
|
|
return expr;
|
|
}
|
|
|
|
ExpressionPtr ParseEchoExpression(TSNode node, ParseContext& ctx)
|
|
{
|
|
auto call = MakeNode<CallExpression>();
|
|
call->kind = NodeKind::kCallExpression;
|
|
call->span = ts::NodeLocation(node);
|
|
|
|
TSNode echo_node = ts_node_child(node, 0);
|
|
auto echo_id = MakeNode<Identifier>();
|
|
echo_id->kind = NodeKind::kIdentifier;
|
|
echo_id->span = ts::NodeLocation(echo_node);
|
|
echo_id->name = "echo";
|
|
echo_id->location = ts::NodeLocation(echo_node);
|
|
|
|
call->callee = std::move(echo_id);
|
|
|
|
uint32_t count = ts_node_child_count(node);
|
|
for (uint32_t i = 0; i < count; i++)
|
|
{
|
|
const char* field = ts_node_field_name_for_child(node, i);
|
|
if (!field || std::string_view(field) != "argument")
|
|
continue;
|
|
|
|
auto expr = ParseExpression(ts_node_child(node, i), ctx);
|
|
if (expr)
|
|
{
|
|
CallExpression::Argument arg;
|
|
arg.value = std::move(expr);
|
|
call->arguments.push_back(std::move(arg));
|
|
}
|
|
}
|
|
|
|
return call;
|
|
}
|
|
|
|
ExpressionPtr ParseRaiseExpression(TSNode node, ParseContext& ctx)
|
|
{
|
|
auto call = MakeNode<CallExpression>();
|
|
call->kind = NodeKind::kCallExpression;
|
|
call->span = ts::NodeLocation(node);
|
|
|
|
TSNode raise_node = ts_node_child(node, 0);
|
|
auto raise_id = MakeNode<Identifier>();
|
|
raise_id->kind = NodeKind::kIdentifier;
|
|
raise_id->span = ts::NodeLocation(raise_node);
|
|
raise_id->name = "raise";
|
|
raise_id->location = ts::NodeLocation(raise_node);
|
|
|
|
call->callee = std::move(raise_id);
|
|
|
|
TSNode exception_node = ts_node_child_by_field_name(node, "exception", 9);
|
|
if (!ts_node_is_null(exception_node))
|
|
{
|
|
auto expr = ParseExpression(exception_node, ctx);
|
|
if (expr)
|
|
{
|
|
CallExpression::Argument arg;
|
|
arg.value = std::move(expr);
|
|
call->arguments.push_back(std::move(arg));
|
|
}
|
|
}
|
|
return call;
|
|
}
|
|
|
|
ExpressionPtr ParseNewExpression(TSNode node, ParseContext& ctx)
|
|
{
|
|
auto call = MakeNode<CallExpression>();
|
|
call->kind = NodeKind::kCallExpression;
|
|
call->span = ts::NodeLocation(node);
|
|
|
|
TSNode new_node = ts_node_child(node, 0);
|
|
auto new_id = MakeNode<Identifier>();
|
|
new_id->kind = NodeKind::kIdentifier;
|
|
new_id->span = ts::NodeLocation(new_node);
|
|
new_id->name = "new";
|
|
new_id->location = ts::NodeLocation(new_node);
|
|
|
|
call->callee = std::move(new_id);
|
|
|
|
TSNode exception_node = ts_node_child_by_field_name(node, "class", 5);
|
|
if (!ts_node_is_null(exception_node))
|
|
{
|
|
auto expr = ParseExpression(exception_node, ctx);
|
|
if (expr)
|
|
{
|
|
CallExpression::Argument arg;
|
|
arg.value = std::move(expr);
|
|
call->arguments.push_back(std::move(arg));
|
|
}
|
|
}
|
|
|
|
return call;
|
|
}
|
|
|
|
ExpressionPtr ParseInheritedExpression(TSNode node, ParseContext& ctx)
|
|
{
|
|
auto call = MakeNode<CallExpression>();
|
|
call->kind = NodeKind::kCallExpression;
|
|
call->span = ts::NodeLocation(node);
|
|
|
|
TSNode inherited_node = ts_node_child(node, 0);
|
|
auto inherited_id = MakeNode<Identifier>();
|
|
inherited_id->kind = NodeKind::kIdentifier;
|
|
inherited_id->span = ts::NodeLocation(inherited_node);
|
|
inherited_id->name = "inherited";
|
|
inherited_id->location = ts::NodeLocation(inherited_node);
|
|
|
|
call->callee = std::move(inherited_id);
|
|
|
|
TSNode exception_node = ts_node_child_by_field_name(node, "class", 5);
|
|
if (!ts_node_is_null(exception_node))
|
|
{
|
|
auto expr = ParseExpression(exception_node, ctx);
|
|
if (expr)
|
|
{
|
|
CallExpression::Argument arg;
|
|
arg.value = std::move(expr);
|
|
call->arguments.push_back(std::move(arg));
|
|
}
|
|
}
|
|
|
|
return call;
|
|
}
|
|
|
|
ExpressionPtr ParsePrimaryExpression(TSNode node, ParseContext& ctx)
|
|
{
|
|
std::string_view node_type = ts_node_type(node);
|
|
Location loc = ts::NodeLocation(node);
|
|
|
|
if (node_type == "literal" || node_type == "reserved_keyword")
|
|
{
|
|
uint32_t count = ts_node_child_count(node);
|
|
for (uint32_t i = 0; i < count; i++)
|
|
{
|
|
TSNode child = ts_node_child(node, i);
|
|
if (ts_node_is_named(child))
|
|
return ParsePrimaryExpression(child, ctx);
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
// 标识符
|
|
if (node_type == "identifier" || node_type == "type" ||
|
|
node_type == "class" || node_type == "do")
|
|
{
|
|
std::string name = ts::Text(node, ctx.Source());
|
|
auto id = MakeNode<Identifier>();
|
|
id->kind = NodeKind::kIdentifier;
|
|
id->span = loc;
|
|
|
|
id->name = std::move(name);
|
|
return id;
|
|
}
|
|
|
|
// 字面量
|
|
if (node_type == "number")
|
|
{
|
|
auto lit = MakeNode<Literal>();
|
|
lit->kind = NodeKind::kLiteral;
|
|
lit->span = loc;
|
|
lit->literal_kind = LiteralKind::kNumber;
|
|
lit->name = ts::Text(node, ctx.Source());
|
|
lit->location = loc;
|
|
return lit;
|
|
}
|
|
|
|
if (node_type == "string")
|
|
{
|
|
auto lit = MakeNode<Literal>();
|
|
lit->kind = NodeKind::kLiteral;
|
|
lit->span = loc;
|
|
lit->literal_kind = LiteralKind::kString;
|
|
lit->name = ts::Text(node, ctx.Source());
|
|
lit->location = loc;
|
|
return lit;
|
|
}
|
|
|
|
if (node_type == "boolean")
|
|
{
|
|
auto lit = MakeNode<Literal>();
|
|
lit->kind = NodeKind::kLiteral;
|
|
lit->span = loc;
|
|
lit->literal_kind = LiteralKind::kBoolean;
|
|
lit->name = ts::Text(node, ctx.Source());
|
|
lit->location = loc;
|
|
return lit;
|
|
}
|
|
|
|
if (node_type == "nil")
|
|
{
|
|
auto lit = MakeNode<Literal>();
|
|
lit->kind = NodeKind::kLiteral;
|
|
lit->span = loc;
|
|
lit->literal_kind = LiteralKind::kNil;
|
|
lit->name = "nil";
|
|
lit->location = loc;
|
|
return lit;
|
|
}
|
|
|
|
if (node_type == "infinity")
|
|
{
|
|
auto lit = MakeNode<Literal>();
|
|
lit->kind = NodeKind::kLiteral;
|
|
lit->span = loc;
|
|
lit->literal_kind = LiteralKind::kInfinity;
|
|
lit->name = ts::Text(node, ctx.Source());
|
|
lit->location = loc;
|
|
return lit;
|
|
}
|
|
|
|
if (node_type == "ellipsis")
|
|
{
|
|
auto lit = MakeNode<Literal>();
|
|
lit->kind = NodeKind::kLiteral;
|
|
lit->span = loc;
|
|
lit->literal_kind = LiteralKind::kEllipsis;
|
|
lit->name = "...";
|
|
lit->location = loc;
|
|
return lit;
|
|
}
|
|
|
|
// 默认:创建一个标识符表达式
|
|
std::string text = ts::Text(node, ctx.Source());
|
|
if (!text.empty())
|
|
{
|
|
auto id = MakeNode<Identifier>();
|
|
id->kind = NodeKind::kIdentifier;
|
|
id->span = loc;
|
|
|
|
id->name = std::move(text);
|
|
return id;
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
ExpressionPtr ParseBinaryExpression(TSNode node, ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
|
|
TSNode left_node = ts_node_child_by_field_name(node, "left", 4);
|
|
TSNode right_node = ts_node_child_by_field_name(node, "right", 5);
|
|
TSNode op_node = ts_node_child_by_field_name(node, "operator", 8);
|
|
|
|
if (ts_node_is_null(left_node))
|
|
return ctx.ReportNullNode<Expression>(loc, "left operand");
|
|
|
|
if (ts_node_is_null(right_node))
|
|
return ctx.ReportNullNode<Expression>(loc, "right operand");
|
|
|
|
auto left = ParseExpression(left_node, ctx);
|
|
auto right = ParseExpression(right_node, ctx);
|
|
|
|
if (!left)
|
|
return ctx.ReportParseFailed<Expression>(loc, "binary_expression", "failed to parse left operand");
|
|
|
|
if (!right)
|
|
return ctx.ReportParseFailed<Expression>(loc, "binary_expression", "failed to parse right operand");
|
|
|
|
std::string op_text;
|
|
if (!ts_node_is_null(op_node))
|
|
op_text = ts::Text(op_node, ctx.Source());
|
|
else
|
|
ctx.RecordMissing(loc, "operator");
|
|
|
|
BinaryOperator op = ParseBinaryOperator(op_text);
|
|
|
|
auto expr = MakeNode<BinaryExpression>();
|
|
expr->kind = NodeKind::kBinaryExpression;
|
|
expr->span = loc;
|
|
|
|
expr->op = op;
|
|
expr->left = std::move(left);
|
|
expr->right = std::move(right);
|
|
return expr;
|
|
}
|
|
|
|
ExpressionPtr ParseUnaryExpression(TSNode node, ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
std::string_view node_type = ts_node_type(node);
|
|
|
|
// 前缀自增/自减
|
|
if (node_type == "prefix_increment_expression")
|
|
{
|
|
TSNode arg_node = ts_node_child_by_field_name(node, "argument", 8);
|
|
auto arg = ParseExpression(arg_node, ctx);
|
|
auto expr = MakeNode<PrefixIncrementExpression>();
|
|
expr->kind = NodeKind::kPrefixIncrementExpression;
|
|
expr->span = loc;
|
|
|
|
expr->argument = std::move(arg);
|
|
return expr;
|
|
}
|
|
|
|
if (node_type == "prefix_decrement_expression")
|
|
{
|
|
TSNode arg_node = ts_node_child_by_field_name(node, "argument", 8);
|
|
auto arg = ParseExpression(arg_node, ctx);
|
|
auto expr = MakeNode<PrefixDecrementExpression>();
|
|
expr->kind = NodeKind::kPrefixDecrementExpression;
|
|
expr->span = loc;
|
|
|
|
expr->argument = std::move(arg);
|
|
return expr;
|
|
}
|
|
|
|
// 后缀自增/自减
|
|
if (node_type == "postfix_increment_expression")
|
|
{
|
|
TSNode arg_node = ts_node_child_by_field_name(node, "argument", 8);
|
|
auto arg = ParseExpression(arg_node, ctx);
|
|
auto expr = MakeNode<PostfixIncrementExpression>();
|
|
expr->kind = NodeKind::kPostfixIncrementExpression;
|
|
expr->span = loc;
|
|
|
|
expr->argument = std::move(arg);
|
|
return expr;
|
|
}
|
|
|
|
if (node_type == "postfix_decrement_expression")
|
|
{
|
|
TSNode arg_node = ts_node_child_by_field_name(node, "argument", 8);
|
|
auto arg = ParseExpression(arg_node, ctx);
|
|
auto expr = MakeNode<PostfixDecrementExpression>();
|
|
expr->kind = NodeKind::kPostfixDecrementExpression;
|
|
expr->span = loc;
|
|
|
|
expr->argument = std::move(arg);
|
|
return expr;
|
|
}
|
|
|
|
// 函数指针
|
|
if (node_type == "function_pointer_expression")
|
|
{
|
|
TSNode arg_node = ts_node_child_by_field_name(node, "argument", 8);
|
|
auto arg = ParseExpression(arg_node, ctx);
|
|
auto expr = MakeNode<FunctionPointerExpression>();
|
|
expr->kind = NodeKind::kFunctionPointerExpression;
|
|
expr->span = loc;
|
|
|
|
expr->argument = std::move(arg);
|
|
return expr;
|
|
}
|
|
|
|
// 通用一元表达式
|
|
TSNode op_node = ts_node_child_by_field_name(node, "operator", 8);
|
|
TSNode arg_node = ts_node_child_by_field_name(node, "argument", 8);
|
|
|
|
if (ts_node_is_null(arg_node))
|
|
return ctx.ReportNullNode(ts::NodeLocation(node), "argument");
|
|
|
|
auto arg = ParseExpression(arg_node, ctx);
|
|
if (!arg)
|
|
return ctx.ReportParseFailed(ts::NodeLocation(arg_node), ts_node_type(arg_node), "argument");
|
|
|
|
std::string op_text;
|
|
if (!ts_node_is_null(op_node))
|
|
op_text = ts::Text(op_node, ctx.Source());
|
|
|
|
UnaryOperator op = ParseUnaryOperator(op_text);
|
|
|
|
auto expr = MakeNode<UnaryExpression>();
|
|
expr->kind = NodeKind::kUnaryExpression;
|
|
expr->span = loc;
|
|
|
|
expr->op = op;
|
|
expr->argument = std::move(arg);
|
|
return expr;
|
|
}
|
|
|
|
ExpressionPtr ParseTernaryExpression(TSNode node, ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
|
|
TSNode cond_node = ts_node_child_by_field_name(node, "condition", 9);
|
|
TSNode cons_node = ts_node_child_by_field_name(node, "consequence", 11);
|
|
TSNode alt_node = ts_node_child_by_field_name(node, "alternative", 11);
|
|
|
|
if (ts_node_is_null(cond_node))
|
|
return ctx.ReportNullNode(loc, "condition");
|
|
|
|
if (ts_node_is_null(alt_node))
|
|
return ctx.ReportNullNode(loc, "alternative");
|
|
|
|
auto condition = ParseExpression(cond_node, ctx);
|
|
auto alternative = ParseExpression(alt_node, ctx);
|
|
|
|
ExpressionPtr consequence;
|
|
if (!ts_node_is_null(cons_node))
|
|
consequence = ParseExpression(cons_node, ctx);
|
|
|
|
auto expr = MakeNode<TernaryExpression>();
|
|
expr->kind = NodeKind::kTernaryExpression;
|
|
expr->span = loc;
|
|
|
|
expr->condition = std::move(condition);
|
|
expr->consequence = std::move(consequence);
|
|
expr->alternative = std::move(alternative);
|
|
return expr;
|
|
}
|
|
|
|
ExpressionPtr ParseCallExpression(TSNode node, ParseContext& ctx)
|
|
{
|
|
auto expr = MakeNode<CallExpression>();
|
|
expr->kind = NodeKind::kCallExpression;
|
|
expr->span = ts::NodeLocation(node);
|
|
|
|
TSNode callee_node = ts_node_child_by_field_name(node, "function", 8);
|
|
if (!ts_node_is_null(callee_node))
|
|
{
|
|
auto callee = ParseExpression(callee_node, ctx);
|
|
std::vector<CallExpression::Argument> arguments;
|
|
uint32_t count = ts_node_child_count(node);
|
|
for (uint32_t i = 0; i < count; i++)
|
|
{
|
|
const char* field = ts_node_field_name_for_child(node, i);
|
|
if (!field || std::string_view(field) != "argument")
|
|
continue;
|
|
|
|
TSNode argument_node = ts_node_child(node, i);
|
|
|
|
TSNode child = ts_node_child(argument_node, 0);
|
|
std::string_view child_node_type = ts_node_type(child);
|
|
|
|
CallExpression::Argument arg;
|
|
if (child_node_type == "expression")
|
|
{
|
|
arg.value = ParseExpression(child, ctx);
|
|
}
|
|
else if (child_node_type == "named_argument")
|
|
{
|
|
TSNode name_node = ts_node_child_by_field_name(child, "name", 4);
|
|
if (!ts_node_is_null(name_node))
|
|
{
|
|
arg.name = ts::Text(name_node, ctx.Source());
|
|
arg.location = ts::NodeLocation(name_node);
|
|
}
|
|
|
|
TSNode value_node = ts_node_child_by_field_name(child, "value", 5);
|
|
if (!ts_node_is_null(value_node))
|
|
arg.value = ParseExpression(value_node, ctx);
|
|
}
|
|
arguments.push_back(std::move(arg));
|
|
}
|
|
expr->callee = std::move(callee);
|
|
expr->arguments = std::move(arguments);
|
|
}
|
|
return expr;
|
|
}
|
|
|
|
ExpressionPtr ParseAttributeExpression(TSNode node, ParseContext& ctx)
|
|
{
|
|
auto expr = MakeNode<AttributeExpression>();
|
|
expr->kind = NodeKind::kAttributeExpression;
|
|
expr->span = ts::NodeLocation(node);
|
|
|
|
TSNode obj_node = ts_node_child_by_field_name(node, "object", 6);
|
|
TSNode attr_node = ts_node_child_by_field_name(node, "attribute", 9);
|
|
|
|
if (!ts_node_is_null(obj_node))
|
|
{
|
|
auto object = ParseExpression(obj_node, ctx);
|
|
expr->object = std::move(object);
|
|
}
|
|
if (!ts_node_is_null(attr_node))
|
|
{
|
|
expr->name = ts::Text(attr_node, ctx.Source());
|
|
expr->location = ts::NodeLocation(attr_node);
|
|
}
|
|
return expr;
|
|
}
|
|
|
|
ExpressionPtr ParseSubscriptExpression(TSNode node, ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
|
|
TSNode value_node = ts_node_child_by_field_name(node, "value", 5);
|
|
|
|
if (ts_node_is_null(value_node))
|
|
{
|
|
ctx.RecordMissing(loc, "value");
|
|
return nullptr;
|
|
}
|
|
|
|
auto value = ParseExpression(value_node, ctx);
|
|
|
|
if (!value)
|
|
return nullptr;
|
|
|
|
std::vector<SubscriptExpression::Index> indices;
|
|
|
|
TSNode subscript_node = ts_node_child_by_field_name(node, "subscript", 9);
|
|
if (!ts_node_is_null(subscript_node))
|
|
{
|
|
uint32_t count = ts_node_child_count(subscript_node);
|
|
for (uint32_t i = 0; i < count; i++)
|
|
{
|
|
TSNode idx_node = ts_node_child(subscript_node, i);
|
|
if (!ts_node_is_named(idx_node))
|
|
continue;
|
|
|
|
std::string_view idx_type = ts_node_type(idx_node);
|
|
SubscriptExpression::Index idx;
|
|
|
|
if (idx_type == "slice" || idx_type == "range_slice" ||
|
|
idx_type == "start_slice" || idx_type == "end_slice" ||
|
|
idx_type == "step_slice")
|
|
{
|
|
idx.is_slice = true;
|
|
int part = 0;
|
|
uint32_t count = ts_node_child_count(idx_node);
|
|
for (uint32_t i = 0; i < count; i++)
|
|
{
|
|
TSNode slice_child = ts_node_child(idx_node, i);
|
|
if (!ts_node_is_named(slice_child))
|
|
{
|
|
if (ts::Text(slice_child, ctx.Source()) == ":")
|
|
part++;
|
|
continue;
|
|
}
|
|
|
|
auto expr = ParseExpression(slice_child, ctx);
|
|
if (part == 0)
|
|
idx.start = std::move(expr);
|
|
else if (part == 1)
|
|
idx.end = std::move(expr);
|
|
else if (part == 2)
|
|
idx.step = std::move(expr);
|
|
}
|
|
}
|
|
else if (idx_type == "empty_slice")
|
|
{
|
|
idx.is_empty_slice = true;
|
|
}
|
|
else
|
|
{
|
|
idx.start = ParseExpression(idx_node, ctx);
|
|
}
|
|
|
|
indices.push_back(std::move(idx));
|
|
}
|
|
}
|
|
|
|
auto expr = MakeNode<SubscriptExpression>();
|
|
expr->kind = NodeKind::kSubscriptExpression;
|
|
expr->span = loc;
|
|
|
|
expr->value = std::move(value);
|
|
expr->indices = std::move(indices);
|
|
return expr;
|
|
}
|
|
|
|
ExpressionPtr ParseArrayExpression(TSNode node, ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
std::vector<ArrayExpression::Element> elements;
|
|
|
|
uint32_t count = ts_node_child_count(node);
|
|
for (uint32_t i = 0; i < count; i++)
|
|
{
|
|
TSNode child = ts_node_child(node, i);
|
|
if (!ts_node_is_named(child))
|
|
continue;
|
|
|
|
std::string_view child_type = ts_node_type(child);
|
|
|
|
if (child_type == "array_element" || child_type == "key_value_pair")
|
|
{
|
|
ArrayExpression::Element elem;
|
|
|
|
TSNode key_node = ts_node_child_by_field_name(child, "key", 3);
|
|
TSNode value_node = ts_node_child_by_field_name(child, "value", 5);
|
|
|
|
if (!ts_node_is_null(key_node))
|
|
{
|
|
elem.key = ParseExpression(key_node, ctx);
|
|
}
|
|
|
|
if (!ts_node_is_null(value_node))
|
|
{
|
|
elem.value = ParseExpression(value_node, ctx);
|
|
}
|
|
else if (ts_node_is_null(key_node))
|
|
{
|
|
elem.value = ParseExpression(child, ctx);
|
|
}
|
|
|
|
elements.push_back(std::move(elem));
|
|
}
|
|
else if (child_type == "parenthesized_array")
|
|
{
|
|
ArrayExpression::Element elem;
|
|
elem.is_nested = true;
|
|
elem.value = ParseArrayExpression(child, ctx);
|
|
elements.push_back(std::move(elem));
|
|
}
|
|
}
|
|
|
|
auto expr = MakeNode<ArrayExpression>();
|
|
expr->kind = NodeKind::kArrayExpression;
|
|
expr->span = loc;
|
|
|
|
expr->elements = std::move(elements);
|
|
return expr;
|
|
}
|
|
|
|
ExpressionPtr ParseAnonymousFunctionExpression(TSNode node, ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
|
|
Signature sig = ParseSignature(node, ctx);
|
|
|
|
TSNode body_node = ts_node_child_by_field_name(node, "body", 4);
|
|
auto body = ParseBlockSuite(body_node, ctx);
|
|
|
|
auto expr = MakeNode<AnonymousFunctionExpression>();
|
|
expr->kind = NodeKind::kAnonymousFunctionExpression;
|
|
expr->span = loc;
|
|
|
|
expr->signature = std::move(sig);
|
|
expr->body = std::move(body);
|
|
return expr;
|
|
}
|
|
|
|
// ===== 左值解析(用于赋值语句) =====
|
|
|
|
LeftHandSide ParseLeftHandSide(TSNode node, ParseContext& ctx)
|
|
{
|
|
if (ts_node_is_null(node))
|
|
{
|
|
auto id = MakeNode<Identifier>();
|
|
id->kind = NodeKind::kIdentifier;
|
|
id->span = ts::NodeLocation(node);
|
|
|
|
id->name = "";
|
|
return id;
|
|
}
|
|
|
|
std::string_view node_type = ts_node_type(node);
|
|
|
|
// 标识符
|
|
if (node_type == "identifier" || node_type == "type" ||
|
|
node_type == "class" || node_type == "do")
|
|
{
|
|
std::string name = ts::Text(node, ctx.Source());
|
|
Location loc = ts::NodeLocation(node);
|
|
auto id = MakeNode<Identifier>();
|
|
id->kind = NodeKind::kIdentifier;
|
|
id->span = loc;
|
|
|
|
id->name = std::move(name);
|
|
return id;
|
|
}
|
|
|
|
// 属性访问
|
|
if (node_type == "attribute")
|
|
{
|
|
return std::unique_ptr<AttributeExpression>(
|
|
static_cast<AttributeExpression*>(ParseAttributeExpression(node, ctx).release()));
|
|
}
|
|
|
|
// 下标访问
|
|
if (node_type == "subscript")
|
|
{
|
|
return std::unique_ptr<SubscriptExpression>(
|
|
static_cast<SubscriptExpression*>(ParseSubscriptExpression(node, ctx).release()));
|
|
}
|
|
|
|
// 解包模式
|
|
if (node_type == "unpack_pattern")
|
|
{
|
|
return ParseUnpackPattern(node, ctx);
|
|
}
|
|
|
|
auto id = MakeNode<Identifier>();
|
|
id->kind = NodeKind::kIdentifier;
|
|
id->span = ts::NodeLocation(node);
|
|
|
|
id->name = ts::Text(node, ctx.Source());
|
|
return id;
|
|
}
|
|
|
|
std::unique_ptr<UnpackPattern> ParseUnpackPattern(TSNode node, ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
std::vector<std::string> names;
|
|
|
|
uint32_t count = ts_node_child_count(node);
|
|
for (uint32_t i = 0; i < count; i++)
|
|
{
|
|
const char* field = ts_node_field_name_for_child(node, i);
|
|
if (field && std::string_view(field) == "name")
|
|
names.push_back(ts::Text(ts_node_child(node, i), ctx.Source()));
|
|
}
|
|
|
|
auto pattern = MakeNode<UnpackPattern>();
|
|
pattern->kind = NodeKind::kUnpackPattern;
|
|
pattern->span = loc;
|
|
|
|
pattern->names = std::move(names);
|
|
return pattern;
|
|
}
|
|
|
|
// ===== 语句解析 =====
|
|
|
|
StatementPtr ParseStatement(TSNode node, ParseContext& ctx)
|
|
{
|
|
if (ts_node_is_null(node))
|
|
return nullptr;
|
|
|
|
std::string node_type = ts_node_type(node);
|
|
|
|
// 查找注册的解析器
|
|
auto parser = StatementParserRegistry::Instance().Get(node_type);
|
|
if (parser)
|
|
return parser(node, ctx);
|
|
|
|
// 默认作为表达式语句处理
|
|
return ParseExpressionStatement(node, ctx);
|
|
}
|
|
|
|
StatementPtr ParseSingleSuite(TSNode node, ParseContext& ctx)
|
|
{
|
|
TSNode child = ts_node_child(node, 0);
|
|
std::string node_type = ts_node_type(child);
|
|
auto parser = StatementParserRegistry::Instance().Get(node_type);
|
|
if (parser)
|
|
return parser(child, ctx);
|
|
return nullptr;
|
|
}
|
|
|
|
StatementPtr ParseBlockSuite(TSNode node, ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
std::vector<StatementPtr> statements;
|
|
|
|
uint32_t count = ts_node_child_count(node);
|
|
for (uint32_t i = 0; i < count; i++)
|
|
{
|
|
TSNode child = ts_node_child(node, i);
|
|
|
|
if (!ts_node_is_named(child))
|
|
continue;
|
|
|
|
if (ts::IsComment(child))
|
|
continue;
|
|
|
|
auto stmt = ParseStatement(child, ctx);
|
|
if (stmt)
|
|
statements.push_back(std::move(stmt));
|
|
}
|
|
|
|
auto block = MakeNode<BlockStatement>();
|
|
block->kind = NodeKind::kBlockStatement;
|
|
block->span = loc;
|
|
|
|
block->statements = std::move(statements);
|
|
return block;
|
|
}
|
|
|
|
StatementPtr ParseExpressionStatement(TSNode node, ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
|
|
ExpressionPtr expr = nullptr;
|
|
uint32_t count = ts_node_child_count(node);
|
|
for (uint32_t i = 0; i < count; i++)
|
|
{
|
|
TSNode child = ts_node_child(node, i);
|
|
if (ts_node_is_named(child))
|
|
{
|
|
expr = ParseExpression(child, ctx);
|
|
break;
|
|
}
|
|
}
|
|
if (!expr)
|
|
return nullptr;
|
|
|
|
auto stmt = MakeNode<ExpressionStatement>();
|
|
stmt->kind = NodeKind::kExpressionStatement;
|
|
stmt->span = loc;
|
|
|
|
stmt->expression = std::move(expr);
|
|
return stmt;
|
|
}
|
|
|
|
ExpressionPtr ParseAssignmentExpression(TSNode node, ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
|
|
TSNode left_node = ts_node_child_by_field_name(node, "left", 4);
|
|
TSNode op_node = ts_node_child_by_field_name(node, "operator", 8);
|
|
TSNode right_node = ts_node_child_by_field_name(node, "right", 5);
|
|
|
|
if (ts_node_is_null(left_node) || ts_node_is_null(right_node))
|
|
return nullptr;
|
|
|
|
LeftHandSide left = ParseLeftHandSide(left_node, ctx);
|
|
|
|
AssignmentOperator op = AssignmentOperator::kAssign;
|
|
if (!ts_node_is_null(op_node))
|
|
{
|
|
std::string op_text = ts::Text(op_node, ctx.Source());
|
|
op = ParseAssignmentOperator(op_text);
|
|
}
|
|
|
|
auto right = ParseExpression(right_node, ctx);
|
|
if (!right)
|
|
return nullptr;
|
|
|
|
auto expr = MakeNode<AssignmentExpression>();
|
|
expr->kind = NodeKind::kAssignmentExpression;
|
|
expr->span = loc;
|
|
|
|
expr->left = std::move(left);
|
|
expr->op = op;
|
|
expr->right = std::move(right);
|
|
return expr;
|
|
}
|
|
|
|
StatementPtr ParseAssignmentStatement(TSNode node, ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
|
|
TSNode left_node = ts_node_child_by_field_name(node, "left", 4);
|
|
TSNode op_node = ts_node_child_by_field_name(node, "operator", 8);
|
|
TSNode right_node = ts_node_child_by_field_name(node, "right", 5);
|
|
|
|
if (ts_node_is_null(left_node))
|
|
{
|
|
uint32_t count = ts_node_child_count(node);
|
|
for (uint32_t i = 0; i < count; i++)
|
|
{
|
|
TSNode child = ts_node_child(node, i);
|
|
std::string_view child_type = ts_node_type(child);
|
|
if (child_type == "assignment_expression" || child_type == "augmented_assignment_expression")
|
|
{
|
|
left_node = ts_node_child_by_field_name(child, "left", 4);
|
|
op_node = ts_node_child_by_field_name(child, "operator", 8);
|
|
right_node = ts_node_child_by_field_name(child, "right", 5);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ts_node_is_null(left_node) || ts_node_is_null(right_node))
|
|
return nullptr;
|
|
|
|
LeftHandSide left = ParseLeftHandSide(left_node, ctx);
|
|
|
|
AssignmentOperator op = AssignmentOperator::kAssign;
|
|
if (!ts_node_is_null(op_node))
|
|
{
|
|
std::string op_text = ts::Text(op_node, ctx.Source());
|
|
op = ParseAssignmentOperator(op_text);
|
|
}
|
|
|
|
auto right = ParseExpression(right_node, ctx);
|
|
if (!right)
|
|
return nullptr;
|
|
|
|
auto stmt = MakeNode<AssignmentStatement>();
|
|
stmt->kind = NodeKind::kAssignmentStatement;
|
|
stmt->span = loc;
|
|
|
|
stmt->left = std::move(left);
|
|
stmt->op = op;
|
|
stmt->right = std::move(right);
|
|
return stmt;
|
|
}
|
|
|
|
// ===== 通用声明解析模板 =====
|
|
|
|
template<typename DeclType, typename StmtType>
|
|
StatementPtr ParseDeclarationStatement(TSNode node, ParseContext& ctx, NodeKind decl_kind, NodeKind stmt_kind)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
std::vector<std::unique_ptr<DeclType>> declarations;
|
|
|
|
TSNode decl_node = ts_node_child_by_field_name(node, "declaration", 11);
|
|
if (!ts_node_is_null(decl_node))
|
|
{
|
|
uint32_t count = ts_node_child_count(decl_node);
|
|
for (uint32_t i = 0; i < count; i++)
|
|
{
|
|
const char* field = ts_node_field_name_for_child(decl_node, i);
|
|
if (!field || std::string_view(field) != "name")
|
|
continue;
|
|
TSNode name_node = ts_node_child(decl_node, i);
|
|
|
|
std::string name = ts::Text(name_node, ctx.Source());
|
|
Location name_loc = ts::NodeLocation(name_node);
|
|
|
|
auto decl = MakeNode<DeclType>();
|
|
decl->kind = decl_kind;
|
|
decl->span = name_loc;
|
|
|
|
decl->name = std::move(name);
|
|
decl->type = std::nullopt;
|
|
decl->initial_value = nullptr;
|
|
declarations.push_back(std::move(decl));
|
|
}
|
|
|
|
TSNode initial_node = ts_node_child_by_field_name(decl_node, "initial_value", 13);
|
|
if (!ts_node_is_null(initial_node))
|
|
declarations.back()->initial_value = ParseExpression(initial_node, ctx);
|
|
|
|
TSNode type_node = ts_node_child_by_field_name(decl_node, "type_name", 9);
|
|
if (!declarations.empty() && !ts_node_is_null(type_node))
|
|
declarations.back()->type = TypeAnnotation{ .name = ts::Text(type_node, ctx.Source()), .location = ts::NodeLocation(type_node) };
|
|
}
|
|
|
|
auto stmt = MakeNode<StmtType>();
|
|
stmt->kind = stmt_kind;
|
|
stmt->span = loc;
|
|
stmt->declarations = std::move(declarations);
|
|
return stmt;
|
|
}
|
|
|
|
StatementPtr ParseVarStatement(TSNode node, ParseContext& ctx)
|
|
{
|
|
return ParseDeclarationStatement<VarDeclaration, VarStatement>(
|
|
node, ctx, NodeKind::kVarDeclaration, NodeKind::kVarStatement);
|
|
}
|
|
|
|
StatementPtr ParseStaticStatement(TSNode node, ParseContext& ctx)
|
|
{
|
|
return ParseDeclarationStatement<StaticDeclaration, StaticStatement>(
|
|
node, ctx, NodeKind::kStaticDeclaration, NodeKind::kStaticStatement);
|
|
}
|
|
|
|
StatementPtr ParseGlobalStatement(TSNode node, ParseContext& ctx)
|
|
{
|
|
return ParseDeclarationStatement<GlobalDeclaration, GlobalStatement>(
|
|
node, ctx, NodeKind::kGlobalDeclaration, NodeKind::kGlobalStatement);
|
|
}
|
|
|
|
StatementPtr ParseConstStatement(TSNode node, ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
|
|
TSNode name_node = ts_node_child_by_field_name(node, "name", 4);
|
|
std::string name = ts_node_is_null(name_node) ? "" : ts::Text(name_node, ctx.Source());
|
|
|
|
std::optional<std::string> type_name;
|
|
TSNode type_node = ts_node_child_by_field_name(node, "type_name", 9);
|
|
if (!ts_node_is_null(type_node))
|
|
{
|
|
type_name = ts::Text(type_node, ctx.Source());
|
|
}
|
|
|
|
TSNode value_node = ts_node_child_by_field_name(node, "value", 5);
|
|
auto value = ParseExpression(value_node, ctx);
|
|
|
|
auto stmt = MakeNode<ConstStatement>();
|
|
stmt->kind = NodeKind::kConstStatement;
|
|
stmt->span = loc;
|
|
|
|
stmt->name = std::move(name);
|
|
stmt->type_name = type_name;
|
|
stmt->value = std::move(value);
|
|
return stmt;
|
|
}
|
|
|
|
StatementPtr ParseIfStatement(TSNode node, ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
std::vector<IfStatement::Branch> branches;
|
|
|
|
uint32_t count = ts_node_child_count(node);
|
|
for (uint32_t i = 0; i < count; i++)
|
|
{
|
|
TSNode child = ts_node_child(node, i);
|
|
std::string_view node_type = ts_node_type(child);
|
|
if (node_type == "if_clause")
|
|
{
|
|
IfStatement::Branch branch;
|
|
|
|
TSNode cond_node = ts_node_child_by_field_name(child, "condition", 9);
|
|
branch.condition = ParseExpression(cond_node, ctx);
|
|
TSNode cons_node = ts_node_child_by_field_name(child, "consequence", 11);
|
|
branch.body = ParseStatement(cons_node, ctx);
|
|
|
|
branches.push_back(std::move(branch));
|
|
}
|
|
else if (node_type == "else_if_clause")
|
|
{
|
|
IfStatement::Branch branch;
|
|
TSNode cond_node = ts_node_child_by_field_name(child, "condition", 9);
|
|
branch.condition = ParseExpression(cond_node, ctx);
|
|
|
|
TSNode cons_node = ts_node_child_by_field_name(child, "consequence", 11);
|
|
branch.body = ParseStatement(cons_node, ctx);
|
|
|
|
branches.push_back(std::move(branch));
|
|
}
|
|
else if (node_type == "else_clause")
|
|
{
|
|
IfStatement::Branch branch;
|
|
branch.condition = nullptr;
|
|
|
|
TSNode cons_node = ts_node_child_by_field_name(child, "consequence", 11);
|
|
branch.body = ParseStatement(cons_node, ctx);
|
|
|
|
branches.push_back(std::move(branch));
|
|
}
|
|
}
|
|
|
|
auto stmt = MakeNode<IfStatement>();
|
|
stmt->kind = NodeKind::kIfStatement;
|
|
stmt->span = loc;
|
|
|
|
stmt->branches = std::move(branches);
|
|
return stmt;
|
|
}
|
|
|
|
StatementPtr ParseForInStatement(TSNode node, ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
|
|
TSNode key_node = ts_node_child_by_field_name(node, "key", 3);
|
|
TSNode value_node = ts_node_child_by_field_name(node, "value", 5);
|
|
TSNode collection_node = ts_node_child_by_field_name(node, "collection", 10);
|
|
TSNode body_node = ts_node_child_by_field_name(node, "body", 4);
|
|
|
|
std::string key = ts_node_is_null(key_node) ? "" : ts::Text(key_node, ctx.Source());
|
|
std::string value = ts_node_is_null(value_node) ? "" : ts::Text(value_node, ctx.Source());
|
|
auto collection = ParseExpression(collection_node, ctx);
|
|
auto body = ParseStatement(body_node, ctx);
|
|
|
|
auto stmt = MakeNode<ForInStatement>();
|
|
stmt->kind = NodeKind::kForInStatement;
|
|
stmt->span = loc;
|
|
|
|
stmt->key = std::move(key);
|
|
stmt->value = std::move(value);
|
|
stmt->collection = std::move(collection);
|
|
stmt->body = std::move(body);
|
|
return stmt;
|
|
}
|
|
|
|
StatementPtr ParseForToStatement(TSNode node, ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
|
|
TSNode counter_node = ts_node_child_by_field_name(node, "counter", 7);
|
|
TSNode start_node = ts_node_child_by_field_name(node, "start", 5);
|
|
TSNode end_node = ts_node_child_by_field_name(node, "end", 3);
|
|
TSNode direction_node = ts_node_child_by_field_name(node, "direction", 9);
|
|
TSNode body_node = ts_node_child_by_field_name(node, "body", 4);
|
|
|
|
std::string counter = ts_node_is_null(counter_node) ? "" : ts::Text(counter_node, ctx.Source());
|
|
auto start = ParseExpression(start_node, ctx);
|
|
auto end = ParseExpression(end_node, ctx);
|
|
|
|
bool is_downto = false;
|
|
if (!ts_node_is_null(direction_node))
|
|
{
|
|
std::string direction = ts::Text(direction_node, ctx.Source());
|
|
is_downto = (direction == "downto");
|
|
}
|
|
|
|
auto body = ParseStatement(body_node, ctx);
|
|
|
|
auto stmt = MakeNode<ForToStatement>();
|
|
stmt->kind = NodeKind::kForToStatement;
|
|
stmt->span = loc;
|
|
|
|
stmt->counter = std::move(counter);
|
|
stmt->start = std::move(start);
|
|
stmt->end = std::move(end);
|
|
stmt->is_downto = is_downto;
|
|
stmt->body = std::move(body);
|
|
return stmt;
|
|
}
|
|
|
|
StatementPtr ParseWhileStatement(TSNode node, ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
|
|
TSNode condition_node = ts_node_child_by_field_name(node, "condition", 9);
|
|
TSNode body_node = ts_node_child_by_field_name(node, "body", 4);
|
|
|
|
auto condition = ParseExpression(condition_node, ctx);
|
|
auto body = ParseStatement(body_node, ctx);
|
|
|
|
auto stmt = MakeNode<WhileStatement>();
|
|
stmt->kind = NodeKind::kWhileStatement;
|
|
stmt->span = loc;
|
|
|
|
stmt->condition = std::move(condition);
|
|
stmt->body = std::move(body);
|
|
return stmt;
|
|
}
|
|
|
|
StatementPtr ParseRepeatStatement(TSNode node, ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
|
|
TSNode condition_node = ts_node_child_by_field_name(node, "condition", 9);
|
|
|
|
std::vector<StatementPtr> body_statements;
|
|
std::string name = "body";
|
|
uint32_t count = ts_node_child_count(node);
|
|
for (uint32_t i = 0; i < count; i++)
|
|
{
|
|
const char* field = ts_node_field_name_for_child(node, i);
|
|
if (!field || std::string_view(field) != "body")
|
|
continue;
|
|
TSNode child = ts_node_child(node, i);
|
|
|
|
auto stmt = ParseStatement(child, ctx);
|
|
if (stmt)
|
|
body_statements.push_back(std::move(stmt));
|
|
}
|
|
|
|
auto condition = ParseExpression(condition_node, ctx);
|
|
|
|
auto stmt = MakeNode<RepeatStatement>();
|
|
stmt->kind = NodeKind::kRepeatStatement;
|
|
stmt->span = loc;
|
|
|
|
stmt->body = std::move(body_statements);
|
|
stmt->condition = std::move(condition);
|
|
return stmt;
|
|
}
|
|
|
|
StatementPtr ParseCaseStatement(TSNode node, ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
|
|
TSNode discriminant_node = ts_node_child_by_field_name(node, "discriminant", 12);
|
|
auto discriminant = ParseExpression(discriminant_node, ctx);
|
|
|
|
std::vector<CaseStatement::Branch> branches;
|
|
|
|
uint32_t count = ts_node_child_count(node);
|
|
for (uint32_t i = 0; i < count; i++)
|
|
{
|
|
const char* field = ts_node_field_name_for_child(node, i);
|
|
if (!field || std::string_view(field) != "branches")
|
|
continue;
|
|
TSNode branch_node = ts_node_child(node, i);
|
|
|
|
CaseStatement::Branch branch;
|
|
|
|
std::string value = "value";
|
|
uint32_t branch_count = ts_node_child_count(branch_node);
|
|
for (uint32_t j = 0; j < branch_count; j++)
|
|
{
|
|
const char* field = ts_node_field_name_for_child(branch_node, j);
|
|
if (!field || value != field)
|
|
continue;
|
|
|
|
TSNode value_node = ts_node_child(branch_node, j);
|
|
auto value = ParseExpression(value_node, ctx);
|
|
if (value)
|
|
branch.values.push_back(std::move(value));
|
|
}
|
|
|
|
TSNode cons_node = ts_node_child_by_field_name(branch_node, "consequence", 11);
|
|
branch.body = ParseStatement(cons_node, ctx);
|
|
|
|
branches.push_back(std::move(branch));
|
|
}
|
|
|
|
StatementPtr default_case = nullptr;
|
|
TSNode default_node = ts_node_child_by_field_name(node, "default", 7);
|
|
if (!ts_node_is_null(default_node))
|
|
{
|
|
auto cons_node = ts_node_child_by_field_name(default_node, "consequence", 11);
|
|
default_case = ParseStatement(cons_node, ctx);
|
|
}
|
|
|
|
auto stmt = MakeNode<CaseStatement>();
|
|
stmt->kind = NodeKind::kCaseStatement;
|
|
stmt->span = loc;
|
|
|
|
stmt->discriminant = std::move(discriminant);
|
|
stmt->branches = std::move(branches);
|
|
stmt->default_case = std::move(default_case);
|
|
return stmt;
|
|
}
|
|
|
|
StatementPtr ParseTryStatement(TSNode node, ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
|
|
TSNode try_body_node = ts_node_child_by_field_name(node, "try_body", 8);
|
|
TSNode except_body_node = ts_node_child_by_field_name(node, "except_body", 11);
|
|
|
|
auto try_body = ParseStatement(try_body_node, ctx);
|
|
auto except_body = ParseStatement(except_body_node, ctx);
|
|
|
|
auto stmt = MakeNode<TryStatement>();
|
|
stmt->kind = NodeKind::kTryStatement;
|
|
stmt->span = loc;
|
|
|
|
stmt->try_body = std::move(try_body);
|
|
stmt->except_body = std::move(except_body);
|
|
return stmt;
|
|
}
|
|
|
|
StatementPtr ParseBreakStatement(TSNode node, [[maybe_unused]] ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
auto stmt = MakeNode<BreakStatement>();
|
|
stmt->kind = NodeKind::kBreakStatement;
|
|
stmt->span = loc;
|
|
|
|
return stmt;
|
|
}
|
|
|
|
StatementPtr ParseContinueStatement(TSNode node, [[maybe_unused]] ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
auto stmt = MakeNode<ContinueStatement>();
|
|
stmt->kind = NodeKind::kContinueStatement;
|
|
stmt->span = loc;
|
|
|
|
return stmt;
|
|
}
|
|
|
|
StatementPtr ParseReturnStatement(TSNode node, ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
|
|
auto stmt = MakeNode<ReturnStatement>();
|
|
stmt->kind = NodeKind::kReturnStatement;
|
|
stmt->span = loc;
|
|
|
|
TSNode value_node = ts_node_child_by_field_name(node, "value", 5);
|
|
if (!ts_node_is_null(value_node))
|
|
{
|
|
auto value = ParseExpression(value_node, ctx);
|
|
stmt->value = std::move(value);
|
|
}
|
|
|
|
return stmt;
|
|
}
|
|
|
|
StatementPtr ParseUsesStatement(TSNode node, ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
|
|
auto uses = MakeNode<UsesStatement>();
|
|
uses->kind = NodeKind::kUsesStatement;
|
|
uses->span = loc;
|
|
|
|
uint32_t count = ts_node_child_count(node);
|
|
for (uint32_t i = 0; i < count; i++)
|
|
{
|
|
const char* field = ts_node_field_name_for_child(node, i);
|
|
if (!field || std::string_view(field) != "units")
|
|
continue;
|
|
|
|
TSNode child = ts_node_child(node, i);
|
|
uses->units.push_back(std::move(ts::Text(child, ctx.Source())));
|
|
}
|
|
return uses;
|
|
}
|
|
|
|
StatementPtr ParseInheritedStatement(TSNode node, ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
ExpressionPtr expr = nullptr;
|
|
|
|
TSNode class_node = ts_node_child_by_field_name(node, "class", 5);
|
|
if (!ts_node_is_null(class_node))
|
|
expr = ParseExpression(class_node, ctx);
|
|
|
|
auto stmt = MakeNode<ExpressionStatement>();
|
|
stmt->kind = NodeKind::kExpressionStatement;
|
|
stmt->span = loc;
|
|
|
|
stmt->expression = std::move(expr);
|
|
return stmt;
|
|
}
|
|
|
|
StatementPtr ParseFunctionDeclaration(TSNode node, ParseContext& ctx)
|
|
{
|
|
auto stmt = MakeNode<FunctionDeclaration>();
|
|
stmt->kind = NodeKind::kFunctionDeclaration;
|
|
stmt->span = ts::NodeLocation(node);
|
|
TSNode name_node = ts_node_child_by_field_name(node, "name", 4);
|
|
if (!ts_node_is_null(name_node))
|
|
{
|
|
stmt->name = ts::Text(name_node, ctx.Source());
|
|
stmt->location = ts::NodeLocation(name_node);
|
|
}
|
|
|
|
Signature sig = ParseSignature(node, ctx);
|
|
stmt->signature = std::move(sig);
|
|
|
|
return stmt;
|
|
}
|
|
|
|
StatementPtr ParseFunctionDefinition(TSNode node, ParseContext& ctx)
|
|
{
|
|
auto stmt = MakeNode<FunctionDefinition>();
|
|
stmt->kind = NodeKind::kFunctionDefinition;
|
|
stmt->span = ts::NodeLocation(node);
|
|
|
|
TSNode name_node = ts_node_child_by_field_name(node, "name", 4);
|
|
if (!ts_node_is_null(name_node))
|
|
{
|
|
std::string name = ts::Text(name_node, ctx.Source());
|
|
stmt->name = std::move(name);
|
|
stmt->location = ts::NodeLocation(name_node);
|
|
}
|
|
|
|
Signature sig = ParseSignature(node, ctx);
|
|
|
|
TSNode body_node = ts_node_child_by_field_name(node, "body", 4);
|
|
auto body = ParseStatement(body_node, ctx);
|
|
|
|
std::string_view node_type = ts_node_type(node);
|
|
bool is_overload = (node_type == "function_definition_with_overload_statement");
|
|
|
|
stmt->signature = std::move(sig);
|
|
stmt->body = std::move(body);
|
|
stmt->is_overload = is_overload;
|
|
return stmt;
|
|
}
|
|
|
|
StatementPtr ParseMatrixIterationStatement(TSNode node, ParseContext& ctx)
|
|
{
|
|
auto stmt = MakeNode<WhileStatement>();
|
|
stmt->kind = NodeKind::kWhileStatement;
|
|
stmt->span = ts::NodeLocation(node);
|
|
|
|
TSNode target_node = ts_node_child_by_field_name(node, "target", 6);
|
|
TSNode body_node = ts_node_child_by_field_name(node, "body", 4);
|
|
|
|
auto target = ParseExpression(target_node, ctx);
|
|
auto body = ParseStatement(body_node, ctx);
|
|
stmt->condition = std::move(target);
|
|
stmt->body = std::move(body);
|
|
return stmt;
|
|
}
|
|
|
|
// ===== TSLX 模板解析 =====
|
|
|
|
StatementPtr ParseTSLXOpenTag(TSNode node, [[maybe_unused]] ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
auto block = MakeNode<BlockStatement>();
|
|
block->kind = NodeKind::kBlockStatement;
|
|
block->span = loc;
|
|
|
|
return block;
|
|
}
|
|
|
|
StatementPtr ParseTSLXCloseTag(TSNode node, [[maybe_unused]] ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
auto block = MakeNode<BlockStatement>();
|
|
block->kind = NodeKind::kBlockStatement;
|
|
block->span = loc;
|
|
|
|
return block;
|
|
}
|
|
|
|
StatementPtr ParseTSLXOutputTag(TSNode node, ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
|
|
std::vector<ExpressionPtr> expressions;
|
|
uint32_t count = ts_node_child_count(node);
|
|
for (uint32_t i = 0; i < count; i++)
|
|
{
|
|
TSNode child = ts_node_child(node, i);
|
|
if (!ts_node_is_named(child))
|
|
continue;
|
|
|
|
auto expr = ParseExpression(child, ctx);
|
|
if (expr)
|
|
expressions.push_back(std::move(expr));
|
|
}
|
|
|
|
auto block = MakeNode<BlockStatement>();
|
|
block->kind = NodeKind::kBlockStatement;
|
|
block->span = loc;
|
|
|
|
for (auto& expr : expressions)
|
|
{
|
|
auto expr_stmt = MakeNode<ExpressionStatement>();
|
|
expr_stmt->kind = NodeKind::kExpressionStatement;
|
|
expr_stmt->span = expr->span;
|
|
|
|
expr_stmt->expression = std::move(expr);
|
|
block->statements.push_back(std::move(expr_stmt));
|
|
}
|
|
|
|
return block;
|
|
}
|
|
|
|
StatementPtr ParseTSLXExpressionTag(TSNode node, ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
|
|
std::vector<StatementPtr> statements;
|
|
uint32_t count = ts_node_child_count(node);
|
|
for (uint32_t i = 0; i < count; i++)
|
|
{
|
|
TSNode child = ts_node_child(node, i);
|
|
if (!ts_node_is_named(child))
|
|
continue;
|
|
|
|
if (ts::IsComment(child))
|
|
continue;
|
|
|
|
auto stmt = ParseStatement(child, ctx);
|
|
if (stmt)
|
|
statements.push_back(std::move(stmt));
|
|
}
|
|
|
|
auto block = MakeNode<BlockStatement>();
|
|
block->kind = NodeKind::kBlockStatement;
|
|
block->span = loc;
|
|
|
|
block->statements = std::move(statements);
|
|
return block;
|
|
}
|
|
|
|
StatementPtr ParseHTMLSelfClosingTag(TSNode node, [[maybe_unused]] ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
auto block = MakeNode<BlockStatement>();
|
|
block->kind = NodeKind::kBlockStatement;
|
|
block->span = loc;
|
|
|
|
return block;
|
|
}
|
|
|
|
StatementPtr ParseHTMLPairedTag(TSNode node, ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
|
|
std::vector<StatementPtr> content;
|
|
TSNode content_node = ts_node_child_by_field_name(node, "content", 7);
|
|
if (!ts_node_is_null(content_node))
|
|
{
|
|
uint32_t count = ts_node_child_count(content_node);
|
|
for (uint32_t i = 0; i < count; i++)
|
|
{
|
|
TSNode child = ts_node_child(content_node, i);
|
|
if (!ts_node_is_named(child))
|
|
continue;
|
|
|
|
auto stmt = ParseStatement(child, ctx);
|
|
if (stmt)
|
|
content.push_back(std::move(stmt));
|
|
}
|
|
}
|
|
|
|
auto block = MakeNode<BlockStatement>();
|
|
block->kind = NodeKind::kBlockStatement;
|
|
block->span = loc;
|
|
|
|
block->statements = std::move(content);
|
|
return block;
|
|
}
|
|
|
|
StatementPtr ParseHTMLComment(TSNode node, [[maybe_unused]] ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
auto block = MakeNode<BlockStatement>();
|
|
block->kind = NodeKind::kBlockStatement;
|
|
block->span = loc;
|
|
|
|
return block;
|
|
}
|
|
|
|
StatementPtr ParseUnitDefinition(TSNode node, ParseContext& ctx)
|
|
{
|
|
auto unit = MakeNode<UnitDefinition>();
|
|
unit->kind = NodeKind::kUnitDefinition;
|
|
unit->span = ts::NodeLocation(node);
|
|
|
|
TSNode name_node = ts_node_child_by_field_name(node, "name", 4);
|
|
if (!ts_node_is_null(name_node))
|
|
{
|
|
unit->name = ts::Text(name_node, ctx.Source());
|
|
unit->location = ts::NodeLocation(name_node);
|
|
}
|
|
|
|
TSNode interface_node = ts_node_child_by_field_name(node, "interface", 9);
|
|
if (!ts_node_is_null(interface_node))
|
|
{
|
|
uint32_t count = ts_node_child_count(interface_node);
|
|
for (uint32_t i = 0; i < count; i++)
|
|
{
|
|
TSNode child = ts_node_child(interface_node, i);
|
|
if (!ts_node_is_named(child))
|
|
continue;
|
|
if (ts::IsComment(child))
|
|
continue;
|
|
|
|
std::string_view child_type = ts_node_type(child);
|
|
if (child_type == "interface")
|
|
continue;
|
|
auto stmt = ParseStatement(child, ctx);
|
|
if (stmt)
|
|
unit->interface_statements.push_back(std::move(stmt));
|
|
}
|
|
}
|
|
|
|
TSNode impl_node = ts_node_child_by_field_name(node, "implementation", 14);
|
|
if (!ts_node_is_null(impl_node))
|
|
{
|
|
uint32_t count = ts_node_child_count(impl_node);
|
|
for (uint32_t i = 0; i < count; i++)
|
|
{
|
|
TSNode child = ts_node_child(impl_node, i);
|
|
if (!ts_node_is_named(child))
|
|
continue;
|
|
if (ts::IsComment(child))
|
|
continue;
|
|
|
|
std::string_view child_type = ts_node_type(child);
|
|
if (child_type == "implementation")
|
|
continue;
|
|
|
|
auto stmt = ParseStatement(child, ctx);
|
|
if (stmt)
|
|
unit->implementation_statements.push_back(std::move(stmt));
|
|
}
|
|
}
|
|
|
|
TSNode init_node = ts_node_child_by_field_name(node, "initialization", 14);
|
|
if (!ts_node_is_null(init_node))
|
|
{
|
|
uint32_t count = ts_node_child_count(init_node);
|
|
for (uint32_t i = 0; i < count; i++)
|
|
{
|
|
TSNode child = ts_node_child(init_node, i);
|
|
if (!ts_node_is_named(child))
|
|
continue;
|
|
if (ts::IsComment(child))
|
|
continue;
|
|
|
|
std::string_view child_type = ts_node_type(child);
|
|
if (child_type == "initialization")
|
|
continue;
|
|
|
|
auto stmt = ParseStatement(child, ctx);
|
|
if (stmt)
|
|
unit->initialization_statements.push_back(std::move(stmt));
|
|
}
|
|
}
|
|
|
|
TSNode final_node = ts_node_child_by_field_name(node, "finalization", 12);
|
|
if (!ts_node_is_null(final_node))
|
|
{
|
|
uint32_t count = ts_node_child_count(final_node);
|
|
for (uint32_t i = 0; i < count; i++)
|
|
{
|
|
TSNode child = ts_node_child(final_node, i);
|
|
if (!ts_node_is_named(child))
|
|
continue;
|
|
if (ts::IsComment(child))
|
|
continue;
|
|
|
|
std::string_view child_type = ts_node_type(child);
|
|
if (child_type == "finalization")
|
|
continue;
|
|
|
|
auto stmt = ParseStatement(child, ctx);
|
|
if (stmt)
|
|
unit->finalization_statements.push_back(std::move(stmt));
|
|
}
|
|
}
|
|
|
|
return unit;
|
|
}
|
|
|
|
// ===== Class成员解析 =====
|
|
|
|
AccessModifier ParseAccessModifier(TSNode node, ParseContext& ctx)
|
|
{
|
|
std::string text = utils::ToLower(ts::Text(node, ctx.Source()));
|
|
|
|
if (text == "public")
|
|
return AccessModifier::kPublic;
|
|
else if (text == "protected")
|
|
return AccessModifier::kProtected;
|
|
else if (text == "private")
|
|
return AccessModifier::kPrivate;
|
|
|
|
return AccessModifier::kPublic;
|
|
}
|
|
|
|
MethodModifier ParseMethodModifier(TSNode node, ParseContext& ctx)
|
|
{
|
|
std::string text = utils::ToLower(ts::Text(node, ctx.Source()));
|
|
|
|
if (text == "virtual")
|
|
return MethodModifier::kVirtual;
|
|
else if (text == "override")
|
|
return MethodModifier::kOverride;
|
|
else if (text == "overload")
|
|
return MethodModifier::kOverload;
|
|
|
|
return MethodModifier::kNone;
|
|
}
|
|
|
|
ReferenceModifier ParseReferenceModifier(TSNode node, ParseContext& ctx)
|
|
{
|
|
std::string text = utils::ToLower(ts::Text(node, ctx.Source()));
|
|
|
|
if (text == "weakref")
|
|
return ReferenceModifier::kWeakRef;
|
|
else if (text == "autoref")
|
|
return ReferenceModifier::kAutoRef;
|
|
|
|
return ReferenceModifier::kNone;
|
|
}
|
|
|
|
std::unique_ptr<MethodDeclaration> ParseMethodDeclaration(TSNode node, ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
|
|
auto method = MakeNode<MethodDeclaration>();
|
|
method->kind = NodeKind::kMethodDeclaration;
|
|
method->span = loc;
|
|
|
|
uint32_t count = ts_node_child_count(node);
|
|
for (uint32_t i = 0; i < count; i++)
|
|
{
|
|
TSNode child = ts_node_child(node, i);
|
|
std::string_view child_type = ts_node_type(child);
|
|
if (child_type == "class")
|
|
{
|
|
method->is_class_method = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
TSNode name_node = ts_node_child_by_field_name(node, "name", 4);
|
|
if (!ts_node_is_null(name_node))
|
|
{
|
|
std::string name_type = ts_node_type(name_node);
|
|
if (name_type == "operator_overload")
|
|
{
|
|
method->is_operator_overload = true;
|
|
TSNode op_node = ts_node_child_by_field_name(name_node, "operator", 8);
|
|
if (!ts_node_is_null(op_node))
|
|
{
|
|
method->name = ts::Text(op_node, ctx.Source());
|
|
method->location = ts::NodeLocation(op_node);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
method->name = ts::Text(name_node, ctx.Source());
|
|
method->location = ts::NodeLocation(name_node);
|
|
}
|
|
}
|
|
|
|
method->signature = ParseSignature(node, ctx);
|
|
|
|
TSNode modifier_node = ts_node_child_by_field_name(node, "modifier", 8);
|
|
if (!ts_node_is_null(modifier_node))
|
|
method->modifier = ParseMethodModifier(modifier_node, ctx);
|
|
|
|
TSNode body_node = ts_node_child_by_field_name(node, "body", 4);
|
|
if (!ts_node_is_null(body_node))
|
|
method->body = ParseStatement(body_node, ctx);
|
|
|
|
if (utils::ToLower(method->name) == "create")
|
|
method->method_type = MethodType::kConstructor;
|
|
else if (utils::ToLower(method->name) == "destroy")
|
|
method->method_type = MethodType::kDestructor;
|
|
|
|
return method;
|
|
}
|
|
|
|
std::unique_ptr<PropertyDeclaration> ParsePropertyDeclaration(TSNode node, ParseContext& ctx)
|
|
{
|
|
Location loc = ts::NodeLocation(node);
|
|
|
|
auto prop = MakeNode<PropertyDeclaration>();
|
|
prop->kind = NodeKind::kPropertyDeclaration;
|
|
prop->span = loc;
|
|
|
|
TSNode name_node = ts_node_child_by_field_name(node, "name", 4);
|
|
if (!ts_node_is_null(name_node))
|
|
{
|
|
prop->name = ts::Text(name_node, ctx.Source());
|
|
prop->location = ts::NodeLocation(name_node);
|
|
}
|
|
|
|
TSNode type_node = ts_node_child_by_field_name(node, "type_name", 9);
|
|
if (!ts_node_is_null(type_node))
|
|
prop->type_name = ts::Text(type_node, ctx.Source());
|
|
|
|
TSNode index_node = ts_node_child_by_field_name(node, "index", 5);
|
|
if (!ts_node_is_null(index_node))
|
|
prop->index_value = ts::Text(node, ctx.Source());
|
|
|
|
TSNode accessors_node = ts_node_child_by_field_name(node, "accessors", 9);
|
|
if (!ts_node_is_null(accessors_node))
|
|
{
|
|
TSNode read_node = ts_node_child_by_field_name(accessors_node, "read", 4);
|
|
TSNode write_node = ts_node_child_by_field_name(accessors_node, "write", 5);
|
|
if (!ts_node_is_null(read_node))
|
|
prop->read_accessor = ts::Text(read_node, ctx.Source());
|
|
if (!ts_node_is_null(write_node))
|
|
prop->write_accessor = ts::Text(write_node, ctx.Source());
|
|
}
|
|
|
|
return prop;
|
|
}
|
|
|
|
std::vector<ClassMemberParseResult> ParseClassMember(TSNode node, ParseContext& ctx, AccessModifier current_access, ReferenceModifier current_reference)
|
|
{
|
|
std::vector<ClassMemberParseResult> results;
|
|
std::string_view node_type = ts_node_type(node);
|
|
Location loc = ts::NodeLocation(node);
|
|
|
|
// 如果是访问修饰符，返回新的访问级别
|
|
if (node_type == "access_modifier")
|
|
{
|
|
ClassMemberParseResult result;
|
|
result.access_modifier = ParseAccessModifier(node, ctx);
|
|
results.push_back(std::move(result));
|
|
return results;
|
|
}
|
|
|
|
// 如果是引用修饰符，返回新的引用修饰符
|
|
if (node_type == "reference_modifier")
|
|
{
|
|
ClassMemberParseResult result;
|
|
result.reference_modifier = ParseReferenceModifier(node, ctx);
|
|
results.push_back(std::move(result));
|
|
return results;
|
|
}
|
|
|
|
if (node_type == "variable_declaration")
|
|
{
|
|
bool is_static = false;
|
|
|
|
TSNode variable_node = ts_node_child_by_field_name(node, "variable", 8);
|
|
if (ts_node_is_null(variable_node))
|
|
return results;
|
|
|
|
bool ref_flag = false;
|
|
TSNode ref_node = ts_node_child_by_field_name(node, "ref_modifier", 12);
|
|
if (!ts_node_is_null(ref_node))
|
|
ref_flag = true;
|
|
|
|
TSNode member_var_node = ts_node_child(variable_node, 0);
|
|
if (ts_node_is_null(member_var_node))
|
|
return results;
|
|
|
|
std::string_view child_type = ts_node_type(member_var_node);
|
|
|
|
if (child_type == "static_member_variable")
|
|
is_static = true;
|
|
else if (child_type == "field_declaration")
|
|
is_static = false;
|
|
|
|
if (ts_node_is_null(member_var_node))
|
|
return results;
|
|
|
|
uint32_t count = ts_node_child_count(member_var_node);
|
|
for (uint32_t i = 0; i < count; i++)
|
|
{
|
|
const char* field = ts_node_field_name_for_child(member_var_node, i);
|
|
if (!field || std::string_view(field) != "name")
|
|
continue;
|
|
|
|
TSNode name_node = ts_node_child(member_var_node, i);
|
|
std::string name = ts::Text(name_node, ctx.Source());
|
|
Location name_loc = ts::NodeLocation(name_node);
|
|
|
|
auto member = MakeNode<ClassMember>();
|
|
member->kind = NodeKind::kClassMember;
|
|
member->span = name_loc;
|
|
member->access_modifier = current_access;
|
|
|
|
if (is_static)
|
|
{
|
|
auto decl = MakeNode<StaticDeclaration>();
|
|
decl->kind = NodeKind::kStaticDeclaration;
|
|
decl->span = name_loc;
|
|
|
|
decl->name = name;
|
|
decl->reference_modifier = ref_flag ? ParseReferenceModifier(ref_node, ctx) : current_reference;
|
|
|
|
member->member = std::move(decl);
|
|
}
|
|
else
|
|
{
|
|
auto decl = MakeNode<FieldDeclaration>();
|
|
decl->kind = NodeKind::kFieldDeclaration;
|
|
decl->span = name_loc;
|
|
|
|
decl->name = name;
|
|
decl->reference_modifier = ref_flag ? ParseReferenceModifier(ref_node, ctx) : current_reference;
|
|
|
|
member->member = std::move(decl);
|
|
}
|
|
|
|
ClassMemberParseResult result;
|
|
result.member = std::move(member);
|
|
results.push_back(std::move(result));
|
|
}
|
|
|
|
ExpressionPtr initial_value;
|
|
TSNode value_node = ts_node_child_by_field_name(member_var_node, "initial_value", 13);
|
|
if (!ts_node_is_null(value_node))
|
|
initial_value = ParseExpression(value_node, ctx);
|
|
|
|
TSNode type_node = ts_node_child_by_field_name(member_var_node, "type_name", 9);
|
|
if (!results.empty())
|
|
{
|
|
auto& last_member = results.back().member;
|
|
|
|
std::visit([&](auto& decl_ptr) {
|
|
using T = std::decay_t<decltype(*decl_ptr)>;
|
|
|
|
if constexpr (std::is_same_v<T, StaticDeclaration> ||
|
|
std::is_same_v<T, FieldDeclaration>)
|
|
{
|
|
if (!ts_node_is_null(type_node))
|
|
decl_ptr->type = TypeAnnotation{ .name = ts::Text(type_node, ctx.Source()), .location = ts::NodeLocation(type_node) };
|
|
decl_ptr->initial_value = std::move(initial_value);
|
|
}
|
|
},
|
|
last_member->member);
|
|
}
|
|
}
|
|
|
|
else if (node_type == "method_declaration_only" ||
|
|
node_type == "method_with_modifier" ||
|
|
node_type == "method_with_implementation")
|
|
{
|
|
auto member = MakeNode<ClassMember>();
|
|
member->kind = NodeKind::kClassMember;
|
|
member->span = loc;
|
|
|
|
member->access_modifier = current_access;
|
|
|
|
auto method = ParseMethodDeclaration(node, ctx);
|
|
member->member = std::move(method);
|
|
|
|
ClassMemberParseResult result;
|
|
result.member = std::move(member);
|
|
results.push_back(std::move(result));
|
|
}
|
|
else if (node_type == "property_declaration")
|
|
{
|
|
auto member = MakeNode<ClassMember>();
|
|
member->kind = NodeKind::kClassMember;
|
|
member->span = loc;
|
|
|
|
member->access_modifier = current_access;
|
|
|
|
auto prop = ParsePropertyDeclaration(node, ctx);
|
|
member->member = std::move(prop);
|
|
|
|
ClassMemberParseResult result;
|
|
result.member = std::move(member);
|
|
results.push_back(std::move(result));
|
|
}
|
|
|
|
return results;
|
|
}
|
|
|
|
StatementPtr ParseClassDefinition(TSNode node, ParseContext& ctx)
|
|
{
|
|
auto class_def = MakeNode<ClassDefinition>();
|
|
class_def->kind = NodeKind::kClassDefinition;
|
|
class_def->span = ts::NodeLocation(node);
|
|
|
|
TSNode name_node = ts_node_child_by_field_name(node, "name", 4);
|
|
if (!ts_node_is_null(name_node))
|
|
{
|
|
class_def->name = ts::Text(name_node, ctx.Source());
|
|
class_def->location = ts::NodeLocation(name_node);
|
|
}
|
|
|
|
uint32_t count = ts_node_child_count(node);
|
|
for (uint32_t i = 0; i < count; i++)
|
|
{
|
|
const char* field = ts_node_field_name_for_child(node, i);
|
|
if (!field || std::string_view(field) != "parent")
|
|
continue;
|
|
TSNode parent_node = ts_node_child(node, i);
|
|
|
|
std::string parent_name;
|
|
std::string_view parent_type = ts_node_type(parent_node);
|
|
|
|
ClassDefinition::ParentClass parent;
|
|
if (parent_type == "attribute")
|
|
{
|
|
auto attr = ParseAttributeExpression(parent_node, ctx);
|
|
auto attr_expr = dynamic_cast<AttributeExpression*>(attr.get());
|
|
if (!attr_expr->name.empty())
|
|
{
|
|
parent.name = attr_expr->name;
|
|
parent.location = attr_expr->location;
|
|
}
|
|
if (attr_expr->object)
|
|
{
|
|
auto identifier = dynamic_cast<Identifier*>(attr_expr->object.get());
|
|
parent.qualifier = identifier->name;
|
|
parent.qualifier_location = identifier->location;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
parent.name = ts::Text(parent_node, ctx.Source());
|
|
parent.location = ts::NodeLocation(parent_node);
|
|
}
|
|
class_def->parent_classes.push_back(std::move(parent));
|
|
}
|
|
|
|
TSNode body_node = ts_node_child_by_field_name(node, "body", 4);
|
|
if (!ts_node_is_null(body_node))
|
|
{
|
|
AccessModifier current_access = AccessModifier::kPublic;
|
|
ReferenceModifier current_reference = ReferenceModifier::kNone;
|
|
|
|
uint32_t count = ts_node_child_count(body_node);
|
|
for (uint32_t i = 0; i < count; i++)
|
|
{
|
|
TSNode member_node = ts_node_child(body_node, i);
|
|
if (!ts_node_is_named(member_node))
|
|
continue;
|
|
if (ts::IsComment(member_node))
|
|
continue;
|
|
|
|
std::string member_type = ts_node_type(member_node);
|
|
if (member_type == "class_member")
|
|
{
|
|
uint32_t member_count = ts_node_child_count(member_node);
|
|
for (uint32_t j = 0; j < member_count; j++)
|
|
{
|
|
TSNode cm_child = ts_node_child(member_node, j);
|
|
|
|
if (!ts_node_is_named(cm_child))
|
|
continue;
|
|
|
|
auto results = ParseClassMember(cm_child, ctx, current_access, current_reference);
|
|
for (auto& result : results)
|
|
{
|
|
if (result.access_modifier)
|
|
current_access = result.access_modifier.value();
|
|
else if (result.reference_modifier)
|
|
current_reference = result.reference_modifier.value();
|
|
else if (result.member)
|
|
class_def->members.push_back(std::move(result.member));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
auto results = ParseClassMember(member_node, ctx, current_access, current_reference);
|
|
for (auto& result : results)
|
|
{
|
|
if (result.access_modifier)
|
|
current_access = result.access_modifier.value();
|
|
else if (result.reference_modifier)
|
|
current_reference = result.reference_modifier.value();
|
|
else if (result.member)
|
|
class_def->members.push_back(std::move(result.member));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return class_def;
|
|
}
|
|
|
|
StatementPtr ParseExternalMethodStatement(TSNode node, ParseContext& ctx)
|
|
{
|
|
auto ext_method = MakeNode<ExternalMethodDefinition>();
|
|
ext_method->kind = NodeKind::kExternalMethodDefinition;
|
|
ext_method->span = ts::NodeLocation(node);
|
|
|
|
TSNode class_node = ts_node_child_by_field_name(node, "class_name", 10);
|
|
if (!ts_node_is_null(class_node))
|
|
{
|
|
ext_method->owner_class.name = ts::Text(class_node, ctx.Source());
|
|
ext_method->owner_class.location = ts::NodeLocation(class_node);
|
|
}
|
|
|
|
TSNode op_node = ts_node_child_by_field_name(node, "operator", 8);
|
|
if (!ts_node_is_null(op_node))
|
|
{
|
|
ext_method->is_operator_overload = true;
|
|
ext_method->name = ts::Text(op_node, ctx.Source());
|
|
ext_method->location = ts::NodeLocation(op_node);
|
|
}
|
|
else
|
|
{
|
|
TSNode method_node = ts_node_child_by_field_name(node, "method_name", 11);
|
|
if (!ts_node_is_null(method_node))
|
|
{
|
|
ext_method->name = ts::Text(method_node, ctx.Source());
|
|
ext_method->location = ts::NodeLocation(method_node);
|
|
}
|
|
}
|
|
|
|
uint32_t count = ts_node_child_count(node);
|
|
for (uint32_t i = 0; i < count; i++)
|
|
{
|
|
TSNode child = ts_node_child(node, i);
|
|
if (!ts_node_is_named(child))
|
|
continue;
|
|
|
|
std::string_view child_type = ts_node_type(child);
|
|
if (child_type == "class")
|
|
{
|
|
ext_method->is_class_method = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
ext_method->signature = ParseSignature(node, ctx);
|
|
|
|
TSNode modifier_node = ts_node_child_by_field_name(node, "modifier", 8);
|
|
if (!ts_node_is_null(modifier_node))
|
|
ext_method->modifier = ParseMethodModifier(modifier_node, ctx);
|
|
|
|
TSNode body_node = ts_node_child_by_field_name(node, "body", 4);
|
|
if (!ts_node_is_null(body_node))
|
|
ext_method->body = ParseStatement(body_node, ctx);
|
|
|
|
if (utils::ToLower(ext_method->name) == "create")
|
|
ext_method->method_type = MethodType::kConstructor;
|
|
else if (utils::ToLower(ext_method->name) == "destroy")
|
|
ext_method->method_type = MethodType::kDestructor;
|
|
|
|
return ext_method;
|
|
}
|
|
}
|