Add capture-free fn literals lowered to static C function pointers.

Reject outer-scope capture with ClosureCapture; update ION_SPEC, integration tests, showcase example, and project skills. Capturing closures remain deferred.

Author: Cod-e-Codes

.cursor/skills/adding-ion-features/SKILL.md

@@ -81,6 +81,7 @@ Critical checks to preserve. Patterns below match **CLI stderr** (`Type check er
 | `if`/`while` non-bool | bool condition errors |
 | Module visibility | `Cannot access non-public` |
 | `unsafe` for extern | `must be inside an unsafe block` |
+| Fn literal capture | `ClosureCapture` |
 
 Add new `TypeCheckError` variants only when existing ones can't express the failure clearly.
 

.cursor/skills/ion-integration-tests/SKILL.md

@@ -119,6 +119,7 @@ The harness greps **compiler CLI stderr** for the pattern (not LSP diagnostic te
 | Non-public import | `Cannot access non-public` |
 | Extern without unsafe | `must be inside an unsafe block` |
 | Non-bool if | `bool.*if condition\|if condition.*bool` |
+| Fn literal capture | `ClosureCapture` |
 
 ### `test_error` PARTIAL pass trap
 

.cursor/skills/ion-lang/SKILL.md

@@ -105,4 +105,5 @@ Read these when the task matches:
 - Multi-file mode: `--mode multi --output <name> <main.ion>` generates per-module `.c`/`.h`.
 - Stdlib lives in `stdlib/` (`io.ion`, `fmt.ion`, `fs.ion`, `result.ion`); imported module functions are emitted as `{alias}_{name}` in single-file merge mode (e.g. `io::print_int` -> `io_print_int`).
 - Integration tests: add `tests/test_*.ion` plus one row in `tests/test_expectations.tsv` (see `ion-integration-tests` skill). Run `cd tests && ./test_runner.sh` to verify.
+- Fn literals are capture-free only; references to outer bindings are rejected with `ClosureCapture`.
 - LSP parses the **open buffer** in memory (lexer → parser), then `load_imports` which **fully `parse_module`s imported files from disk** (per-import errors are published). Parser/tc/import changes may need LSP updates (`ion-lsp-vscode` skill).

.cursor/skills/writing-ion-code/SKILL.md

@@ -112,6 +112,15 @@ let result: int = recv(&mut rx_back_mut);
 
 `spawn` captures owned values by move. `T` in `channel<T>()` must be `Send`.
 
+**Fn literals (capture-free)**
+
+```ion
+let f: fn(int) -> int = fn(x: int) -> int { return x + 5; };
+return f(7);
+```
+
+Fn literals lower to static C functions and must not reference outer bindings (owned or by reference). Use named functions with extra parameters for customized behavior. See [tests/test_fn_literal_basic.ion](../../../tests/test_fn_literal_basic.ion) and [tests/test_fn_literal_callback.ion](../../../tests/test_fn_literal_callback.ion).
+
 **Unsafe and FFI**
 
 All `extern "C"` calls belong inside `unsafe { ... }`. See [tests/test_ffi_basic.ion](../../../tests/test_ffi_basic.ion).
@@ -147,7 +156,7 @@ For programs under `tests/`, follow the `ion-integration-tests` skill (`test_exp
 
 These are **not** in Ion today. Check ION_SPEC.md section 10.2 before using anything similar:
 
-- Closures, fn literals, or `impl` blocks in user code
+- Capturing closures (fn literals that reference outer variables), or `impl` blocks in user code
 - Traits, trait bounds, or `where` clauses on generics
 - Returning `&T` / `&mut T` or `Option<&T>` from functions
 - References in struct fields, enum payloads, or channels

ION_SPEC.md

@@ -432,7 +432,10 @@ primary_expr     = identifier
                  | "(" , expr , ")"
                  | struct_lit
                  | enum_lit
-                 | array_lit ;
+                 | array_lit
+                 | fn_literal ;
+
+fn_literal       = "fn" , "(" , params? , ")" , [ "->" , type_expr ] , block ;
 
 array_lit        = "[" , ( expr_list | ( expr , ";" , int_lit ) ) , "]" ;
 expr_list        = expr , { "," , expr } ;
@@ -612,7 +615,11 @@ The corresponding function type is:
 fn(T1, T2) -> R
 ```
 
-Function types are **first-class**: they may be stored in variables, passed as arguments, and returned. However, **function values may not capture references that would violate the no-escape rule** (see Section 5.4).
+Function types are **first-class**: they may be stored in variables, passed as arguments, and returned.
+
+**Fn literals** (capture-free only): an expression `fn(params) [-> R] { ... }` has type `fn(T1, T2, ...) -> R` matching its signature. The body may reference only parameters and locals declared inside the literal; any use of a binding from an outer scope is a compile-time error (`ClosureCapture`). Fn literals lower to plain C function pointers (each site gets a unique `static` function); there is no environment payload and no heap allocation.
+
+Named functions and capture-free fn literals may not capture references that would violate the no-escape rule (see Section 5.4). **Capturing closures** (literals that move owned state from outer scopes) are not implemented; use named functions with extra parameters, explicit context structs, or `spawn` for move-only thread capture.
 
 #### 4.4 Type Inference
 
@@ -778,11 +785,13 @@ fn main() {
 ```ion
 fn make_printer(x: &int) -> fn() {
     return fn() {
-        println("x = {}", x); // would capture x by reference
+        println("x = {}", *x); // ERROR: ClosureCapture (cannot reference outer x)
     }; // ERROR: closure escapes with reference
 }
 ```
 
+Capturing closures are not implemented; the compiler rejects any outer binding referenced from a fn literal body.
+
 **Example (valid – borrow within function):**
 
 ```ion
@@ -836,7 +845,7 @@ Uninitialized `Box`/`Vec`/`String` bindings are zero-initialized to `NULL` so dr
 
 Ion does **not** perform implicit heap allocation for:
 
-- Captured closures
+- Captured closures (not implemented; fn literals are capture-free and use static functions only)
 - Slices or views
 - Temporaries (beyond what is required for expression evaluation)
 
@@ -1193,7 +1202,7 @@ Build with `cargo build --release --bin ion-lsp`. Rebuild after compiler or LSP
 - Match guards on the same variant are lowered to a single `switch` case with sequential `if` checks
 - LSP go-to-definition for built-in methods (`Vec::push`, `String::len`, etc.) has no target (signature hover only)
 - LSP go-to-definition for type names in type annotations (no source spans on `Type` AST nodes)
-- Function types: named functions only; no fn literals/closures, no generic `fn(T) -> R` type parameters, no method values as fn pointers
+- Function types: capture-free fn literals implemented; no capturing closures, no generic `fn(T) -> R` type parameters, no method values as fn pointers
 - Tuple values: no nested tuples, `==` on tuples, struct fields holding tuples, or generic `(T1, T2)` parameters
 
 ### 11. Future Work (Non-Normative)
@@ -1204,6 +1213,7 @@ The following features are **not planned** for the current compiler:
 - Complex trait or typeclass systems.
 - Macros and compile-time metaprogramming.
 - Advanced iterator pipelines and zero-cost abstractions beyond the basics.
+- Capturing closures (fn literals that move owned environment from outer scopes).
 
 Any such addition must:
 

README.md

@@ -193,7 +193,7 @@ For `http_server.ion`, add `-Drecv_sys=recv -Dsend_sys=send` when linking.
 | [examples/hello_world_safe.ion](examples/hello_world_safe.ion) | stdlib `io` module |
 | [examples/spawn_channel.ion](examples/spawn_channel.ion) | `spawn` with cross-thread channels |
 | [examples/http_server.ion](examples/http_server.ion) | Sockets, FFI, concurrent clients via `spawn` |
-| [examples/showcase.ion](examples/showcase.ion) | Mixed language features: tuples, `+=`, `push_byte`, spawn/channels |
+| [examples/showcase.ion](examples/showcase.ion) | Mixed language features: tuples, `+=`, `push_byte`, spawn/channels, capture-free fn literals |
 | [examples/access_log.ion](examples/access_log.ion) | Log parsing, `loop`/`break`, match guards, spawn, channels, fmt/io |
 | [examples/minimal.ion](examples/minimal.ion) | Smallest valid program |
 | [examples/channel_worker.ion](examples/channel_worker.ion) | Channel worker: `spawn` sums jobs from a channel |

examples/showcase.c

@@ -12,6 +12,7 @@ typedef struct {
     ion_receiver_t rx;
     ion_sender_t tx_back;
 } ion_spawn_ctx_0;
+static int ion_fn_lit_0(int x);
 
 typedef struct Vec_int {
     void* data;
@@ -118,6 +119,7 @@ int reference_example(void);
 int generic_example(void);
 int tuple_example(void);
 int spawn_channel_example(void);
+int fn_literal_example(void);
 int complex_example(void);
 int main(void);
 int get_first_int(Pair_int pair);
@@ -494,6 +496,19 @@ int spawn_channel_example(void) {
         return ret_val;
 }
 
+int fn_literal_example(void) {
+    int ret_val = 0;
+    int (*twice)(int) = ion_fn_lit_0;
+    if (twice(21) != 42) {
+        ret_val = 1;
+        goto epilogue;
+    }
+    ret_val = 0;
+    goto epilogue;
+epilogue:
+        return ret_val;
+}
+
 int complex_example(void) {
     int ret_val = 0;
     Vec_int* numbers = ((Vec_int*)(ion_vec_new(sizeof(int))));
@@ -595,10 +610,14 @@ int main(void) {
         ret_val = 9;
         goto epilogue;
     }
-    if (complex_example() != 0) {
+    if (fn_literal_example() != 0) {
         ret_val = 10;
         goto epilogue;
     }
+    if (complex_example() != 0) {
+        ret_val = 11;
+        goto epilogue;
+    }
     ret_val = 0;
     goto epilogue;
 epilogue:
@@ -630,3 +649,11 @@ static void* ion_spawn_entry_0(void* arg) {
     return NULL;
 }
 
+static int ion_fn_lit_0(int x) {
+    int ret_val = 0;
+    ret_val = (x * 2);
+    goto ion_fn_lit_0_epilogue;
+ion_fn_lit_0_epilogue:
+    return ret_val;
+}
+

examples/showcase.ion

@@ -332,7 +332,20 @@ fn spawn_channel_example() -> int {
 }
 
 // ============================================
-// 13. COMPLEX EXAMPLE - Combining features
+// 13. FN LITERALS - Capture-free function pointers
+// ============================================
+fn fn_literal_example() -> int {
+    let twice: fn(int) -> int = fn(x: int) -> int {
+        return x * 2;
+    };
+    if twice(21) != 42 {
+        return 1;
+    }
+    return 0;
+}
+
+// ============================================
+// 14. COMPLEX EXAMPLE - Combining features
 // ============================================
 fn complex_example() -> int {
     let mut numbers: Vec<int> = Vec::new();
@@ -426,9 +439,13 @@ fn main() -> int {
         return 9;
     }
 
-    if complex_example() != 0 {
+    if fn_literal_example() != 0 {
         return 10;
     }
 
+    if complex_example() != 0 {
+        return 11;
+    }
+
     return 0;
 }

src/ast/mod.rs

@@ -276,6 +276,15 @@ pub enum Expr {
     Index(IndexExpr),
     Cast(CastExpr),
     Assign(AssignExpr),
+    FnLiteral(FnLiteralExpr),
+}
+
+#[derive(Debug, Clone)]
+pub struct FnLiteralExpr {
+    pub params: Vec<Param>,
+    pub return_type: Option<Type>,
+    pub body: Block,
+    pub span: Span,
 }
 
 #[derive(Debug, Clone)]