320 lines
11 KiB
C++
320 lines
11 KiB
C++
// Step 306: TypeScript/JavaScript + Rust Parser Deepening (12 tests)
|
|
// Tests that JS/TS and Rust parsers correctly produce the new AST node
|
|
// types: ClassDeclaration, InterfaceDeclaration, MethodDeclaration,
|
|
// AsyncFunction, AwaitExpression, LambdaExpression via tree-sitter parsing.
|
|
|
|
#include "ast/Parser.h"
|
|
#include "ast/ClassDeclaration.h"
|
|
#include "ast/GenericType.h"
|
|
#include "ast/AsyncNodes.h"
|
|
#include "ast/Module.h"
|
|
#include "ast/Function.h"
|
|
#include "ast/Variable.h"
|
|
#include "ast/Parameter.h"
|
|
#include "ast/Statement.h"
|
|
#include "ast/Expression.h"
|
|
#include <iostream>
|
|
#include <string>
|
|
#include <memory>
|
|
#include <functional>
|
|
|
|
static int passed = 0, failed = 0;
|
|
#define TEST(name) { std::cout << " " << #name << "... "; }
|
|
#define PASS() { std::cout << "PASS\n"; ++passed; }
|
|
#define FAIL(msg) { std::cout << "FAIL: " << msg << "\n"; ++failed; }
|
|
#define CHECK(cond, msg) if (!(cond)) { FAIL(msg); return; } else {}
|
|
|
|
// Helper: recursively find a node of a given conceptType
|
|
static bool findNodeOfType(ASTNode* node, const std::string& type) {
|
|
if (!node) return false;
|
|
if (node->conceptType == type) return true;
|
|
for (auto* child : node->allChildren()) {
|
|
if (findNodeOfType(child, type)) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// ---------------------------------------------------------------
|
|
// JavaScript/TypeScript tests (1-6)
|
|
// ---------------------------------------------------------------
|
|
|
|
// 1. JS backward compat — simple function still yields Function
|
|
void test_js_backward_compat() {
|
|
TEST(js_backward_compat);
|
|
std::string src = "function greet(name) {\n return name;\n}\n";
|
|
auto mod = TreeSitterParser::parseJavaScript(src);
|
|
CHECK(mod != nullptr, "module null");
|
|
|
|
auto& fns = mod->getChildren("functions");
|
|
CHECK(!fns.empty(), "expected at least one function");
|
|
CHECK(fns[0]->conceptType == "Function", "expected Function, got " + fns[0]->conceptType);
|
|
auto* fn0 = dynamic_cast<Function*>(fns[0]);
|
|
CHECK(fn0 != nullptr, "dynamic_cast to Function failed");
|
|
CHECK(fn0->name == "greet", "expected name 'greet', got " + fn0->name);
|
|
PASS();
|
|
}
|
|
|
|
// 2. JS class → ClassDeclaration with superclass and MethodDeclaration
|
|
void test_js_class() {
|
|
TEST(js_class);
|
|
std::string src =
|
|
"class Animal extends LivingThing {\n"
|
|
" speak() {\n"
|
|
" return \"...\";\n"
|
|
" }\n"
|
|
"}\n";
|
|
auto mod = TreeSitterParser::parseJavaScript(src);
|
|
CHECK(mod != nullptr, "module null");
|
|
|
|
auto& classes = mod->getChildren("classes");
|
|
CHECK(!classes.empty(), "expected at least one class");
|
|
CHECK(classes[0]->conceptType == "ClassDeclaration",
|
|
"expected ClassDeclaration, got " + classes[0]->conceptType);
|
|
|
|
auto* cls = dynamic_cast<ClassDeclaration*>(classes[0]);
|
|
CHECK(cls != nullptr, "dynamic_cast to ClassDeclaration failed");
|
|
CHECK(cls->name == "Animal", "expected name 'Animal', got " + cls->name);
|
|
CHECK(cls->superClass == "LivingThing",
|
|
"expected superClass 'LivingThing', got " + cls->superClass);
|
|
|
|
auto& methods = cls->getChildren("methods");
|
|
CHECK(!methods.empty(), "expected at least one method");
|
|
auto* meth = dynamic_cast<MethodDeclaration*>(methods[0]);
|
|
CHECK(meth != nullptr, "dynamic_cast to MethodDeclaration failed");
|
|
CHECK(meth->name == "speak", "expected method 'speak', got " + meth->name);
|
|
CHECK(meth->className == "Animal", "expected className 'Animal', got " + meth->className);
|
|
PASS();
|
|
}
|
|
|
|
// 3. JS async function → AsyncFunction
|
|
void test_js_async_function() {
|
|
TEST(js_async_function);
|
|
std::string src = "async function fetchData() {\n return 42;\n}\n";
|
|
auto mod = TreeSitterParser::parseJavaScript(src);
|
|
CHECK(mod != nullptr, "module null");
|
|
|
|
auto& fns = mod->getChildren("functions");
|
|
CHECK(!fns.empty(), "expected at least one function");
|
|
|
|
auto* af = dynamic_cast<AsyncFunction*>(fns[0]);
|
|
CHECK(af != nullptr, "expected AsyncFunction, got " + fns[0]->conceptType);
|
|
CHECK(af->name == "fetchData", "expected name 'fetchData', got " + af->name);
|
|
CHECK(af->isAsync, "isAsync should be true");
|
|
PASS();
|
|
}
|
|
|
|
// 4. JS await expression → AwaitExpression in body
|
|
void test_js_await() {
|
|
TEST(js_await);
|
|
std::string src =
|
|
"async function load() {\n"
|
|
" const result = await getData();\n"
|
|
"}\n";
|
|
auto mod = TreeSitterParser::parseJavaScript(src);
|
|
CHECK(mod != nullptr, "module null");
|
|
|
|
auto& fns = mod->getChildren("functions");
|
|
CHECK(!fns.empty(), "expected function");
|
|
|
|
CHECK(findNodeOfType(fns[0], "AwaitExpression"),
|
|
"expected AwaitExpression in function body");
|
|
PASS();
|
|
}
|
|
|
|
// 5. JS arrow function in expression context → LambdaExpression
|
|
void test_js_arrow_lambda() {
|
|
TEST(js_arrow_lambda);
|
|
std::string src =
|
|
"function make() {\n"
|
|
" const fn = (x) => x + 1;\n"
|
|
"}\n";
|
|
auto mod = TreeSitterParser::parseJavaScript(src);
|
|
CHECK(mod != nullptr, "module null");
|
|
|
|
// The top-level function "make" should be in functions
|
|
auto& fns = mod->getChildren("functions");
|
|
CHECK(!fns.empty(), "expected function");
|
|
|
|
// Walk body looking for LambdaExpression
|
|
CHECK(findNodeOfType(fns[0], "LambdaExpression"),
|
|
"expected LambdaExpression from arrow function in body");
|
|
PASS();
|
|
}
|
|
|
|
// 6. TypeScript class — same as JS but through TS parser
|
|
void test_ts_class() {
|
|
TEST(ts_class);
|
|
std::string src =
|
|
"class Service {\n"
|
|
" process(data: string): void {\n"
|
|
" console.log(data);\n"
|
|
" }\n"
|
|
"}\n";
|
|
auto mod = TreeSitterParser::parseTypeScript(src);
|
|
CHECK(mod != nullptr, "module null");
|
|
|
|
auto& classes = mod->getChildren("classes");
|
|
CHECK(!classes.empty(), "expected at least one class");
|
|
|
|
auto* cls = dynamic_cast<ClassDeclaration*>(classes[0]);
|
|
CHECK(cls != nullptr, "expected ClassDeclaration, got " + classes[0]->conceptType);
|
|
CHECK(cls->name == "Service", "expected name 'Service', got " + cls->name);
|
|
|
|
auto& methods = cls->getChildren("methods");
|
|
CHECK(!methods.empty(), "expected at least one method");
|
|
auto* meth = dynamic_cast<MethodDeclaration*>(methods[0]);
|
|
CHECK(meth != nullptr, "expected MethodDeclaration");
|
|
CHECK(meth->name == "process", "expected method 'process', got " + meth->name);
|
|
PASS();
|
|
}
|
|
|
|
// ---------------------------------------------------------------
|
|
// Rust tests (7-12)
|
|
// ---------------------------------------------------------------
|
|
|
|
// 7. Rust backward compat — function still yields Function
|
|
void test_rust_backward_compat() {
|
|
TEST(rust_backward_compat);
|
|
std::string src = "fn greet(name: &str) -> String {\n name.to_string()\n}\n";
|
|
auto mod = TreeSitterParser::parseRust(src);
|
|
CHECK(mod != nullptr, "module null");
|
|
|
|
auto& fns = mod->getChildren("functions");
|
|
CHECK(!fns.empty(), "expected at least one function");
|
|
auto* fn0 = dynamic_cast<Function*>(fns[0]);
|
|
CHECK(fn0 != nullptr, "dynamic_cast to Function failed");
|
|
CHECK(fn0->name == "greet", "expected name 'greet', got " + fn0->name);
|
|
PASS();
|
|
}
|
|
|
|
// 8. Rust struct → ClassDeclaration
|
|
void test_rust_struct() {
|
|
TEST(rust_struct);
|
|
std::string src =
|
|
"struct Point {\n"
|
|
" x: f64,\n"
|
|
" y: f64,\n"
|
|
"}\n";
|
|
auto mod = TreeSitterParser::parseRust(src);
|
|
CHECK(mod != nullptr, "module null");
|
|
|
|
auto& classes = mod->getChildren("classes");
|
|
CHECK(!classes.empty(), "expected at least one class");
|
|
|
|
auto* cls = dynamic_cast<ClassDeclaration*>(classes[0]);
|
|
CHECK(cls != nullptr, "expected ClassDeclaration, got " + classes[0]->conceptType);
|
|
CHECK(cls->name == "Point", "expected name 'Point', got " + cls->name);
|
|
PASS();
|
|
}
|
|
|
|
// 9. Rust trait → InterfaceDeclaration
|
|
void test_rust_trait() {
|
|
TEST(rust_trait);
|
|
std::string src =
|
|
"trait Drawable {\n"
|
|
" fn draw(&self);\n"
|
|
"}\n";
|
|
auto mod = TreeSitterParser::parseRust(src);
|
|
CHECK(mod != nullptr, "module null");
|
|
|
|
auto& classes = mod->getChildren("classes");
|
|
bool foundTrait = false;
|
|
for (auto* entry : classes) {
|
|
if (entry->conceptType == "InterfaceDeclaration") {
|
|
auto* iface = dynamic_cast<InterfaceDeclaration*>(entry);
|
|
CHECK(iface != nullptr, "dynamic_cast to InterfaceDeclaration failed");
|
|
CHECK(iface->name == "Drawable", "expected name 'Drawable', got " + iface->name);
|
|
foundTrait = true;
|
|
break;
|
|
}
|
|
}
|
|
CHECK(foundTrait, "expected InterfaceDeclaration in classes");
|
|
PASS();
|
|
}
|
|
|
|
// 10. Rust impl → MethodDeclaration on ClassDeclaration
|
|
void test_rust_impl_methods() {
|
|
TEST(rust_impl_methods);
|
|
std::string src =
|
|
"struct Dog {\n"
|
|
" name: String,\n"
|
|
"}\n"
|
|
"\n"
|
|
"impl Dog {\n"
|
|
" fn bark(&self) {\n"
|
|
" println!(\"Woof!\");\n"
|
|
" }\n"
|
|
"}\n";
|
|
auto mod = TreeSitterParser::parseRust(src);
|
|
CHECK(mod != nullptr, "module null");
|
|
|
|
auto& classes = mod->getChildren("classes");
|
|
CHECK(!classes.empty(), "expected class from struct");
|
|
|
|
auto* cls = dynamic_cast<ClassDeclaration*>(classes[0]);
|
|
CHECK(cls != nullptr, "expected ClassDeclaration");
|
|
CHECK(cls->name == "Dog", "expected name 'Dog', got " + cls->name);
|
|
|
|
auto& methods = cls->getChildren("methods");
|
|
CHECK(!methods.empty(), "expected at least one method from impl");
|
|
|
|
auto* meth = dynamic_cast<MethodDeclaration*>(methods[0]);
|
|
CHECK(meth != nullptr, "expected MethodDeclaration");
|
|
CHECK(meth->name == "bark", "expected method 'bark', got " + meth->name);
|
|
CHECK(meth->className == "Dog", "expected className 'Dog', got " + meth->className);
|
|
PASS();
|
|
}
|
|
|
|
// 11. Rust async fn → AsyncFunction
|
|
void test_rust_async_function() {
|
|
TEST(rust_async_function);
|
|
std::string src = "async fn fetch_data() -> String {\n String::new()\n}\n";
|
|
auto mod = TreeSitterParser::parseRust(src);
|
|
CHECK(mod != nullptr, "module null");
|
|
|
|
auto& fns = mod->getChildren("functions");
|
|
CHECK(!fns.empty(), "expected at least one function");
|
|
|
|
auto* af = dynamic_cast<AsyncFunction*>(fns[0]);
|
|
CHECK(af != nullptr, "expected AsyncFunction, got " + fns[0]->conceptType);
|
|
CHECK(af->name == "fetch_data", "expected name 'fetch_data', got " + af->name);
|
|
CHECK(af->isAsync, "isAsync should be true");
|
|
PASS();
|
|
}
|
|
|
|
// 12. Rust closure → LambdaExpression
|
|
void test_rust_closure() {
|
|
TEST(rust_closure);
|
|
std::string src =
|
|
"fn make() {\n"
|
|
" let add = |x, y| x + y;\n"
|
|
"}\n";
|
|
auto mod = TreeSitterParser::parseRust(src);
|
|
CHECK(mod != nullptr, "module null");
|
|
|
|
auto& fns = mod->getChildren("functions");
|
|
CHECK(!fns.empty(), "expected function");
|
|
|
|
CHECK(findNodeOfType(fns[0], "LambdaExpression"),
|
|
"expected LambdaExpression from closure in function body");
|
|
PASS();
|
|
}
|
|
|
|
int main() {
|
|
std::cout << "=== Step 306: TypeScript/JavaScript + Rust Parser Deepening ===\n";
|
|
test_js_backward_compat();
|
|
test_js_class();
|
|
test_js_async_function();
|
|
test_js_await();
|
|
test_js_arrow_lambda();
|
|
test_ts_class();
|
|
test_rust_backward_compat();
|
|
test_rust_struct();
|
|
test_rust_trait();
|
|
test_rust_impl_methods();
|
|
test_rust_async_function();
|
|
test_rust_closure();
|
|
std::cout << "\nResults: " << passed << "/" << (passed + failed) << " passed\n";
|
|
return failed > 0 ? 1 : 0;
|
|
}
|