irc: PrimOp memory leak and IR_VERSION mismatch
Signed-off-by: NotAShelf <raf@notashelf.dev> Change-Id: Iad057cd5f51ef26e7de93ccca7b3d3156a6a6964
This commit is contained in:
parent
f6481b3c01
commit
28de44c598
GPG key ID:
29D95B64378DB4BF
2 changed files with 420 additions and 69 deletions
|
|
@ -47,12 +47,11 @@ void test_enum_compatibility() {
|
|||
<< " (expected 0x34 or 0x33 with WITH=0x32)" << std::endl;
|
||||
}
|
||||
|
||||
if (IR_VERSION == 2) {
|
||||
std::cout << " PASS: IR_VERSION bumped to 2 for breaking change" << std::endl;
|
||||
} else if (static_cast<uint8_t>(NodeType::WITH) == 0x32) {
|
||||
std::cout << " PASS: IR_VERSION unchanged but WITH restored to 0x32" << std::endl;
|
||||
if (IR_VERSION == 3) {
|
||||
std::cout << " PASS: IR_VERSION is 3" << std::endl;
|
||||
} else {
|
||||
std::cerr << " FAIL: Either bump IR_VERSION or fix enum values" << std::endl;
|
||||
std::cerr << " FAIL: IR_VERSION should be 3, got " << IR_VERSION << std::endl;
|
||||
failures++;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -272,8 +271,358 @@ void test_float_node() {
|
|||
"Float value is approximately 3.14159");
|
||||
}
|
||||
|
||||
// LambdaPatternNode Tests
|
||||
void test_lambda_pattern_simple() {
|
||||
std::cout << "> LambdaPatternNode simple ({ a, b }: a + b)..." << std::endl;
|
||||
|
||||
// Body: a + b (using VarNode for a and b)
|
||||
auto var_a = std::make_shared<Node>(VarNode(0, "a"));
|
||||
auto var_b = std::make_shared<Node>(VarNode(0, "b"));
|
||||
auto body = std::make_shared<Node>(BinaryOpNode(BinaryOp::ADD, var_a, var_b));
|
||||
|
||||
// Create lambda pattern with two required fields
|
||||
LambdaPatternNode lambda_pattern(body);
|
||||
lambda_pattern.required_fields.emplace_back("a", std::nullopt);
|
||||
lambda_pattern.required_fields.emplace_back("b", std::nullopt);
|
||||
lambda_pattern.allow_extra = false;
|
||||
|
||||
auto node = std::make_shared<Node>(std::move(lambda_pattern));
|
||||
|
||||
// Serialize
|
||||
IRModule module;
|
||||
module.entry = node;
|
||||
Serializer ser;
|
||||
auto bytes = ser.serialize_to_bytes(module);
|
||||
|
||||
// Deserialize
|
||||
Deserializer deser;
|
||||
auto loaded = deser.deserialize(bytes);
|
||||
|
||||
// Verify
|
||||
auto* loaded_node = loaded.entry->get_if<LambdaPatternNode>();
|
||||
TEST_CHECK(loaded_node != nullptr, "Type is LambdaPatternNode");
|
||||
TEST_CHECK(loaded_node && loaded_node->required_fields.size() == 2, "Has 2 required fields");
|
||||
TEST_CHECK(loaded_node && loaded_node->optional_fields.size() == 0, "Has 0 optional fields");
|
||||
TEST_CHECK(loaded_node && loaded_node->required_fields[0].name == "a", "First field is 'a'");
|
||||
TEST_CHECK(loaded_node && loaded_node->required_fields[1].name == "b", "Second field is 'b'");
|
||||
TEST_CHECK(loaded_node && !loaded_node->at_binding.has_value(), "No at-binding");
|
||||
TEST_CHECK(loaded_node && !loaded_node->allow_extra, "No ellipsis");
|
||||
TEST_CHECK(loaded_node && loaded_node->body != nullptr, "Has body");
|
||||
}
|
||||
|
||||
void test_lambda_pattern_with_defaults() {
|
||||
std::cout << "> LambdaPatternNode with defaults ({ a, b ? 10 }: a + b)..." << std::endl;
|
||||
|
||||
// Default value for b
|
||||
auto default_b = std::make_shared<Node>(ConstIntNode(10));
|
||||
|
||||
// Body: a + b
|
||||
auto var_a = std::make_shared<Node>(VarNode(0, "a"));
|
||||
auto var_b = std::make_shared<Node>(VarNode(0, "b"));
|
||||
auto body = std::make_shared<Node>(BinaryOpNode(BinaryOp::ADD, var_a, var_b));
|
||||
|
||||
// Create lambda pattern
|
||||
LambdaPatternNode lambda_pattern(body);
|
||||
lambda_pattern.required_fields.emplace_back("a", std::nullopt);
|
||||
lambda_pattern.optional_fields.emplace_back("b", default_b);
|
||||
lambda_pattern.allow_extra = false;
|
||||
|
||||
auto node = std::make_shared<Node>(std::move(lambda_pattern));
|
||||
|
||||
// Serialize
|
||||
IRModule module;
|
||||
module.entry = node;
|
||||
Serializer ser;
|
||||
auto bytes = ser.serialize_to_bytes(module);
|
||||
|
||||
// Deserialize
|
||||
Deserializer deser;
|
||||
auto loaded = deser.deserialize(bytes);
|
||||
|
||||
// Verify
|
||||
auto* loaded_node = loaded.entry->get_if<LambdaPatternNode>();
|
||||
TEST_CHECK(loaded_node != nullptr, "Type is LambdaPatternNode");
|
||||
TEST_CHECK(loaded_node && loaded_node->required_fields.size() == 1, "Has 1 required field");
|
||||
TEST_CHECK(loaded_node && loaded_node->optional_fields.size() == 1, "Has 1 optional field");
|
||||
TEST_CHECK(loaded_node && loaded_node->required_fields[0].name == "a", "Required field is 'a'");
|
||||
TEST_CHECK(loaded_node && loaded_node->optional_fields[0].name == "b", "Optional field is 'b'");
|
||||
TEST_CHECK(loaded_node && loaded_node->optional_fields[0].default_value.has_value(),
|
||||
"Optional field has default");
|
||||
|
||||
if (loaded_node && loaded_node->optional_fields[0].default_value) {
|
||||
auto* def_val = (*loaded_node->optional_fields[0].default_value)->get_if<ConstIntNode>();
|
||||
TEST_CHECK(def_val && def_val->value == 10, "Default value is 10");
|
||||
}
|
||||
}
|
||||
|
||||
void test_lambda_pattern_at_binding() {
|
||||
std::cout << "> LambdaPatternNode with at-binding (args@{ a, b }: args.a)..." << std::endl;
|
||||
|
||||
// Body: args.a (select expression)
|
||||
auto var_args = std::make_shared<Node>(VarNode(0, "args"));
|
||||
auto attr = std::make_shared<Node>(ConstStringNode("a"));
|
||||
auto body = std::make_shared<Node>(SelectNode(var_args, attr));
|
||||
|
||||
// Create lambda pattern with at-binding
|
||||
LambdaPatternNode lambda_pattern(body);
|
||||
lambda_pattern.required_fields.emplace_back("a", std::nullopt);
|
||||
lambda_pattern.required_fields.emplace_back("b", std::nullopt);
|
||||
lambda_pattern.at_binding = "args";
|
||||
lambda_pattern.allow_extra = false;
|
||||
|
||||
auto node = std::make_shared<Node>(std::move(lambda_pattern));
|
||||
|
||||
// Serialize
|
||||
IRModule module;
|
||||
module.entry = node;
|
||||
Serializer ser;
|
||||
auto bytes = ser.serialize_to_bytes(module);
|
||||
|
||||
// Deserialize
|
||||
Deserializer deser;
|
||||
auto loaded = deser.deserialize(bytes);
|
||||
|
||||
// Verify
|
||||
auto* loaded_node = loaded.entry->get_if<LambdaPatternNode>();
|
||||
TEST_CHECK(loaded_node != nullptr, "Type is LambdaPatternNode");
|
||||
TEST_CHECK(loaded_node && loaded_node->at_binding.has_value(), "Has at-binding");
|
||||
TEST_CHECK(loaded_node && loaded_node->at_binding.value() == "args", "At-binding is 'args'");
|
||||
}
|
||||
|
||||
void test_lambda_pattern_ellipsis() {
|
||||
std::cout << "> LambdaPatternNode with ellipsis ({ a, ... }: a)..." << std::endl;
|
||||
|
||||
// Body: a
|
||||
auto body = std::make_shared<Node>(VarNode(0, "a"));
|
||||
|
||||
// Create lambda pattern with ellipsis
|
||||
LambdaPatternNode lambda_pattern(body);
|
||||
lambda_pattern.required_fields.emplace_back("a", std::nullopt);
|
||||
lambda_pattern.allow_extra = true;
|
||||
|
||||
auto node = std::make_shared<Node>(std::move(lambda_pattern));
|
||||
|
||||
// Serialize
|
||||
IRModule module;
|
||||
module.entry = node;
|
||||
Serializer ser;
|
||||
auto bytes = ser.serialize_to_bytes(module);
|
||||
|
||||
// Deserialize
|
||||
Deserializer deser;
|
||||
auto loaded = deser.deserialize(bytes);
|
||||
|
||||
// Verify
|
||||
auto* loaded_node = loaded.entry->get_if<LambdaPatternNode>();
|
||||
TEST_CHECK(loaded_node != nullptr, "Type is LambdaPatternNode");
|
||||
TEST_CHECK(loaded_node && loaded_node->allow_extra, "Has ellipsis (allow_extra=true)");
|
||||
}
|
||||
|
||||
void test_lambda_pattern_complete() {
|
||||
std::cout << "> LambdaPatternNode complete (args@{ a, b ? 5, ... }: body)..." << std::endl;
|
||||
|
||||
// Default value for b
|
||||
auto default_b = std::make_shared<Node>(ConstIntNode(5));
|
||||
|
||||
// Body: simple var
|
||||
auto body = std::make_shared<Node>(VarNode(0, "x"));
|
||||
|
||||
// Create lambda pattern with all features
|
||||
LambdaPatternNode lambda_pattern(body);
|
||||
lambda_pattern.required_fields.emplace_back("a", std::nullopt);
|
||||
lambda_pattern.optional_fields.emplace_back("b", default_b);
|
||||
lambda_pattern.at_binding = "args";
|
||||
lambda_pattern.allow_extra = true;
|
||||
|
||||
auto node = std::make_shared<Node>(std::move(lambda_pattern));
|
||||
|
||||
// Serialize
|
||||
IRModule module;
|
||||
module.entry = node;
|
||||
Serializer ser;
|
||||
auto bytes = ser.serialize_to_bytes(module);
|
||||
|
||||
// Deserialize
|
||||
Deserializer deser;
|
||||
auto loaded = deser.deserialize(bytes);
|
||||
|
||||
// Verify all fields
|
||||
auto* loaded_node = loaded.entry->get_if<LambdaPatternNode>();
|
||||
TEST_CHECK(loaded_node != nullptr, "Type is LambdaPatternNode");
|
||||
TEST_CHECK(loaded_node && loaded_node->required_fields.size() == 1, "Has 1 required field");
|
||||
TEST_CHECK(loaded_node && loaded_node->optional_fields.size() == 1, "Has 1 optional field");
|
||||
TEST_CHECK(loaded_node && loaded_node->at_binding.has_value(), "Has at-binding");
|
||||
TEST_CHECK(loaded_node && loaded_node->at_binding.value() == "args", "At-binding is 'args'");
|
||||
TEST_CHECK(loaded_node && loaded_node->allow_extra, "Has ellipsis");
|
||||
}
|
||||
|
||||
void test_lambda_pattern_empty() {
|
||||
std::cout << "> LambdaPatternNode empty ({ }: body)..." << std::endl;
|
||||
|
||||
// Body: simple constant
|
||||
auto body = std::make_shared<Node>(ConstIntNode(42));
|
||||
|
||||
// Create empty lambda pattern
|
||||
LambdaPatternNode lambda_pattern(body);
|
||||
lambda_pattern.allow_extra = false;
|
||||
|
||||
auto node = std::make_shared<Node>(std::move(lambda_pattern));
|
||||
|
||||
// Serialize
|
||||
IRModule module;
|
||||
module.entry = node;
|
||||
Serializer ser;
|
||||
auto bytes = ser.serialize_to_bytes(module);
|
||||
|
||||
// Deserialize
|
||||
Deserializer deser;
|
||||
auto loaded = deser.deserialize(bytes);
|
||||
|
||||
// Verify
|
||||
auto* loaded_node = loaded.entry->get_if<LambdaPatternNode>();
|
||||
TEST_CHECK(loaded_node != nullptr, "Type is LambdaPatternNode");
|
||||
TEST_CHECK(loaded_node && loaded_node->required_fields.size() == 0, "Has 0 required fields");
|
||||
TEST_CHECK(loaded_node && loaded_node->optional_fields.size() == 0, "Has 0 optional fields");
|
||||
TEST_CHECK(loaded_node && !loaded_node->at_binding.has_value(), "No at-binding");
|
||||
TEST_CHECK(loaded_node && !loaded_node->allow_extra, "No ellipsis");
|
||||
}
|
||||
|
||||
// StringInterpolationNode Tests
|
||||
|
||||
void test_string_interpolation_simple() {
|
||||
std::cout << "> StringInterpolationNode simple (\"hello ${name}\")..." << std::endl;
|
||||
|
||||
// "hello ${name}" = literal "hello " + expr(name)
|
||||
std::vector<StringPart> parts;
|
||||
parts.push_back(StringPart::make_literal("hello "));
|
||||
parts.push_back(StringPart::make_expr(std::make_shared<Node>(VarNode(0, "name"))));
|
||||
|
||||
auto node = std::make_shared<Node>(StringInterpolationNode(std::move(parts)));
|
||||
|
||||
// Serialize
|
||||
IRModule module;
|
||||
module.entry = node;
|
||||
Serializer ser;
|
||||
auto bytes = ser.serialize_to_bytes(module);
|
||||
|
||||
// Deserialize
|
||||
Deserializer deser;
|
||||
auto loaded = deser.deserialize(bytes);
|
||||
|
||||
// Verify
|
||||
auto* loaded_node = loaded.entry->get_if<StringInterpolationNode>();
|
||||
TEST_CHECK(loaded_node != nullptr, "Type is StringInterpolationNode");
|
||||
TEST_CHECK(loaded_node && loaded_node->parts.size() == 2, "Has 2 parts");
|
||||
TEST_CHECK(loaded_node && loaded_node->parts[0].type == StringPart::Type::LITERAL,
|
||||
"First part is LITERAL");
|
||||
TEST_CHECK(loaded_node && loaded_node->parts[0].literal == "hello ", "First part is 'hello '");
|
||||
TEST_CHECK(loaded_node && loaded_node->parts[1].type == StringPart::Type::EXPR,
|
||||
"Second part is EXPR");
|
||||
TEST_CHECK(loaded_node && loaded_node->parts[1].expr != nullptr, "Second part has expression");
|
||||
}
|
||||
|
||||
void test_string_interpolation_multiple() {
|
||||
std::cout << "> StringInterpolationNode multiple (\"${a} and ${b}\")..." << std::endl;
|
||||
|
||||
// "${a} and ${b}" = expr(a) + literal " and " + expr(b)
|
||||
std::vector<StringPart> parts;
|
||||
parts.push_back(StringPart::make_expr(std::make_shared<Node>(VarNode(0, "a"))));
|
||||
parts.push_back(StringPart::make_literal(" and "));
|
||||
parts.push_back(StringPart::make_expr(std::make_shared<Node>(VarNode(0, "b"))));
|
||||
|
||||
auto node = std::make_shared<Node>(StringInterpolationNode(std::move(parts)));
|
||||
|
||||
// Serialize
|
||||
IRModule module;
|
||||
module.entry = node;
|
||||
Serializer ser;
|
||||
auto bytes = ser.serialize_to_bytes(module);
|
||||
|
||||
// Deserialize
|
||||
Deserializer deser;
|
||||
auto loaded = deser.deserialize(bytes);
|
||||
|
||||
// Verify
|
||||
auto* loaded_node = loaded.entry->get_if<StringInterpolationNode>();
|
||||
TEST_CHECK(loaded_node != nullptr, "Type is StringInterpolationNode");
|
||||
TEST_CHECK(loaded_node && loaded_node->parts.size() == 3, "Has 3 parts");
|
||||
TEST_CHECK(loaded_node && loaded_node->parts[0].type == StringPart::Type::EXPR, "Part 0 is EXPR");
|
||||
TEST_CHECK(loaded_node && loaded_node->parts[1].type == StringPart::Type::LITERAL,
|
||||
"Part 1 is LITERAL");
|
||||
TEST_CHECK(loaded_node && loaded_node->parts[1].literal == " and ", "Part 1 is ' and '");
|
||||
TEST_CHECK(loaded_node && loaded_node->parts[2].type == StringPart::Type::EXPR, "Part 2 is EXPR");
|
||||
}
|
||||
|
||||
void test_string_interpolation_complex() {
|
||||
std::cout << "> StringInterpolationNode complex (\"result: ${a + b}\")..." << std::endl;
|
||||
|
||||
// "result: ${a + b}" = literal "result: " + expr(a + b)
|
||||
auto expr_a = std::make_shared<Node>(VarNode(0, "a"));
|
||||
auto expr_b = std::make_shared<Node>(VarNode(0, "b"));
|
||||
auto add_expr = std::make_shared<Node>(BinaryOpNode(BinaryOp::ADD, expr_a, expr_b));
|
||||
|
||||
std::vector<StringPart> parts;
|
||||
parts.push_back(StringPart::make_literal("result: "));
|
||||
parts.push_back(StringPart::make_expr(add_expr));
|
||||
|
||||
auto node = std::make_shared<Node>(StringInterpolationNode(std::move(parts)));
|
||||
|
||||
// Serialize
|
||||
IRModule module;
|
||||
module.entry = node;
|
||||
Serializer ser;
|
||||
auto bytes = ser.serialize_to_bytes(module);
|
||||
|
||||
// Deserialize
|
||||
Deserializer deser;
|
||||
auto loaded = deser.deserialize(bytes);
|
||||
|
||||
// Verify
|
||||
auto* loaded_node = loaded.entry->get_if<StringInterpolationNode>();
|
||||
TEST_CHECK(loaded_node != nullptr, "Type is StringInterpolationNode");
|
||||
TEST_CHECK(loaded_node && loaded_node->parts.size() == 2, "Has 2 parts");
|
||||
TEST_CHECK(loaded_node && loaded_node->parts[1].type == StringPart::Type::EXPR, "Part 1 is EXPR");
|
||||
|
||||
// Verify the expression is a BinaryOpNode
|
||||
if (loaded_node && loaded_node->parts[1].expr) {
|
||||
auto* bin_op = loaded_node->parts[1].expr->get_if<BinaryOpNode>();
|
||||
TEST_CHECK(bin_op != nullptr, "Expression is BinaryOpNode");
|
||||
TEST_CHECK(bin_op && bin_op->op == BinaryOp::ADD, "Operation is ADD");
|
||||
}
|
||||
}
|
||||
|
||||
void test_string_interpolation_nested() {
|
||||
std::cout << "> StringInterpolationNode nested (\"${prefix}/${path}\")..." << std::endl;
|
||||
|
||||
// "${prefix}/${path}" = expr(prefix) + literal "/" + expr(path)
|
||||
std::vector<StringPart> parts;
|
||||
parts.push_back(StringPart::make_expr(std::make_shared<Node>(VarNode(0, "prefix"))));
|
||||
parts.push_back(StringPart::make_literal("/"));
|
||||
parts.push_back(StringPart::make_expr(std::make_shared<Node>(VarNode(0, "path"))));
|
||||
|
||||
auto node = std::make_shared<Node>(StringInterpolationNode(std::move(parts)));
|
||||
|
||||
// Serialize
|
||||
IRModule module;
|
||||
module.entry = node;
|
||||
Serializer ser;
|
||||
auto bytes = ser.serialize_to_bytes(module);
|
||||
|
||||
// Deserialize
|
||||
Deserializer deser;
|
||||
auto loaded = deser.deserialize(bytes);
|
||||
|
||||
// Verify
|
||||
auto* loaded_node = loaded.entry->get_if<StringInterpolationNode>();
|
||||
TEST_CHECK(loaded_node != nullptr, "Type is StringInterpolationNode");
|
||||
TEST_CHECK(loaded_node && loaded_node->parts.size() == 3, "Has 3 parts");
|
||||
TEST_CHECK(loaded_node && loaded_node->parts[1].type == StringPart::Type::LITERAL,
|
||||
"Middle part is LITERAL");
|
||||
TEST_CHECK(loaded_node && loaded_node->parts[1].literal == "/", "Middle part is '/'");
|
||||
}
|
||||
|
||||
int main() {
|
||||
std::cout << "=== Regression Tests for Nixir ===" << std::endl << std::endl;
|
||||
std::cout << "=== Regression Tests ===" << std::endl << std::endl;
|
||||
|
||||
test_enum_compatibility();
|
||||
std::cout << std::endl;
|
||||
|
|
@ -308,6 +657,36 @@ int main() {
|
|||
test_float_node();
|
||||
std::cout << std::endl;
|
||||
|
||||
test_lambda_pattern_simple();
|
||||
std::cout << std::endl;
|
||||
|
||||
test_lambda_pattern_with_defaults();
|
||||
std::cout << std::endl;
|
||||
|
||||
test_lambda_pattern_at_binding();
|
||||
std::cout << std::endl;
|
||||
|
||||
test_lambda_pattern_ellipsis();
|
||||
std::cout << std::endl;
|
||||
|
||||
test_lambda_pattern_complete();
|
||||
std::cout << std::endl;
|
||||
|
||||
test_lambda_pattern_empty();
|
||||
std::cout << std::endl;
|
||||
|
||||
test_string_interpolation_simple();
|
||||
std::cout << std::endl;
|
||||
|
||||
test_string_interpolation_multiple();
|
||||
std::cout << std::endl;
|
||||
|
||||
test_string_interpolation_complex();
|
||||
std::cout << std::endl;
|
||||
|
||||
test_string_interpolation_nested();
|
||||
std::cout << std::endl;
|
||||
|
||||
std::cout << "=== Tests Complete ===" << std::endl;
|
||||
std::cout << "Failures: " << failures << std::endl;
|
||||
return failures > 0 ? 1 : 0;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue