Add function pointers to the ION_SPEC Eq bound table, fix method-call LSP signature help to include generic bounds, and add an integration test for Eq on function pointer types.

Author: Cod-e-Codes

CHANGELOG.md

@@ -3,6 +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`.
 
 ## 2026-06
 

ION_SPEC.md

@@ -693,7 +693,7 @@ Syntax: `identifier : Bound [ + Bound ... ]` after each type parameter name. Bou
 | Bound | Meaning (structural) |
 |-------|----------------------|
 | `Copy` | Type is copied rather than moved at the ownership level (primitives, references, function pointers). |
-| `Eq` | Type supports `==` and `!=` with correct semantics (primitives, `String`, references, arrays and tuples of `Eq` types, structs and enums whose fields or payloads are all `Eq`). |
+| `Eq` | Type supports `==` and `!=` with correct semantics (primitives, `String`, references, function pointers, arrays and tuples of `Eq` types, structs and enums whose fields or payloads are all `Eq`). |
 | `Send` | Type may cross thread boundaries (Section 7.3). |
 
 At each monomorphization site (generic call, struct or enum construction, type-alias substitution), the compiler substitutes concrete types for parameters and rejects any instantiation where a concrete type does not satisfy a declared bound. Unknown bound names are rejected at the declaration site.

src/tc/mod.rs

@@ -3697,7 +3697,10 @@ impl TypeChecker {
                 }
 
                 // Regular function call type checking
-                let (params, return_type_opt) = if desugared_call.callee.contains("::") {
+                let (params, return_type_opt, fn_type_params) = if desugared_call
+                    .callee
+                    .contains("::")
+                {
                     let parts: Vec<&str> = desugared_call.callee.split("::").collect();
                     if parts.len() != 2 {
                         return Err(TypeCheckError::Message(format!(
@@ -3733,12 +3736,20 @@ impl TypeChecker {
                                 }
                             })?;
 
-                        (func_decl.params.clone(), func_decl.return_type.clone())
+                        (
+                            func_decl.params.clone(),
+                            func_decl.return_type.clone(),
+                            func_decl.generics.clone(),
+                        )
                     } else {
                         // Type method case - look up the function again
                         let func_decl =
                             self.lookup_method_function(&desugared_call.callee, &base_type_name)?;
-                        (func_decl.params.clone(), func_decl.return_type.clone())
+                        (
+                            func_decl.params.clone(),
+                            func_decl.return_type.clone(),
+                            func_decl.generics.clone(),
+                        )
                     }
                 } else {
                     // Simple function call - shouldn't happen for methods
@@ -3782,7 +3793,12 @@ impl TypeChecker {
 
                 self.record_signature(
                     method_call.span,
-                    Self::fn_hover_doc(&desugared_call.callee, &[], &params, &return_type_opt),
+                    Self::fn_hover_doc(
+                        &desugared_call.callee,
+                        &fn_type_params,
+                        &params,
+                        &return_type_opt,
+                    ),
                     None,
                 );
 
@@ -5415,6 +5431,63 @@ fn main() -> int {
         );
     }
 
+    #[test]
+    fn method_call_signature_includes_generic_bounds() {
+        let src = r#"
+struct Pair {
+    first: int;
+    second: int;
+}
+
+fn bump(x: int) -> int {
+    return x + 1;
+}
+
+fn main() -> int {
+    let p: Pair = Pair { first: 0, second: 0 };
+    let f: fn(int) -> int = bump;
+    let g: fn(int) -> int = bump;
+    if p.same(f, g) {
+        return 0;
+    }
+    return 1;
+}
+"#;
+        let helper_src = r#"
+fn same<T: Eq>(pair: Pair, a: T, b: T) -> bool {
+    return a == b;
+}
+"#;
+        let fn_ptr = Type::Fn {
+            params: vec![Type::Int],
+            return_type: Box::new(Type::Int),
+        };
+        let tokens = crate::lexer::Lexer::new(src).tokenize().unwrap();
+        let mut program = parser::Parser::new(tokens).parse().unwrap();
+        let helper_tokens = crate::lexer::Lexer::new(helper_src).tokenize().unwrap();
+        let helper = parser::Parser::new(helper_tokens).parse().unwrap();
+        let mut method_fn = helper.functions.into_iter().next().expect("helper fn");
+        method_fn.name = "Pair::same".to_string();
+        method_fn.params[1].ty = fn_ptr.clone();
+        method_fn.params[2].ty = fn_ptr;
+        program.functions.push(method_fn);
+
+        let mut checker = TypeChecker::new();
+        let (result, errors) = checker.check_program_collecting(&program);
+        assert!(errors.is_empty(), "{errors:?}");
+        let sig = result
+            .lsp_info
+            .signatures
+            .values()
+            .find(|s| s.label.contains("Pair::same"))
+            .expect("Pair::same method signature help");
+        assert!(
+            sig.label.contains("<T: Eq>"),
+            "expected generic bounds in signature help, got: {}",
+            sig.label
+        );
+    }
+
     fn spans_overlap(a: Span, b: Span) -> bool {
         a.line == b.line
             && a.column < b.column + (b.end - b.start)

tests/README.md

@@ -257,6 +257,7 @@ The test runner prints pass/fail counts when it finishes. Do not rely on hardcod
 - `test_trait_bound_send_ok.ion` - generic fn with `T: Send` accepts `int`
 - `test_trait_bound_copy_ok.ion` - generic fn with `T: Copy` accepts `int`
 - `test_trait_bound_eq_ok.ion` - generic fn with `T: Eq` compares ints
+- `test_trait_bound_eq_fn_ok.ion` - generic fn with `T: Eq` compares function pointers
 - `test_trait_bound_send_error.ion` - `&int` rejected for `T: Send`
 - `test_trait_bound_copy_error.ion` - `String` rejected for `T: Copy`
 - `test_trait_bound_eq_error.ion` - `Vec<int>` rejected for `T: Eq`

tests/test_expectations.tsv

@@ -214,6 +214,7 @@ test_str_from_literal.ion	run	71
 test_trait_bound_send_ok.ion	run	42
 test_trait_bound_copy_ok.ion	run	7
 test_trait_bound_eq_ok.ion	run	61
+test_trait_bound_eq_fn_ok.ion	run	99
 test_trait_bound_send_error.ion	error		TraitBoundNotSatisfied
 test_trait_bound_copy_error.ion	error		TraitBoundNotSatisfied
 test_trait_bound_eq_error.ion	error		TraitBoundNotSatisfied

tests/test_trait_bound_eq_fn_ok.ion

@@ -0,0 +1,17 @@
+// Generic function with Eq bound: function pointers support ==
+fn add_one(x: int) -> int {
+    return x + 1;
+}
+
+fn same_fn<T: Eq>(a: T, b: T) -> bool {
+    return a == b;
+}
+
+fn main() -> int {
+    let f: fn(int) -> int = add_one;
+    let g: fn(int) -> int = add_one;
+    if same_fn(f, g) {
+        return 99;
+    }
+    return 1;
+}