Fix IR generic monomorphization to infer function-pointer types from program signatures when a generic call's first argument is a function identifier, enabling identity(add_one) and similar Copy-bounded instantiations to codegen correctly.

Author: Cod-e-Codes

CHANGELOG.md

@@ -3,7 +3,7 @@
 ## 2026-07
 
 - **VM-style idioms**: `match` on `&Enum` from `Vec::get_ref`; struct field assignment and `+=` on owned/`&mut` paths; method desugaring (`vec.push`, `vec.get_ref`) with correct borrows; nested generic types (`Vec<Vec<int>>`); match-arm control-flow unification (`break`/`return` with value arms); `&str` call-site coercion; enum literals in `Vec::push`/`set` without double-wrapped C; `&mut Struct` field access via `->` in codegen. Integration tests and examples `bytecode_vm`, updated `showcase`, `todo_demo`, `http_server`, `text_summary`. Fix extern call typing so `&T` arguments match `&T` parameters (no erroneous copy-type ref stripping). Fix `Option<T>` match codegen to use the scrutinee type instead of the first registered monomorph. Former negative match-arm rvalue tests now pass as positive runs.
-- **Trait bounds follow-up**: ION_SPEC §4.8 `Eq` row documents function pointers; integration test `test_trait_bound_eq_fn_ok`; method-call signature help threads generic bounds through `fn_hover_doc`.
+- **Trait bounds follow-up**: ION_SPEC §4.8 `Eq` row documents function pointers; integration test `test_trait_bound_eq_fn_ok`; method-call signature help threads generic bounds through `fn_hover_doc`. Fix IR generic monomorphization when the first type argument is a function identifier (`identity(add_one)`): infer fn-pointer types from program signatures so mangled instantiations are emitted and call sites use the correct name. Integration test `test_trait_bound_copy_fn_ok`; `examples/trait_bounds` exercises `identity(add_one)`.
 
 ## 2026-06
 

examples/trait_bounds/ion.toml

@@ -0,0 +1,5 @@
+name = "trait_bounds"
+main = "trait_bounds.ion"
+output = "trait_bounds"
+mode = "single"
+out_dir = "target"

examples/trait_bounds/trait_bounds.ion

@@ -0,0 +1,50 @@
+// Built-in trait bounds on generic parameters: Copy, Eq, Send.
+// Bounds are checked at monomorphization; each helper is instantiated with a concrete type.
+
+fn identity<T: Copy>(value: T) -> T {
+    return value;
+}
+
+fn values_equal<T: Eq>(a: T, b: T) -> bool {
+    return a == b;
+}
+
+fn hold_send<T: Send>(value: T) -> int {
+    let _held: T = value;
+    return 1;
+}
+
+fn add_one(x: int) -> int {
+    return x + 1;
+}
+
+fn main() -> int {
+    // Copy: int satisfies Copy at instantiation.
+    let n: int = identity(21);
+    if n != 21 {
+        return 1;
+    }
+
+    // Copy: function pointers satisfy Copy; identity(add_one) must monomorphize.
+    let h: fn(int) -> int = identity(add_one);
+    if h(4) != 5 {
+        return 5;
+    }
+
+    // Eq: primitives and function pointers support ==.
+    if !values_equal(10, 10) {
+        return 2;
+    }
+    let f: fn(int) -> int = add_one;
+    let g: fn(int) -> int = add_one;
+    if !values_equal(f, g) {
+        return 3;
+    }
+
+    // Send: int is safe to pass into a Send-bounded generic.
+    if hold_send(n) != 1 {
+        return 4;
+    }
+
+    return 0;
+}