356 lines
13 KiB
C++
356 lines
13 KiB
C++
|
// Step 305: Python + Java Parser Deepening (12 tests)
|
||
|
|
// Tests that PythonParser and JavaParser correctly produce the new AST node
|
||
|
|
// types: ClassDeclaration, InterfaceDeclaration, MethodDeclaration,
|
||
|
|
// AsyncFunction, AwaitExpression, LambdaExpression, DecoratorAnnotation,
|
||
|
|
// and TypeParameter via tree-sitter parsing of real source strings.
|
||
|
|
|
||
|
|
#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 <vector>
|
||
|
|
#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 {}
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------
|
||
|
|
// Python tests (1-6)
|
||
|
|
// ---------------------------------------------------------------
|
||
|
|
|
||
|
|
// 1. Python backward compat — simple function still yields Function
|
||
|
|
void test_python_backward_compat() {
|
||
|
|
TEST(python_backward_compat);
|
||
|
|
std::string src = "def greet(name):\n return name\n";
|
||
|
|
auto mod = TreeSitterParser::parsePython(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. Python class — class_definition yields ClassDeclaration
|
||
|
|
void test_python_class() {
|
||
|
|
TEST(python_class);
|
||
|
|
std::string src =
|
||
|
|
"class Animal(LivingThing):\n"
|
||
|
|
" def speak(self):\n"
|
||
|
|
" return \"...\"\n";
|
||
|
|
auto mod = TreeSitterParser::parsePython(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. Python async function — async def yields AsyncFunction
|
||
|
|
void test_python_async_function() {
|
||
|
|
TEST(python_async_function);
|
||
|
|
std::string src = "async def fetch_data():\n pass\n";
|
||
|
|
auto mod = TreeSitterParser::parsePython(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, dynamic_cast failed (got " + fns[0]->conceptType + ")");
|
||
|
|
CHECK(af->name == "fetch_data", "expected name 'fetch_data', got " + af->name);
|
||
|
|
CHECK(af->isAsync, "isAsync should be true");
|
||
|
|
PASS();
|
||
|
|
}
|
||
|
|
|
||
|
|
// 4. Python await — await expression in body yields AwaitExpression
|
||
|
|
void test_python_await() {
|
||
|
|
TEST(python_await);
|
||
|
|
std::string src =
|
||
|
|
"async def load():\n"
|
||
|
|
" result = await get_data()\n";
|
||
|
|
auto mod = TreeSitterParser::parsePython(src);
|
||
|
|
CHECK(mod != nullptr, "module null");
|
||
|
|
|
||
|
|
auto& fns = mod->getChildren("functions");
|
||
|
|
CHECK(!fns.empty(), "expected function");
|
||
|
|
|
||
|
|
// The body should contain a statement with an await expression somewhere
|
||
|
|
auto& body = fns[0]->getChildren("body");
|
||
|
|
CHECK(!body.empty(), "expected body statements");
|
||
|
|
|
||
|
|
// Walk body looking for an AwaitExpression
|
||
|
|
bool foundAwait = false;
|
||
|
|
std::function<void(ASTNode*)> findAwait = [&](ASTNode* node) {
|
||
|
|
if (!node) return;
|
||
|
|
if (node->conceptType == "AwaitExpression") { foundAwait = true; return; }
|
||
|
|
for (auto* child : node->allChildren()) findAwait(child);
|
||
|
|
};
|
||
|
|
for (auto* stmt : body) findAwait(stmt);
|
||
|
|
|
||
|
|
CHECK(foundAwait, "expected AwaitExpression in function body");
|
||
|
|
PASS();
|
||
|
|
}
|
||
|
|
|
||
|
|
// 5. Python lambda — lambda expression yields LambdaExpression
|
||
|
|
void test_python_lambda() {
|
||
|
|
TEST(python_lambda);
|
||
|
|
std::string src =
|
||
|
|
"def make():\n"
|
||
|
|
" return lambda x: x + 1\n";
|
||
|
|
auto mod = TreeSitterParser::parsePython(src);
|
||
|
|
CHECK(mod != nullptr, "module null");
|
||
|
|
|
||
|
|
auto& fns = mod->getChildren("functions");
|
||
|
|
CHECK(!fns.empty(), "expected function");
|
||
|
|
|
||
|
|
// Walk body looking for LambdaExpression
|
||
|
|
bool foundLambda = false;
|
||
|
|
std::string lambdaType;
|
||
|
|
std::function<void(ASTNode*)> findLambda = [&](ASTNode* node) {
|
||
|
|
if (!node) return;
|
||
|
|
if (node->conceptType == "LambdaExpression") {
|
||
|
|
foundLambda = true;
|
||
|
|
lambdaType = node->conceptType;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
for (auto* child : node->allChildren()) findLambda(child);
|
||
|
|
};
|
||
|
|
auto& body = fns[0]->getChildren("body");
|
||
|
|
for (auto* stmt : body) findLambda(stmt);
|
||
|
|
|
||
|
|
CHECK(foundLambda, "expected LambdaExpression in function body");
|
||
|
|
PASS();
|
||
|
|
}
|
||
|
|
|
||
|
|
// 6. Python decorator — @decorator yields DecoratorAnnotation
|
||
|
|
void test_python_decorator() {
|
||
|
|
TEST(python_decorator);
|
||
|
|
std::string src =
|
||
|
|
"@cache\n"
|
||
|
|
"def expensive():\n"
|
||
|
|
" return 42\n";
|
||
|
|
auto mod = TreeSitterParser::parsePython(src);
|
||
|
|
CHECK(mod != nullptr, "module null");
|
||
|
|
|
||
|
|
auto& fns = mod->getChildren("functions");
|
||
|
|
CHECK(!fns.empty(), "expected function");
|
||
|
|
|
||
|
|
// The function should have a DecoratorAnnotation in annotations
|
||
|
|
auto& annos = fns[0]->getChildren("annotations");
|
||
|
|
bool foundDecorator = false;
|
||
|
|
for (auto* anno : annos) {
|
||
|
|
if (anno->conceptType == "DecoratorAnnotation") {
|
||
|
|
auto* dec = dynamic_cast<DecoratorAnnotation*>(anno);
|
||
|
|
CHECK(dec != nullptr, "dynamic_cast to DecoratorAnnotation failed");
|
||
|
|
CHECK(dec->name == "cache", "expected decorator 'cache', got " + dec->name);
|
||
|
|
foundDecorator = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
CHECK(foundDecorator, "expected DecoratorAnnotation on function");
|
||
|
|
PASS();
|
||
|
|
}
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------
|
||
|
|
// Java tests (7-12)
|
||
|
|
// ---------------------------------------------------------------
|
||
|
|
|
||
|
|
// 7. Java backward compat — method still appears as Function in module.functions
|
||
|
|
void test_java_backward_compat() {
|
||
|
|
TEST(java_backward_compat);
|
||
|
|
std::string src =
|
||
|
|
"class Dog {\n"
|
||
|
|
" void bark() { }\n"
|
||
|
|
"}\n";
|
||
|
|
auto mod = TreeSitterParser::parseJava(src);
|
||
|
|
CHECK(mod != nullptr, "module null");
|
||
|
|
|
||
|
|
auto& fns = mod->getChildren("functions");
|
||
|
|
CHECK(!fns.empty(), "expected at least one function (backward compat)");
|
||
|
|
|
||
|
|
bool found = false;
|
||
|
|
for (auto* fn : fns) {
|
||
|
|
auto* func = dynamic_cast<Function*>(fn);
|
||
|
|
if (func && func->name.find("bark") != std::string::npos) { found = true; break; }
|
||
|
|
}
|
||
|
|
CHECK(found, "expected a Function with 'bark' in name");
|
||
|
|
PASS();
|
||
|
|
}
|
||
|
|
|
||
|
|
// 8. Java ClassDeclaration — class parsed into classes child
|
||
|
|
void test_java_class_declaration() {
|
||
|
|
TEST(java_class_declaration);
|
||
|
|
std::string src =
|
||
|
|
"class Dog extends Animal {\n"
|
||
|
|
" void bark() { }\n"
|
||
|
|
"}\n";
|
||
|
|
auto mod = TreeSitterParser::parseJava(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, "dynamic_cast to ClassDeclaration failed (got " + classes[0]->conceptType + ")");
|
||
|
|
CHECK(cls->name == "Dog", "expected name 'Dog', got " + cls->name);
|
||
|
|
CHECK(cls->superClass == "Animal", "expected superClass 'Animal', got " + cls->superClass);
|
||
|
|
PASS();
|
||
|
|
}
|
||
|
|
|
||
|
|
// 9. Java InterfaceDeclaration — interface parsed into classes child
|
||
|
|
void test_java_interface_declaration() {
|
||
|
|
TEST(java_interface_declaration);
|
||
|
|
std::string src =
|
||
|
|
"interface Drawable {\n"
|
||
|
|
" void draw();\n"
|
||
|
|
"}\n";
|
||
|
|
auto mod = TreeSitterParser::parseJava(src);
|
||
|
|
CHECK(mod != nullptr, "module null");
|
||
|
|
|
||
|
|
auto& classes = mod->getChildren("classes");
|
||
|
|
CHECK(!classes.empty(), "expected at least one class/interface entry");
|
||
|
|
|
||
|
|
bool foundIface = 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);
|
||
|
|
foundIface = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
CHECK(foundIface, "expected InterfaceDeclaration in classes");
|
||
|
|
PASS();
|
||
|
|
}
|
||
|
|
|
||
|
|
// 10. Java MethodDeclaration — method as child of ClassDeclaration
|
||
|
|
void test_java_method_declaration() {
|
||
|
|
TEST(java_method_declaration);
|
||
|
|
std::string src =
|
||
|
|
"class Service {\n"
|
||
|
|
" public static void process() { }\n"
|
||
|
|
"}\n";
|
||
|
|
auto mod = TreeSitterParser::parseJava(src);
|
||
|
|
CHECK(mod != nullptr, "module null");
|
||
|
|
|
||
|
|
auto& classes = mod->getChildren("classes");
|
||
|
|
CHECK(!classes.empty(), "expected class");
|
||
|
|
|
||
|
|
auto* cls = dynamic_cast<ClassDeclaration*>(classes[0]);
|
||
|
|
CHECK(cls != nullptr, "expected ClassDeclaration");
|
||
|
|
|
||
|
|
auto& methods = cls->getChildren("methods");
|
||
|
|
CHECK(!methods.empty(), "expected at least one method in class");
|
||
|
|
|
||
|
|
auto* meth = dynamic_cast<MethodDeclaration*>(methods[0]);
|
||
|
|
CHECK(meth != nullptr, "dynamic_cast to MethodDeclaration failed");
|
||
|
|
CHECK(meth->name == "process", "expected method 'process', got " + meth->name);
|
||
|
|
CHECK(meth->className == "Service", "expected className 'Service', got " + meth->className);
|
||
|
|
CHECK(meth->isStatic, "expected isStatic=true for 'public static'");
|
||
|
|
CHECK(meth->visibility == "public", "expected visibility 'public', got " + meth->visibility);
|
||
|
|
PASS();
|
||
|
|
}
|
||
|
|
|
||
|
|
// 11. Java lambda — lambda expression yields LambdaExpression
|
||
|
|
void test_java_lambda() {
|
||
|
|
TEST(java_lambda);
|
||
|
|
std::string src =
|
||
|
|
"class App {\n"
|
||
|
|
" void run() {\n"
|
||
|
|
" Runnable r = () -> { };\n"
|
||
|
|
" }\n"
|
||
|
|
"}\n";
|
||
|
|
auto mod = TreeSitterParser::parseJava(src);
|
||
|
|
CHECK(mod != nullptr, "module null");
|
||
|
|
|
||
|
|
// Walk entire AST looking for LambdaExpression
|
||
|
|
bool foundLambda = false;
|
||
|
|
std::function<void(ASTNode*)> findLambda = [&](ASTNode* node) {
|
||
|
|
if (!node) return;
|
||
|
|
if (node->conceptType == "LambdaExpression") { foundLambda = true; return; }
|
||
|
|
for (auto* child : node->allChildren()) findLambda(child);
|
||
|
|
};
|
||
|
|
findLambda(mod.get());
|
||
|
|
|
||
|
|
CHECK(foundLambda, "expected LambdaExpression somewhere in AST");
|
||
|
|
PASS();
|
||
|
|
}
|
||
|
|
|
||
|
|
// 12. Java generic class — type parameters yield TypeParameter children
|
||
|
|
void test_java_generic_class() {
|
||
|
|
TEST(java_generic_class);
|
||
|
|
std::string src =
|
||
|
|
"class Box<T extends Comparable> {\n"
|
||
|
|
" T value;\n"
|
||
|
|
"}\n";
|
||
|
|
auto mod = TreeSitterParser::parseJava(src);
|
||
|
|
CHECK(mod != nullptr, "module null");
|
||
|
|
|
||
|
|
auto& classes = mod->getChildren("classes");
|
||
|
|
CHECK(!classes.empty(), "expected class");
|
||
|
|
|
||
|
|
auto* cls = dynamic_cast<ClassDeclaration*>(classes[0]);
|
||
|
|
CHECK(cls != nullptr, "expected ClassDeclaration");
|
||
|
|
CHECK(cls->name == "Box", "expected name 'Box', got " + cls->name);
|
||
|
|
|
||
|
|
auto& typeParams = cls->getChildren("typeParameters");
|
||
|
|
CHECK(!typeParams.empty(), "expected at least one TypeParameter");
|
||
|
|
|
||
|
|
auto* tp = dynamic_cast<TypeParameter*>(typeParams[0]);
|
||
|
|
CHECK(tp != nullptr, "dynamic_cast to TypeParameter failed");
|
||
|
|
CHECK(tp->name == "T", "expected type param 'T', got " + tp->name);
|
||
|
|
CHECK(tp->constraint == "Comparable",
|
||
|
|
"expected constraint 'Comparable', got " + tp->constraint);
|
||
|
|
PASS();
|
||
|
|
}
|
||
|
|
|
||
|
|
int main() {
|
||
|
|
std::cout << "=== Step 305: Python + Java Parser Deepening ===\n";
|
||
|
|
test_python_backward_compat();
|
||
|
|
test_python_class();
|
||
|
|
test_python_async_function();
|
||
|
|
test_python_await();
|
||
|
|
test_python_lambda();
|
||
|
|
test_python_decorator();
|
||
|
|
test_java_backward_compat();
|
||
|
|
test_java_class_declaration();
|
||
|
|
test_java_interface_declaration();
|
||
|
|
test_java_method_declaration();
|
||
|
|
test_java_lambda();
|
||
|
|
test_java_generic_class();
|
||
|
|
std::cout << "\nResults: " << passed << "/" << (passed + failed) << " passed\n";
|
||
|
|
return failed > 0 ? 1 : 0;
|
||
|
|
}
|