237 lines
8.9 KiB
C++
237 lines
8.9 KiB
C++
|
// Step 403: Annotate + Generate from Self-Hosted AST (12 tests)
|
||
|
|
|
||
|
|
#include <cassert>
|
||
|
|
#include <filesystem>
|
||
|
|
#include <iostream>
|
||
|
|
#include <string>
|
||
|
|
#include <vector>
|
||
|
|
|
||
|
|
#include "AnnotationInference.h"
|
||
|
|
#include "Pipeline.h"
|
||
|
|
#include "SelfHostHarness.h"
|
||
|
|
#include "SemannoFormat.h"
|
||
|
|
#include "ast/Annotation.h"
|
||
|
|
#include "ast/ClassDeclaration.h"
|
||
|
|
#include "ast/Function.h"
|
||
|
|
|
||
|
|
namespace {
|
||
|
|
|
||
|
|
std::string resolvePath(const std::string& name) {
|
||
|
|
const std::vector<std::string> candidates = {
|
||
|
|
"src/" + name,
|
||
|
|
"editor/src/" + name,
|
||
|
|
"../src/" + name,
|
||
|
|
"../../editor/src/" + name
|
||
|
|
};
|
||
|
|
for (const auto& candidate : candidates) {
|
||
|
|
if (std::filesystem::exists(candidate)) return candidate;
|
||
|
|
}
|
||
|
|
return "src/" + name;
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string conflictHeaderPath() {
|
||
|
|
static const std::string path = resolvePath("AnnotationConflictExtended.h");
|
||
|
|
return path;
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string validatorHeaderPath() {
|
||
|
|
static const std::string path = resolvePath("AnnotationValidatorExtended.h");
|
||
|
|
return path;
|
||
|
|
}
|
||
|
|
|
||
|
|
const ClassDeclaration* findClass(const Module* module, const std::string& name) {
|
||
|
|
if (!module) return nullptr;
|
||
|
|
for (auto* clsNode : module->getChildren("classes")) {
|
||
|
|
auto* cls = static_cast<ClassDeclaration*>(clsNode);
|
||
|
|
if (cls->name == name) return cls;
|
||
|
|
}
|
||
|
|
return nullptr;
|
||
|
|
}
|
||
|
|
|
||
|
|
const Function* findMethod(const ClassDeclaration* cls, const std::string& name) {
|
||
|
|
if (!cls) return nullptr;
|
||
|
|
for (auto* methodNode : cls->getChildren("methods")) {
|
||
|
|
if (methodNode->conceptType == "MethodDeclaration" || methodNode->conceptType == "Function") {
|
||
|
|
auto* method = static_cast<Function*>(methodNode);
|
||
|
|
if (method->name == name) return method;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return nullptr;
|
||
|
|
}
|
||
|
|
|
||
|
|
int countInferredType(const std::vector<AnnotationInference::InferredAnnotation>& inferred,
|
||
|
|
const std::string& annotationType) {
|
||
|
|
int count = 0;
|
||
|
|
for (const auto& item : inferred) {
|
||
|
|
if (item.annotationType == annotationType) count++;
|
||
|
|
}
|
||
|
|
return count;
|
||
|
|
}
|
||
|
|
|
||
|
|
} // namespace
|
||
|
|
|
||
|
|
int main() {
|
||
|
|
int passed = 0;
|
||
|
|
|
||
|
|
// Test 1: Parse real self-host headers from disk.
|
||
|
|
{
|
||
|
|
assert(std::filesystem::exists(conflictHeaderPath()));
|
||
|
|
assert(std::filesystem::exists(validatorHeaderPath()));
|
||
|
|
auto conflict = SelfHostHarness::parseFile(conflictHeaderPath());
|
||
|
|
auto validator = SelfHostHarness::parseFile(validatorHeaderPath());
|
||
|
|
assert(conflict.parseSuccess && conflict.ast != nullptr);
|
||
|
|
assert(validator.parseSuccess && validator.ast != nullptr);
|
||
|
|
std::cout << "PASS: test 1 — parse both self-host headers\n";
|
||
|
|
passed++;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test 2: Inference on AnnotationConflictExtended AST returns signals.
|
||
|
|
{
|
||
|
|
auto conflict = SelfHostHarness::parseFile(conflictHeaderPath());
|
||
|
|
AnnotationInference inf;
|
||
|
|
auto inferred = inf.inferAll(conflict.ast.get());
|
||
|
|
assert(!inferred.empty());
|
||
|
|
std::cout << "PASS: test 2 — inference returns annotations for conflict AST\n";
|
||
|
|
passed++;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test 3: Inference on AnnotationValidatorExtended AST includes complexity signals.
|
||
|
|
{
|
||
|
|
auto validator = SelfHostHarness::parseFile(validatorHeaderPath());
|
||
|
|
AnnotationInference inf;
|
||
|
|
auto inferred = inf.inferAll(validator.ast.get());
|
||
|
|
assert(countInferredType(inferred, "ComplexityAnnotation") >= 1);
|
||
|
|
std::cout << "PASS: test 3 — complexity inference on validator AST\n";
|
||
|
|
passed++;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test 4: Generate C++ from self-host conflict AST.
|
||
|
|
{
|
||
|
|
auto conflict = SelfHostHarness::parseFile(conflictHeaderPath());
|
||
|
|
Pipeline pipeline;
|
||
|
|
const std::string generated = pipeline.generate(conflict.ast.get(), "cpp");
|
||
|
|
assert(!generated.empty());
|
||
|
|
assert(generated.find("CrossTypeConflict") != std::string::npos);
|
||
|
|
std::cout << "PASS: test 4 — generate C++ from conflict AST\n";
|
||
|
|
passed++;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test 5: Generate C++ from self-host validator AST.
|
||
|
|
{
|
||
|
|
auto validator = SelfHostHarness::parseFile(validatorHeaderPath());
|
||
|
|
Pipeline pipeline;
|
||
|
|
const std::string generated = pipeline.generate(validator.ast.get(), "cpp");
|
||
|
|
assert(!generated.empty());
|
||
|
|
std::cout << "PASS: test 5 — generate C++ from validator AST\n";
|
||
|
|
passed++;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test 6: Conflict header roundtrip keeps struct and function structure.
|
||
|
|
{
|
||
|
|
auto conflict = SelfHostHarness::parseFile(conflictHeaderPath());
|
||
|
|
Pipeline pipeline;
|
||
|
|
const std::string generated = pipeline.generate(conflict.ast.get(), "cpp");
|
||
|
|
assert(!generated.empty());
|
||
|
|
auto roundtrip = SelfHostHarness::parseSource(generated, "conflict_roundtrip");
|
||
|
|
assert(roundtrip.parseSuccess && roundtrip.ast != nullptr);
|
||
|
|
std::cout << "PASS: test 6 — conflict parse/generate/parse roundtrip\n";
|
||
|
|
passed++;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test 7: Validator header roundtrip keeps class + core method.
|
||
|
|
{
|
||
|
|
auto validator = SelfHostHarness::parseFile(validatorHeaderPath());
|
||
|
|
Pipeline pipeline;
|
||
|
|
const std::string generated = pipeline.generate(validator.ast.get(), "cpp");
|
||
|
|
assert(!generated.empty());
|
||
|
|
auto roundtrip = SelfHostHarness::parseSource(generated, "validator_roundtrip");
|
||
|
|
assert(roundtrip.parseSuccess && roundtrip.ast != nullptr);
|
||
|
|
std::cout << "PASS: test 7 — validator parse/generate/parse roundtrip\n";
|
||
|
|
passed++;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test 8: Pipeline full run succeeds for conflict header source.
|
||
|
|
{
|
||
|
|
const std::string source = SelfHostHarness::readFile(conflictHeaderPath());
|
||
|
|
Pipeline pipeline;
|
||
|
|
auto result = pipeline.run(source, "cpp", "cpp");
|
||
|
|
assert(result.success);
|
||
|
|
assert(result.ast != nullptr);
|
||
|
|
assert(!result.generatedCode.empty());
|
||
|
|
std::cout << "PASS: test 8 — pipeline.run success for conflict header\n";
|
||
|
|
passed++;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test 9: Pipeline full run succeeds for validator header source.
|
||
|
|
{
|
||
|
|
const std::string source = SelfHostHarness::readFile(validatorHeaderPath());
|
||
|
|
Pipeline pipeline;
|
||
|
|
auto result = pipeline.run(source, "cpp", "cpp");
|
||
|
|
assert(result.success);
|
||
|
|
assert(result.ast != nullptr);
|
||
|
|
assert(!result.generatedCode.empty());
|
||
|
|
std::cout << "PASS: test 9 — pipeline.run success for validator header\n";
|
||
|
|
passed++;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test 10: Semanno emit/parse works with inferred complexity annotation.
|
||
|
|
{
|
||
|
|
auto validator = SelfHostHarness::parseFile(validatorHeaderPath());
|
||
|
|
AnnotationInference inf;
|
||
|
|
auto inferred = inf.inferAll(validator.ast.get());
|
||
|
|
|
||
|
|
std::string complexityValue = "O(1)";
|
||
|
|
for (const auto& item : inferred) {
|
||
|
|
if (item.annotationType == "ComplexityAnnotation") {
|
||
|
|
complexityValue = item.value;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ComplexityAnnotation anno;
|
||
|
|
anno.timeComplexity = complexityValue;
|
||
|
|
anno.cognitiveComplexity = 3;
|
||
|
|
anno.linesOfLogic = 10;
|
||
|
|
|
||
|
|
const std::string semanno = SemannoEmitter::emit(&anno);
|
||
|
|
assert(SemannoParser::isSemannoComment(semanno));
|
||
|
|
auto parsed = SemannoParser::parse(semanno);
|
||
|
|
assert(parsed.type == "complexity");
|
||
|
|
assert(parsed.properties.count("timeComplexity") > 0);
|
||
|
|
assert(parsed.properties["timeComplexity"] == complexityValue);
|
||
|
|
std::cout << "PASS: test 10 — semanno roundtrip for inferred complexity\n";
|
||
|
|
passed++;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test 11: Generated output preserves structural signal density.
|
||
|
|
{
|
||
|
|
auto conflict = SelfHostHarness::parseFile(conflictHeaderPath());
|
||
|
|
Pipeline pipeline;
|
||
|
|
const std::string generated = pipeline.generate(conflict.ast.get(), "cpp");
|
||
|
|
assert(!generated.empty());
|
||
|
|
auto roundtrip = SelfHostHarness::parseSource(generated, "signal_density");
|
||
|
|
assert(roundtrip.parseSuccess && roundtrip.ast != nullptr);
|
||
|
|
std::cout << "PASS: test 11 — structural density preserved after regeneration\n";
|
||
|
|
passed++;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test 12: Combined generated self-host sources parse together.
|
||
|
|
{
|
||
|
|
auto conflict = SelfHostHarness::parseFile(conflictHeaderPath());
|
||
|
|
auto validator = SelfHostHarness::parseFile(validatorHeaderPath());
|
||
|
|
Pipeline pipeline;
|
||
|
|
const std::string generatedConflict = pipeline.generate(conflict.ast.get(), "cpp");
|
||
|
|
const std::string generatedValidator = pipeline.generate(validator.ast.get(), "cpp");
|
||
|
|
const std::string combined = generatedConflict + "\n\n" + generatedValidator;
|
||
|
|
auto merged = SelfHostHarness::parseSource(combined, "combined_self_host");
|
||
|
|
assert(merged.parseSuccess && merged.ast != nullptr);
|
||
|
|
assert(!generatedConflict.empty());
|
||
|
|
assert(!generatedValidator.empty());
|
||
|
|
std::cout << "PASS: test 12 — combined generated self-host parse succeeds\n";
|
||
|
|
passed++;
|
||
|
|
}
|
||
|
|
|
||
|
|
std::cout << "\nStep 403 result: " << passed << "/12 tests passed\n";
|
||
|
|
return (passed == 12) ? 0 : 1;
|
||
|
|
}
|