298 lines
12 KiB
C
298 lines
12 KiB
C
|
#pragma once
|
||
|
|
// TreeSitterParser Cpp support.
|
||
|
|
public:
|
||
|
|
// C++
|
||
|
|
// ---------------------------------------------------------------
|
||
|
|
static std::unique_ptr<Module> parseCpp(const std::string& source) {
|
||
|
|
TSParser* parser = ts_parser_new();
|
||
|
|
ts_parser_set_language(parser, tree_sitter_cpp());
|
||
|
|
TSTree* tree = ts_parser_parse_string(parser, nullptr, source.c_str(), (uint32_t)source.size());
|
||
|
|
TSNode root = ts_tree_root_node(tree);
|
||
|
|
|
||
|
|
auto module = std::make_unique<Module>();
|
||
|
|
module->id = IdGenerator::next("mod");
|
||
|
|
module->name = "parsed_cpp_module";
|
||
|
|
module->targetLanguage = "cpp";
|
||
|
|
applySpan(module.get(), root);
|
||
|
|
|
||
|
|
convertCppTranslationUnit(root, source, module.get());
|
||
|
|
|
||
|
|
ts_tree_delete(tree);
|
||
|
|
ts_parser_delete(parser);
|
||
|
|
return module;
|
||
|
|
}
|
||
|
|
|
||
|
|
static ParseResult parseCppWithDiagnostics(const std::string& source) {
|
||
|
|
ParseResult result;
|
||
|
|
TSParser* parser = ts_parser_new();
|
||
|
|
ts_parser_set_language(parser, tree_sitter_cpp());
|
||
|
|
TSTree* tree = ts_parser_parse_string(parser, nullptr, source.c_str(), (uint32_t)source.size());
|
||
|
|
TSNode root = ts_tree_root_node(tree);
|
||
|
|
|
||
|
|
result.module = std::make_unique<Module>();
|
||
|
|
result.module->id = IdGenerator::next("mod");
|
||
|
|
result.module->name = "parsed_cpp_module";
|
||
|
|
result.module->targetLanguage = "cpp";
|
||
|
|
applySpan(result.module.get(), root);
|
||
|
|
|
||
|
|
convertCppTranslationUnit(root, source, result.module.get());
|
||
|
|
collectDiagnostics(root, source, result.diagnostics);
|
||
|
|
|
||
|
|
ts_tree_delete(tree);
|
||
|
|
ts_parser_delete(parser);
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------
|
||
|
|
private:
|
||
|
|
// C++ CST → AST
|
||
|
|
// ---------------------------------------------------------------
|
||
|
|
static void convertCppTranslationUnit(TSNode root, const std::string& source, Module* module) {
|
||
|
|
uint32_t count = ts_node_named_child_count(root);
|
||
|
|
for (uint32_t i = 0; i < count; ++i) {
|
||
|
|
TSNode child = ts_node_named_child(root, i);
|
||
|
|
std::string type = nodeType(child);
|
||
|
|
if (type == "function_definition") {
|
||
|
|
auto* fn = convertCppFunction(child, source);
|
||
|
|
if (fn) module->addChild("functions", fn);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static Function* convertCppFunction(TSNode node, const std::string& source) {
|
||
|
|
auto* fn = new Function();
|
||
|
|
fn->id = IdGenerator::next("fn");
|
||
|
|
applySpan(fn, node);
|
||
|
|
|
||
|
|
// In C++ grammar, the structure is:
|
||
|
|
// function_definition: type declarator body
|
||
|
|
// The declarator contains the function name and parameters.
|
||
|
|
|
||
|
|
// Return type
|
||
|
|
TSNode typeNode = childByFieldName(node, "type");
|
||
|
|
if (!ts_node_is_null(typeNode)) {
|
||
|
|
std::string typeText = nodeText(typeNode, source);
|
||
|
|
auto* retType = new PrimitiveType(IdGenerator::next("type"), typeText);
|
||
|
|
fn->setChild("returnType", retType);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Declarator: function_declarator which has declarator (name) and parameters
|
||
|
|
TSNode declaratorNode = childByFieldName(node, "declarator");
|
||
|
|
if (!ts_node_is_null(declaratorNode)) {
|
||
|
|
extractCppFunctionName(declaratorNode, source, fn);
|
||
|
|
extractCppParameters(declaratorNode, source, fn);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Body
|
||
|
|
TSNode bodyNode = childByFieldName(node, "body");
|
||
|
|
if (!ts_node_is_null(bodyNode)) {
|
||
|
|
convertCppBody(bodyNode, source, fn);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Memory pattern detection from source text
|
||
|
|
std::string bodySource = "";
|
||
|
|
if (!ts_node_is_null(bodyNode)) {
|
||
|
|
bodySource = nodeText(bodyNode, source);
|
||
|
|
}
|
||
|
|
detectCppMemoryPatterns(bodySource, fn);
|
||
|
|
|
||
|
|
return fn;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void extractCppFunctionName(TSNode declNode, const std::string& source, Function* fn) {
|
||
|
|
std::string type = nodeType(declNode);
|
||
|
|
if (type == "function_declarator") {
|
||
|
|
TSNode nameNode = childByFieldName(declNode, "declarator");
|
||
|
|
if (!ts_node_is_null(nameNode)) {
|
||
|
|
// Could be an identifier directly, or nested further
|
||
|
|
fn->name = nodeText(nameNode, source);
|
||
|
|
}
|
||
|
|
} else if (type == "identifier") {
|
||
|
|
fn->name = nodeText(declNode, source);
|
||
|
|
} else {
|
||
|
|
// Try to find function_declarator among children
|
||
|
|
uint32_t count = ts_node_named_child_count(declNode);
|
||
|
|
for (uint32_t i = 0; i < count; ++i) {
|
||
|
|
TSNode child = ts_node_named_child(declNode, i);
|
||
|
|
std::string childType = nodeType(child);
|
||
|
|
if (childType == "function_declarator") {
|
||
|
|
extractCppFunctionName(child, source, fn);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// Fallback
|
||
|
|
fn->name = nodeText(declNode, source);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static void extractCppParameters(TSNode declNode, const std::string& source, Function* fn) {
|
||
|
|
std::string type = nodeType(declNode);
|
||
|
|
if (type == "function_declarator") {
|
||
|
|
TSNode paramsNode = childByFieldName(declNode, "parameters");
|
||
|
|
if (!ts_node_is_null(paramsNode)) {
|
||
|
|
uint32_t count = ts_node_named_child_count(paramsNode);
|
||
|
|
for (uint32_t i = 0; i < count; ++i) {
|
||
|
|
TSNode paramChild = ts_node_named_child(paramsNode, i);
|
||
|
|
std::string paramType = nodeType(paramChild);
|
||
|
|
if (paramType == "parameter_declaration") {
|
||
|
|
convertCppParameter(paramChild, source, fn);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
// Search for function_declarator child
|
||
|
|
uint32_t count = ts_node_named_child_count(declNode);
|
||
|
|
for (uint32_t i = 0; i < count; ++i) {
|
||
|
|
TSNode child = ts_node_named_child(declNode, i);
|
||
|
|
if (nodeType(child) == "function_declarator") {
|
||
|
|
extractCppParameters(child, source, fn);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static void convertCppParameter(TSNode paramNode, const std::string& source, Function* fn) {
|
||
|
|
auto* param = new Parameter();
|
||
|
|
param->id = IdGenerator::next("param");
|
||
|
|
applySpan(param, paramNode);
|
||
|
|
|
||
|
|
// parameter_declaration has type and declarator fields
|
||
|
|
TSNode typeNode = childByFieldName(paramNode, "type");
|
||
|
|
TSNode declNode = childByFieldName(paramNode, "declarator");
|
||
|
|
|
||
|
|
if (!ts_node_is_null(typeNode)) {
|
||
|
|
std::string typeText = nodeText(typeNode, source);
|
||
|
|
auto* primType = new PrimitiveType(IdGenerator::next("type"), typeText);
|
||
|
|
applySpan(primType, typeNode);
|
||
|
|
param->setChild("type", primType);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!ts_node_is_null(declNode)) {
|
||
|
|
param->name = nodeText(declNode, source);
|
||
|
|
}
|
||
|
|
|
||
|
|
fn->addChild("parameters", param);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void convertCppBody(TSNode bodyNode, const std::string& source, Function* fn) {
|
||
|
|
// bodyNode is a compound_statement { ... }
|
||
|
|
uint32_t count = ts_node_named_child_count(bodyNode);
|
||
|
|
for (uint32_t i = 0; i < count; ++i) {
|
||
|
|
TSNode child = ts_node_named_child(bodyNode, i);
|
||
|
|
ASTNode* stmt = convertCppStatement(child, source);
|
||
|
|
if (stmt) fn->addChild("body", stmt);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static ASTNode* convertCppStatement(TSNode node, const std::string& source) {
|
||
|
|
std::string type = nodeType(node);
|
||
|
|
if (type == "return_statement") {
|
||
|
|
auto* ret = new Return();
|
||
|
|
ret->id = IdGenerator::next("ret");
|
||
|
|
applySpan(ret, node);
|
||
|
|
uint32_t count = ts_node_named_child_count(node);
|
||
|
|
if (count > 0) {
|
||
|
|
ASTNode* val = convertCppExpression(ts_node_named_child(node, 0), source);
|
||
|
|
if (val) ret->setChild("value", val);
|
||
|
|
}
|
||
|
|
return ret;
|
||
|
|
} else if (type == "expression_statement") {
|
||
|
|
auto* exprStmt = new ExpressionStatement();
|
||
|
|
exprStmt->id = IdGenerator::next("exprstmt");
|
||
|
|
applySpan(exprStmt, node);
|
||
|
|
uint32_t count = ts_node_named_child_count(node);
|
||
|
|
if (count > 0) {
|
||
|
|
ASTNode* expr = convertCppExpression(ts_node_named_child(node, 0), source);
|
||
|
|
if (expr) exprStmt->setChild("expression", expr);
|
||
|
|
}
|
||
|
|
return exprStmt;
|
||
|
|
} else if (type == "declaration") {
|
||
|
|
auto* exprStmt = new ExpressionStatement();
|
||
|
|
exprStmt->id = IdGenerator::next("exprstmt");
|
||
|
|
applySpan(exprStmt, node);
|
||
|
|
return exprStmt;
|
||
|
|
} else if (type == "if_statement") {
|
||
|
|
auto* ifStmt = new IfStatement();
|
||
|
|
ifStmt->id = IdGenerator::next("if");
|
||
|
|
applySpan(ifStmt, node);
|
||
|
|
return ifStmt;
|
||
|
|
}
|
||
|
|
return nullptr;
|
||
|
|
}
|
||
|
|
|
||
|
|
static ASTNode* convertCppExpression(TSNode node, const std::string& source) {
|
||
|
|
std::string type = nodeType(node);
|
||
|
|
if (type == "binary_expression") {
|
||
|
|
auto* binOp = new BinaryOperation();
|
||
|
|
binOp->id = IdGenerator::next("binop");
|
||
|
|
applySpan(binOp, node);
|
||
|
|
TSNode leftNode = childByFieldName(node, "left");
|
||
|
|
TSNode rightNode = childByFieldName(node, "right");
|
||
|
|
TSNode opNode = childByFieldName(node, "operator");
|
||
|
|
if (!ts_node_is_null(opNode)) {
|
||
|
|
binOp->op = nodeText(opNode, source);
|
||
|
|
}
|
||
|
|
if (!ts_node_is_null(leftNode)) {
|
||
|
|
ASTNode* left = convertCppExpression(leftNode, source);
|
||
|
|
if (left) binOp->setChild("left", left);
|
||
|
|
}
|
||
|
|
if (!ts_node_is_null(rightNode)) {
|
||
|
|
ASTNode* right = convertCppExpression(rightNode, source);
|
||
|
|
if (right) binOp->setChild("right", right);
|
||
|
|
}
|
||
|
|
return binOp;
|
||
|
|
} else if (type == "identifier") {
|
||
|
|
auto* ref = new VariableReference(IdGenerator::next("var"), nodeText(node, source));
|
||
|
|
applySpan(ref, node);
|
||
|
|
return ref;
|
||
|
|
} else if (type == "number_literal") {
|
||
|
|
std::string text = nodeText(node, source);
|
||
|
|
int val = 0;
|
||
|
|
try { val = std::stoi(text); } catch (...) {}
|
||
|
|
auto* lit = new IntegerLiteral(IdGenerator::next("int"), val);
|
||
|
|
applySpan(lit, node);
|
||
|
|
return lit;
|
||
|
|
} else if (type == "string_literal" || type == "raw_string_literal") {
|
||
|
|
auto* lit = new StringLiteral(IdGenerator::next("str"), nodeText(node, source));
|
||
|
|
applySpan(lit, node);
|
||
|
|
return lit;
|
||
|
|
} else if (type == "parenthesized_expression") {
|
||
|
|
uint32_t count = ts_node_named_child_count(node);
|
||
|
|
if (count > 0) return convertCppExpression(ts_node_named_child(node, 0), source);
|
||
|
|
}
|
||
|
|
// Fallback
|
||
|
|
std::string text = nodeText(node, source);
|
||
|
|
if (!text.empty()) {
|
||
|
|
auto* ref = new VariableReference(IdGenerator::next("var"), text);
|
||
|
|
applySpan(ref, node);
|
||
|
|
return ref;
|
||
|
|
}
|
||
|
|
return nullptr;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void detectCppMemoryPatterns(const std::string& bodySource, Function* fn) {
|
||
|
|
bool hasUnique = bodySource.find("unique_ptr") != std::string::npos ||
|
||
|
|
bodySource.find("make_unique") != std::string::npos;
|
||
|
|
bool hasShared = bodySource.find("shared_ptr") != std::string::npos ||
|
||
|
|
bodySource.find("make_shared") != std::string::npos;
|
||
|
|
bool hasNew = bodySource.find("new ") != std::string::npos;
|
||
|
|
bool hasDelete = bodySource.find("delete ") != std::string::npos ||
|
||
|
|
bodySource.find("delete;") != std::string::npos;
|
||
|
|
|
||
|
|
if (hasUnique) {
|
||
|
|
auto* anno = new LifetimeAnnotation(IdGenerator::next("anno"), "RAII");
|
||
|
|
fn->addChild("annotations", anno);
|
||
|
|
}
|
||
|
|
if (hasShared) {
|
||
|
|
auto* anno = new OwnerAnnotation(IdGenerator::next("anno"), "Shared_ARC");
|
||
|
|
fn->addChild("annotations", anno);
|
||
|
|
}
|
||
|
|
if (hasNew && hasDelete) {
|
||
|
|
auto* anno = new DeallocateAnnotation(IdGenerator::next("anno"), "Explicit");
|
||
|
|
fn->addChild("annotations", anno);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------
|