so long nerds

Author: vbxq

.cargo/config.toml

@@ -0,0 +1,2 @@
+[env]
+LLVM_SYS_181_PREFIX = "/usr/lib/llvm18"

.gitignore

@@ -14,4 +14,7 @@ main.aelys
 main.ll
 torture/
 audit/**
-audit_tmp/**
+audit_tmp/**
+.vs/**
+.idea/**
+tests_e2e/**

aelys/tests/air_validation_tests.rs

@@ -334,7 +334,7 @@ fn caller() -> i32 {
 
     let mut program = air;
     compute_layouts(&mut program);
-    let program = monomorphize(program);
+    let program = monomorphize(program).unwrap();
 
     let mono_fn = program
         .functions
@@ -418,7 +418,7 @@ fn main() {
 "#,
     );
     compute_layouts(&mut air);
-    let mut air = monomorphize(air);
+    let mut air = monomorphize(air).unwrap();
     passes::copy_elim::eliminate_copies(&mut air);
     passes::dead_locals::eliminate_dead_locals(&mut air);
 
@@ -501,7 +501,7 @@ fn align_probe(x: i64, y: i32, z: i16, w: i8, b: bool, f: f32, d: f64, p: string
 "#,
     );
     compute_layouts(&mut air);
-    let mut air = monomorphize(air);
+    let mut air = monomorphize(air).unwrap();
     passes::copy_elim::eliminate_copies(&mut air);
 
     let f = func(&air, "align_probe");
@@ -536,7 +536,7 @@ fn keep_copy(x: i64) -> i64 {
 "#,
     );
     compute_layouts(&mut air);
-    let mut air = monomorphize(air);
+    let mut air = monomorphize(air).unwrap();
     aelys_air::passes::copy_elim::eliminate_copies(&mut air);
 
     let f = func(&air, "keep_copy");
@@ -626,7 +626,7 @@ fn align_probe(x: i64, y: i32, z: i16, w: i8, b: bool, f: f32, d: f64, p: string
 "#,
     );
     compute_layouts(&mut air);
-    let mut air = monomorphize(air);
+    let mut air = monomorphize(air).unwrap();
     passes::copy_elim::eliminate_copies(&mut air);
     passes::dead_locals::eliminate_dead_locals(&mut air);
 
@@ -658,7 +658,7 @@ fn caller() -> i64 {
 
     let mut program = air;
     compute_layouts(&mut program);
-    let program = monomorphize(program);
+    let program = monomorphize(program).unwrap();
 
     // Both instantiations should exist
     let mono_i32 = program
@@ -998,20 +998,20 @@ fn main() -> i64 {
 "#,
     );
     let f = func(&air, "main");
-    let has_fnref = f.blocks.iter().any(|b| {
+    let has_closure_create = f.blocks.iter().any(|b| {
         b.stmts.iter().any(|s| {
             matches!(
                 &s.kind,
                 AirStmtKind::Assign {
-                    rvalue: Rvalue::Use(Operand::Const(AirConst::FnRef(name))),
+                    rvalue: Rvalue::ClosureCreate { fn_name, .. },
                     ..
-                } if name == "inc"
+                } if fn_name == "inc"
             )
         })
     });
     assert!(
-        has_fnref,
-        "expected function identifier value to materialize from FnRef(\"inc\")"
+        has_closure_create,
+        "expected function identifier value to materialize from ClosureCreate(\"inc\")"
     );
 }
 
@@ -1156,7 +1156,7 @@ fn caller() -> i32 {
 "#,
     );
     compute_layouts(&mut air);
-    let mut air = monomorphize(air);
+    let mut air = monomorphize(air).unwrap();
     passes::copy_elim::eliminate_copies(&mut air);
     passes::dead_locals::eliminate_dead_locals(&mut air);
 
@@ -1423,7 +1423,7 @@ fn caller() -> i64 {
 "#,
     );
     compute_layouts(&mut air);
-    let mut air = monomorphize(air);
+    let mut air = monomorphize(air).unwrap();
     passes::copy_elim::eliminate_copies(&mut air);
     passes::dead_locals::eliminate_dead_locals(&mut air);
 
@@ -1448,7 +1448,7 @@ fn main() {
         &["print", "println"],
     );
     compute_layouts(&mut air);
-    let mut air = monomorphize(air);
+    let mut air = monomorphize(air).unwrap();
     passes::copy_elim::eliminate_copies(&mut air);
     passes::dead_locals::eliminate_dead_locals(&mut air);
 
@@ -1710,31 +1710,13 @@ fn validate_rejects_ambiguous_generic_unit_variant_after_mono() {
         struct_sizes: std::collections::HashMap::new(),
     };
 
-    let air = monomorphize(program);
-    let result = validate_air(&air);
-    assert!(
-        result.is_err(),
-        "ambiguous generic unit variant should be rejected after monomorphization"
-    );
-    let errors = result.unwrap_err();
-    assert!(
-        errors.iter().any(|e| matches!(
-            &e.detail,
-            AirValidationDetail::UnknownEnumType {
-                local_name: Some(name),
-                enum_name,
-                ..
-            } if name == "ambiguous" && enum_name == "Option"
-        )),
-        "expected unknown enum type error for unresolved local, got: {:?}",
-        errors
-    );
+    let errors = match monomorphize(program) {
+        Err(e) => e,
+        Ok(_) => panic!("ambiguous generic unit variant should be rejected during monomorphization"),
+    };
     assert!(
-        errors.iter().any(|e| matches!(
-            &e.detail,
-            AirValidationDetail::UnknownEnumReference { enum_name, .. } if enum_name == "Option"
-        )),
-        "expected unknown enum reference error for unresolved enum_init, got: {:?}",
+        errors.iter().any(|e| e.contains("ambiguous unit variant")),
+        "expected ambiguous unit variant error, got: {:?}",
         errors
     );
 }
@@ -1894,7 +1876,7 @@ fn monomorphize_distinguishes_fnptr_calling_conventions_in_enum_type_args() {
         struct_sizes: std::collections::HashMap::new(),
     };
 
-    let air = monomorphize(program);
+    let air = monomorphize(program).unwrap();
     let holder_defs: Vec<_> = air
         .enums
         .iter()

aelys/tests/enum_parse_tests.rs

@@ -1,4 +1,5 @@
 use aelys::api::compile_to_typed_ast;
+use aelys_air::AirType;
 use aelys_air::lower::lower;
 use aelys_air::print::print_program;
 use aelys_frontend::lexer::Lexer;
@@ -14,6 +15,11 @@ fn lower_source(code: &str) -> aelys_air::AirProgram {
     lower(&typed)
 }
 
+fn lower_and_monomorphize(code: &str) -> aelys_air::AirProgram {
+    let air = lower_source(code);
+    aelys_air::mono::monomorphize(air).unwrap()
+}
+
 #[test]
 fn parse_basic_enum_declaration() {
     let src = r#"
@@ -296,7 +302,9 @@ enum Message {
     Move(i64, i64),
     Write(string),
 }
-let msg = Message::Write("hello")
+fn use_write() -> Message {
+    return Message::Write("hello")
+}
 "#;
     let air = lower_source(src);
     // Verify the enum def exists in the AIR program
@@ -477,6 +485,27 @@ fn name(c: Color) -> i64 {
     );
 }
 
+#[test]
+fn match_wildcard_must_be_last() {
+    let src = r#"
+enum Color { Red, Green, Blue }
+
+fn name(c: Color) -> i64 {
+    return match c {
+        _ => 0,
+        Color::Red => 1,
+    }
+}
+"#;
+    let result = compile_to_typed_ast(src);
+    let errors = result.expect_err("wildcard before specific arms should fail");
+    let rendered = format!("{:?}", errors);
+    assert!(
+        rendered.contains("wildcard pattern must be the last match arm"),
+        "unexpected diagnostics: {rendered}"
+    );
+}
+
 #[test]
 fn match_non_exhaustive_error() {
     let src = r#"
@@ -1305,6 +1334,115 @@ fn handle(r: Result<i64, string>) -> i64 {
     );
 }
 
+#[test]
+fn nested_generic_enum_unit_variant_monomorphizes_nested_enum_def() {
+    let src = r#"
+enum Pair<A, B> {
+    Both(A, B),
+    Neither,
+}
+
+enum Boxed<T> {
+    Value(T),
+    Empty,
+}
+
+fn get_empty() -> Boxed<Pair<i64, string>> {
+    return Boxed::Empty
+}
+
+fn main() {
+    let e = get_empty()
+}
+"#;
+    let air = lower_and_monomorphize(src);
+    let pair = air
+        .enums
+        .iter()
+        .find(|e| e.name == "__mono_Pair_i64$str")
+        .expect("nested Pair mono enum should exist");
+    assert_eq!(pair.variants[0].payload.len(), 2);
+
+    let boxed = air
+        .enums
+        .iter()
+        .find(|e| e.name == "__mono_Boxed_enum___mono_Pair_i64$str")
+        .expect("Boxed<Pair<...>> mono enum should exist");
+    let value_variant = boxed
+        .variants
+        .iter()
+        .find(|v| v.name == "Value")
+        .expect("Value variant should exist");
+    assert_eq!(
+        value_variant.payload,
+        vec![AirType::Enum("__mono_Pair_i64$str".to_string())]
+    );
+}
+
+#[test]
+fn generic_enum_unit_variant_with_fnptr_type_arg_monomorphizes() {
+    let src = r#"
+enum Holder<T> {
+    Value(T),
+    Empty,
+}
+
+fn apply_default() -> Holder<fn(i64) -> i64> {
+    return Holder::Empty
+}
+"#;
+    let air = lower_and_monomorphize(src);
+    let air_text = print_program(&air);
+
+    let holder = air
+        .enums
+        .iter()
+        .find(|e| e.name == "__mono_Holder_fnptr$i64$Ri64")
+        .expect("fnptr-instantiated Holder enum should exist");
+    assert_eq!(holder.variants.len(), 2);
+    assert!(
+        !air_text.contains("enum_init Holder::"),
+        "fnptr generic unit variant should be rewritten to mono enum:\n{air_text}"
+    );
+}
+
+#[test]
+fn generic_enum_named_fn_payload_uses_fnptr_monomorphization() {
+    let src = r#"
+enum Holder<T> {
+    Value(T),
+    Empty,
+}
+
+fn inc(x: i64) -> i64 {
+    return x + 1
+}
+
+fn call_holder(h: Holder<fn(i64) -> i64>) -> i64 {
+    return match h {
+        Holder::Value(f) => f(41)
+        Holder::Empty => 0
+    }
+}
+
+fn main() {
+    let h: Holder<fn(i64) -> i64> = Holder::Value(inc)
+    call_holder(h)
+}
+"#;
+    let air = lower_and_monomorphize(src);
+    let air_text = print_program(&air);
+
+    assert!(
+        air_text.contains("enum_init __mono_Holder_fnptr$i64$Ri64::Value"),
+        "named function payload should monomorphize to fnptr enum, got:\n{air_text}"
+    );
+    assert!(
+        !air_text.contains("__mono_Holder_ptr_void"),
+        "named function payload must not degrade to ptr_void mono, got:\n{air_text}"
+    );
+}
+
 #[test]
 fn generic_enum_result_air_lowering() {
     let src = r#"
@@ -1375,7 +1513,7 @@ fn make_none_int() -> Option<i64> {
 }
 "#;
     let air = lower_source(src);
-    let air = aelys_air::mono::monomorphize(air);
+    let air = aelys_air::mono::monomorphize(air).unwrap();
     let air_text = print_program(&air);
 
     // After monomorphization, no generic enum definitions should remain

aelys/tests/fatal_error_filter_tests.rs

@@ -231,7 +231,7 @@ fn while_with_early_return() {
     assert!(
         sema_ok(
             r#"
-fn find(arr: Array<i64>, n: i64, target: i64) -> i64 {
+fn find(arr: [i64; 10], n: i64, target: i64) -> i64 {
     let mut i: i64 = 0
     while i < n {
         if arr[i] == target {

aelys/tests/llvm_air_abi_tests.rs

@@ -136,11 +136,19 @@ fn air_and_llvm_string_layout_match_x86_64_abi() {
 
     let ir = compile_air_to_verified_ir(&program);
     assert!(ir.contains("%__aelys_string = type { ptr, i64 }"), "{ir}");
+    // Aelys-convention functions prepend an implicit env ptr; the string follows.
+    let sink_decl = ir
+        .lines()
+        .find(|l| l.contains("define fastcc i64 @sink"))
+        .expect("sink function must be defined");
     assert!(
-        ir.contains("define fastcc i64 @sink(%__aelys_string"),
-        "{ir}"
+        sink_decl.contains("%__aelys_string"),
+        "string param must lower to %__aelys_string struct, not a bare ptr:\n{sink_decl}"
+    );
+    assert!(
+        !sink_decl.contains("ptr, i64"),
+        "string must not be flattened to (ptr, i64) scalars:\n{sink_decl}"
     );
-    assert!(!ir.contains("define fastcc i64 @sink(ptr"), "{ir}");
 
     let context = Context::create();
     let mut nul_terminated_ir = ir.into_bytes();