bill/whetstone_DSL
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Step 306: JS/TS + Rust parser deepening — class, async, await, arrow/closure, struct, trait, impl (12/12 tests)

Browse Source 
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
Bill
2026-02-15 03:34:22 +00:00
parent 91152e4cf1
commit 30e718a996
4 changed files with 706 additions and 34 deletions
Download Patch File Download Diff File Expand all files Collapse all files

201
editor/src/ast/JavaScriptParser.h
View File

@@ -59,41 +59,105 @@ private:
auto* fn = convertJavaScriptFunction(child, source, language);
if (fn) module->addChild("functions", fn);
} else if (type == "class_declaration") {
convertJavaScriptClass(child, source, module, language);
convertJavaScriptClassDecl(child, source, module, language);
} else if (type == "lexical_declaration" || type == "variable_declaration") {
convertJavaScriptVariableFunctions(child, source, module, language);
} else if (type == "export_statement") {
TSNode decl = ts_node_named_child(child, 0);
std::string declType = nodeType(decl);
if (declType == "function_declaration") {
auto* fn = convertJavaScriptFunction(decl, source, language);
if (fn) module->addChild("functions", fn);
} else if (declType == "class_declaration") {
convertJavaScriptClass(decl, source, module, language);
} else if (declType == "lexical_declaration" || declType == "variable_declaration") {
convertJavaScriptVariableFunctions(decl, source, module, language);
uint32_t ec = ts_node_named_child_count(child);
for (uint32_t j = 0; j < ec; ++j) {
TSNode decl = ts_node_named_child(child, j);
std::string declType = nodeType(decl);
if (declType == "function_declaration") {
auto* fn = convertJavaScriptFunction(decl, source, language);
if (fn) module->addChild("functions", fn);
} else if (declType == "class_declaration") {
convertJavaScriptClassDecl(decl, source, module, language);
} else if (declType == "lexical_declaration" || declType == "variable_declaration") {
convertJavaScriptVariableFunctions(decl, source, module, language);
}
}
}
}
}
static void convertJavaScriptClass(TSNode node,
const std::string& source,
Module* module,
const std::string& language) {
static void convertJavaScriptClassDecl(TSNode node,
const std::string& source,
Module* module,
const std::string& language) {
TSNode nameNode = childByFieldName(node, "name");
std::string className = nodeText(nameNode, source);
TSNode bodyNode = childByFieldName(node, "body");
if (ts_node_is_null(bodyNode)) return;
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);
std::string type = nodeType(child);
if (type == "method_definition") {
auto* fn = convertJavaScriptMethod(child, source, language, className);
if (fn) module->addChild("functions", fn);
auto* cls = new ClassDeclaration(IdGenerator::next("cls"), className);
applySpan(cls, node);
// Superclass — check for heritage clause with "extends"
// In tree-sitter-javascript, the superclass is in a child named
// "class_heritage" or we look for an identifier after "extends"
uint32_t allCount = ts_node_named_child_count(node);
for (uint32_t i = 0; i < allCount; ++i) {
TSNode ch = ts_node_named_child(node, i);
std::string chType = nodeType(ch);
if (chType == "class_heritage") {
// The heritage node contains the superclass identifier
uint32_t hc = ts_node_named_child_count(ch);
if (hc > 0) {
cls->superClass = nodeText(ts_node_named_child(ch, 0), source);
}
}
}
TSNode bodyNode = childByFieldName(node, "body");
if (!ts_node_is_null(bodyNode)) {
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);
std::string type = nodeType(child);
if (type == "method_definition") {
// Create MethodDeclaration on the class
auto* meth = convertJavaScriptMethodDecl(child, source, language, className);
if (meth) cls->addChild("methods", meth);
// Backward compat: also add as Function to module.functions
auto* fn = convertJavaScriptMethod(child, source, language, className);
if (fn) module->addChild("functions", fn);
}
}
}
module->addChild("classes", cls);
}
static MethodDeclaration* convertJavaScriptMethodDecl(TSNode node,
const std::string& source,
const std::string& language,
const std::string& className) {
TSNode nameNode = childByFieldName(node, "name");
if (ts_node_is_null(nameNode)) return nullptr;
std::string name = nodeText(nameNode, source);
auto* meth = new MethodDeclaration(IdGenerator::next("meth"), name);
applySpan(meth, node);
meth->className = className;
// Check for static keyword
uint32_t totalCount = ts_node_child_count(node);
for (uint32_t i = 0; i < totalCount; ++i) {
TSNode ch = ts_node_child(node, i);
std::string text = nodeText(ch, source);
if (text == "static") meth->isStatic = true;
}
TSNode paramsNode = childByFieldName(node, "parameters");
if (!ts_node_is_null(paramsNode)) {
convertJavaScriptParameters(paramsNode, source, meth, language);
}
TSNode bodyNode = childByFieldName(node, "body");
if (!ts_node_is_null(bodyNode)) {
convertJavaScriptBody(bodyNode, source, meth, language);
}
return meth;
}
static void convertJavaScriptVariableFunctions(TSNode node,
@@ -122,10 +186,19 @@ private:
const std::string& language) {
TSNode nameNode = childByFieldName(node, "name");
if (ts_node_is_null(nameNode)) return nullptr;
auto* fn = new Function();
fn->id = IdGenerator::next("fn");
// Detect async keyword
bool isAsync = jsNodeHasAsyncKeyword(node, source);
Function* fn;
if (isAsync) {
fn = new AsyncFunction(IdGenerator::next("fn"), nodeText(nameNode, source));
} else {
fn = new Function();
fn->id = IdGenerator::next("fn");
fn->name = nodeText(nameNode, source);
}
applySpan(fn, node);
fn->name = nodeText(nameNode, source);
TSNode paramsNode = childByFieldName(node, "parameters");
if (!ts_node_is_null(paramsNode)) {
@@ -200,6 +273,19 @@ private:
return fn;
}
static bool jsNodeHasAsyncKeyword(TSNode node, const std::string& source) {
uint32_t totalCount = ts_node_child_count(node);
for (uint32_t i = 0; i < totalCount; ++i) {
TSNode ch = ts_node_child(node, i);
if (!ts_node_is_named(ch) && nodeText(ch, source) == "async") return true;
}
// Also check named children text for "async" keyword
// In some tree-sitter JS grammars, "async" appears differently
std::string fullText = nodeText(node, source);
if (fullText.substr(0, 6) == "async ") return true;
return false;
}
static void convertJavaScriptParameters(TSNode paramsNode,
const std::string& source,
Function* fn,
@@ -250,7 +336,7 @@ private:
Function* fn,
const std::string& language) {
std::string type = nodeType(bodyNode);
if (type == "statement_block" || type == "statement_block") {
if (type == "statement_block") {
uint32_t count = ts_node_named_child_count(bodyNode);
for (uint32_t i = 0; i < count; ++i) {
ASTNode* stmt = convertJavaScriptStatement(ts_node_named_child(bodyNode, i), source, language);
@@ -430,6 +516,67 @@ private:
if (idx) access->setChild("index", idx);
}
return access;
} else if (type == "await_expression") {
auto* awExpr = new AwaitExpression(IdGenerator::next("await"));
applySpan(awExpr, node);
uint32_t count = ts_node_named_child_count(node);
if (count > 0) {
ASTNode* expr = convertJavaScriptExpression(ts_node_named_child(node, 0), source, language);
if (expr) awExpr->setChild("expression", expr);
}
return awExpr;
} else if (type == "arrow_function") {
auto* lam = new LambdaExpression(IdGenerator::next("lam"));
applySpan(lam, node);
TSNode paramsNode = childByFieldName(node, "parameters");
if (!ts_node_is_null(paramsNode)) {
uint32_t pc = ts_node_named_child_count(paramsNode);
for (uint32_t pi = 0; pi < pc; ++pi) {
TSNode pChild = ts_node_named_child(paramsNode, pi);
std::string pType = nodeType(pChild);
std::string paramName;
if (pType == "identifier") {
paramName = nodeText(pChild, source);
} else {
TSNode pName = childByFieldName(pChild, "pattern");
if (ts_node_is_null(pName)) pName = childByFieldName(pChild, "name");
if (ts_node_is_null(pName)) pName = pChild;
paramName = nodeText(pName, source);
}
if (!paramName.empty()) {
auto* param = new Parameter(IdGenerator::next("param"), paramName);
applySpan(param, pChild);
lam->addChild("parameters", param);
}
}
} else {
// Single parameter without parens: x => ...
TSNode paramNode = childByFieldName(node, "parameter");
if (!ts_node_is_null(paramNode)) {
auto* param = new Parameter(IdGenerator::next("param"), nodeText(paramNode, source));
applySpan(param, paramNode);
lam->addChild("parameters", param);
}
}
TSNode bodyNode = childByFieldName(node, "body");
if (!ts_node_is_null(bodyNode)) {
if (nodeType(bodyNode) == "statement_block") {
uint32_t bc = ts_node_named_child_count(bodyNode);
for (uint32_t bi = 0; bi < bc; ++bi) {
ASTNode* stmt = convertJavaScriptStatement(ts_node_named_child(bodyNode, bi), source, language);
if (stmt) lam->addChild("body", stmt);
}
} else {
ASTNode* expr = convertJavaScriptExpression(bodyNode, source, language);
if (expr) {
auto* exprStmt = new ExpressionStatement();
exprStmt->id = IdGenerator::next("exprstmt");
exprStmt->setChild("expression", expr);
lam->addChild("body", exprStmt);
}
}
}
return lam;
} else if (type == "identifier") {
auto* ref = new VariableReference(IdGenerator::next("var"), nodeText(node, source));
applySpan(ref, node);

212
editor/src/ast/RustParser.h
View File

@@ -67,8 +67,14 @@ private:
if (fn) module->addChild("functions", fn);
} else if (type == "impl_item") {
convertRustImpl(child, source, module);
} else if (type == "struct_item" || type == "enum_item" || type == "trait_item") {
// Record type name as a custom type variable for visibility.
} else if (type == "struct_item") {
auto* cls = convertRustStruct(child, source);
if (cls) module->addChild("classes", cls);
} else if (type == "trait_item") {
auto* iface = convertRustTrait(child, source);
if (iface) module->addChild("classes", iface);
} else if (type == "enum_item") {
// Record enum name as variable for visibility
TSNode nameNode = childByFieldName(child, "name");
if (!ts_node_is_null(nameNode)) {
auto* var = new Variable(IdGenerator::next("var"), nodeText(nameNode, source));
@@ -78,6 +84,78 @@ private:
}
}
static ClassDeclaration* convertRustStruct(TSNode node, const std::string& source) {
TSNode nameNode = childByFieldName(node, "name");
if (ts_node_is_null(nameNode)) return nullptr;
auto* cls = new ClassDeclaration(IdGenerator::next("cls"), nodeText(nameNode, source));
applySpan(cls, node);
// Extract fields from field_declaration_list body
TSNode bodyNode = childByFieldName(node, "body");
if (!ts_node_is_null(bodyNode)) {
uint32_t fc = ts_node_named_child_count(bodyNode);
for (uint32_t i = 0; i < fc; ++i) {
TSNode fieldNode = ts_node_named_child(bodyNode, i);
if (nodeType(fieldNode) == "field_declaration") {
TSNode fName = childByFieldName(fieldNode, "name");
if (!ts_node_is_null(fName)) {
auto* var = new Variable(IdGenerator::next("var"), nodeText(fName, source));
applySpan(var, fieldNode);
TSNode fType = childByFieldName(fieldNode, "type");
if (!ts_node_is_null(fType)) {
if (auto* t = convertRustType(fType, source)) var->setChild("type", t);
}
cls->addChild("fields", var);
}
}
}
}
return cls;
}
static InterfaceDeclaration* convertRustTrait(TSNode node, const std::string& source) {
TSNode nameNode = childByFieldName(node, "name");
if (ts_node_is_null(nameNode)) return nullptr;
auto* iface = new InterfaceDeclaration(IdGenerator::next("iface"), nodeText(nameNode, source));
applySpan(iface, node);
// Extract method signatures from declaration_list body
TSNode bodyNode = childByFieldName(node, "body");
if (!ts_node_is_null(bodyNode)) {
uint32_t mc = ts_node_named_child_count(bodyNode);
for (uint32_t i = 0; i < mc; ++i) {
TSNode methNode = ts_node_named_child(bodyNode, i);
std::string mType = nodeType(methNode);
if (mType == "function_signature_item" || mType == "function_item") {
TSNode mName = childByFieldName(methNode, "name");
if (!ts_node_is_null(mName)) {
auto* meth = new MethodDeclaration(IdGenerator::next("meth"), nodeText(mName, source));
applySpan(meth, methNode);
meth->className = iface->name;
meth->isVirtual = true;
TSNode paramsNode = childByFieldName(methNode, "parameters");
if (!ts_node_is_null(paramsNode)) {
convertRustParameters(paramsNode, source, meth);
}
TSNode retNode = childByFieldName(methNode, "return_type");
if (!ts_node_is_null(retNode)) {
if (auto* t = convertRustType(retNode, source)) meth->setChild("returnType", t);
}
iface->addChild("methods", meth);
}
}
}
}
return iface;
}
static void convertRustImpl(TSNode node,
const std::string& source,
Module* module) {
@@ -85,30 +163,93 @@ private:
std::string typeName = nodeText(typeNode, source);
TSNode bodyNode = childByFieldName(node, "body");
if (ts_node_is_null(bodyNode)) return;
// Find existing ClassDeclaration for this type to attach methods
ClassDeclaration* targetCls = nullptr;
auto& classes = module->getChildren("classes");
for (auto* entry : classes) {
auto* cls = dynamic_cast<ClassDeclaration*>(entry);
if (cls && cls->name == typeName) {
targetCls = cls;
break;
}
}
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);
if (nodeType(child) == "function_item" || nodeType(child) == "function_signature_item") {
// Backward compat: add as Function to module.functions
auto* fn = convertRustFunction(child, source, typeName);
if (fn) module->addChild("functions", fn);
// If we have a ClassDeclaration, also add MethodDeclaration
if (targetCls) {
auto* meth = convertRustMethodDecl(child, source, typeName);
if (meth) targetCls->addChild("methods", meth);
}
}
}
}
static MethodDeclaration* convertRustMethodDecl(TSNode node,
const std::string& source,
const std::string& typeName) {
TSNode nameNode = childByFieldName(node, "name");
if (ts_node_is_null(nameNode)) return nullptr;
auto* meth = new MethodDeclaration(IdGenerator::next("meth"), nodeText(nameNode, source));
applySpan(meth, node);
meth->className = typeName;
// Check visibility modifiers
uint32_t allCount = ts_node_named_child_count(node);
for (uint32_t i = 0; i < allCount; ++i) {
TSNode ch = ts_node_named_child(node, i);
if (nodeType(ch) == "visibility_modifier") {
meth->visibility = "public";
}
}
TSNode paramsNode = childByFieldName(node, "parameters");
if (!ts_node_is_null(paramsNode)) {
convertRustParameters(paramsNode, source, meth);
}
TSNode retNode = childByFieldName(node, "return_type");
if (!ts_node_is_null(retNode)) {
if (auto* t = convertRustType(retNode, source)) meth->setChild("returnType", t);
}
TSNode bodyNode = childByFieldName(node, "body");
if (!ts_node_is_null(bodyNode)) {
convertRustBlock(bodyNode, source, meth);
}
return meth;
}
static Function* convertRustFunction(TSNode node,
const std::string& source,
const std::string& receiverType) {
TSNode nameNode = childByFieldName(node, "name");
if (ts_node_is_null(nameNode)) return nullptr;
auto* fn = new Function();
fn->id = IdGenerator::next("fn");
applySpan(fn, node);
// Detect async keyword
bool isAsync = rustNodeHasAsyncKeyword(node, source);
Function* fn;
std::string name = nodeText(nameNode, source);
if (!receiverType.empty()) {
fn->name = receiverType + "." + name;
if (!receiverType.empty()) name = receiverType + "." + name;
if (isAsync) {
fn = new AsyncFunction(IdGenerator::next("fn"), name);
} else {
fn = new Function();
fn->id = IdGenerator::next("fn");
fn->name = name;
}
applySpan(fn, node);
TSNode paramsNode = childByFieldName(node, "parameters");
if (!ts_node_is_null(paramsNode)) {
@@ -130,6 +271,18 @@ private:
return fn;
}
static bool rustNodeHasAsyncKeyword(TSNode node, const std::string& source) {
uint32_t totalCount = ts_node_child_count(node);
for (uint32_t i = 0; i < totalCount; ++i) {
TSNode ch = ts_node_child(node, i);
if (!ts_node_is_named(ch) && nodeText(ch, source) == "async") return true;
}
// Fallback: check source text prefix
std::string fullText = nodeText(node, source);
if (fullText.substr(0, 6) == "async ") return true;
return false;
}
static void convertRustParameters(TSNode paramsNode,
const std::string& source,
Function* fn) {
@@ -367,6 +520,51 @@ private:
if (idx) access->setChild("index", idx);
}
return access;
} else if (type == "closure_expression") {
auto* lam = new LambdaExpression(IdGenerator::next("lam"));
applySpan(lam, node);
TSNode paramsNode = childByFieldName(node, "parameters");
if (!ts_node_is_null(paramsNode)) {
uint32_t pc = ts_node_named_child_count(paramsNode);
for (uint32_t pi = 0; pi < pc; ++pi) {
TSNode pChild = ts_node_named_child(paramsNode, pi);
std::string pType = nodeType(pChild);
std::string paramName;
if (pType == "identifier") {
paramName = nodeText(pChild, source);
} else if (pType == "parameter") {
TSNode pName = childByFieldName(pChild, "pattern");
if (ts_node_is_null(pName)) pName = pChild;
paramName = nodeText(pName, source);
} else {
paramName = nodeText(pChild, source);
}
if (!paramName.empty()) {
auto* param = new Parameter(IdGenerator::next("param"), paramName);
applySpan(param, pChild);
lam->addChild("parameters", param);
}
}
}
TSNode bodyNode = childByFieldName(node, "body");
if (!ts_node_is_null(bodyNode)) {
if (nodeType(bodyNode) == "block") {
uint32_t bc = ts_node_named_child_count(bodyNode);
for (uint32_t bi = 0; bi < bc; ++bi) {
ASTNode* stmt = convertRustStatement(ts_node_named_child(bodyNode, bi), source);
if (stmt) lam->addChild("body", stmt);
}
} else {
ASTNode* expr = convertRustExpression(bodyNode, source);
if (expr) {
auto* exprStmt = new ExpressionStatement();
exprStmt->id = IdGenerator::next("exprstmt");
exprStmt->setChild("expression", expr);
lam->addChild("body", exprStmt);
}
}
}
return lam;
} else if (type == "identifier") {
auto* ref = new VariableReference(IdGenerator::next("var"), nodeText(node, source));
applySpan(ref, node);