lab/sx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(ir): extract GenericResolver (generics.zig) for substitution + mono keys (A4.1 step 2)

Browse Source 
Generic substitution and monomorphization-key construction now live in one
module, src/ir/generics.zig, behind a *Lowering facade (GenericResolver),
mirroring CallResolver / ExprTyper. Moved verbatim:
- mangleTypeName + mangleParamList (the mono-key fragment builder),
- mangleGenericName (generic mono key), appendComptimeValueMangle (comptime-value
  fragment),
- buildTypeBindings (call-site type-param inference), inferGenericReturnType
  (generic return resolution).

inferGenericReturnType now uses a scoped TypeBindingScope (enter/exit with defer)
instead of a manual type_bindings save/restore — the PLAN-ARCH A4.1 "scoped
substitution env" shape; a generics.test.zig assertion confirms the prior
bindings are restored (the issue-0048/0050 leak class, for this field).

Lowering keeps a thin pub mangleTypeName wrapper delegating to
genericResolver().mangleTypeName, because ~30 cross-cutting callers (impl-map
keys, conversion keys, shape keys) reach it well beyond generics. mangleParamList
(sole caller was mangleTypeName) moved fully. The other 4 originals are deleted
(no fallback); their 6 call sites now go through self.genericResolver()
(calls.zig via self.l.genericResolver()).

matchTypeParam / extractTypeParam / isTypeParamDecl widened to pub (the moved
substitution logic calls them); genericResolver() accessor added. The 2
mangleTypeName / inferGenericReturnType unit tests moved from lower.test.zig to
generics.test.zig (driving GenericResolver directly) and wired into the barrel.

monomorphizeFunction / monomorphizePackFn intentionally stay in lower.zig (they
save/restore three fields across nested mono and call emission helpers) — a
heavier scoped-env adoption deferred to an optional sub-step 3.

zig build, zig build test, and tests/run_examples.sh (357/0) all green — no .ir
snapshot churn, confirming the move preserved mono-key/substitution output.
This commit is contained in:
agra
2026-06-02 21:28:31 +03:00
parent e1f167a1c3
commit 3ca68189c0
6 changed files with 462 additions and 370 deletions
Download Patch File Download Diff File Expand all files Collapse all files

89
src/ir/lower.test.zig
View File

@@ -828,92 +828,3 @@ test "E1.4c noreturn typing: divergence shapes + if-else unification + block pro
defer alloc.destroy(both_div);
try std.testing.expectEqual(TypeId.noreturn, lowering.inferExprType(both_div));
}
// ── A4.1 test-first scaffolding: generic substitution + mono keys ────
// Lock the CURRENT behavior of the generic mono-key building blocks
// (`mangleTypeName`) and generic-return substitution (`inferGenericReturnType`)
// before they move to `src/ir/generics.zig`. Reached through the existing
// public surface — no new exposure (mirrors the A3.2 sub-step-1 cadence).
test "generics: mangleTypeName encodes the mono-key fragment per type shape" {
// Arena: the compound arms allocate fragment strings via the module
// allocator (`allocPrint` / ArrayList) and never free them — the real
// compiler runs in the compile arena, so an arena keeps the leak checker
// clean without changing the encoding under test.
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const alloc = arena.allocator();
var module = ir_mod.Module.init(alloc);
defer module.deinit();
var l = Lowering.init(&module);
const tt = &module.types;
// Builtins — the leaf fragments `mangleGenericName` concatenates per
// bound type param (`base__<frag>...`).
try std.testing.expectEqualStrings("s64", l.mangleTypeName(.s64));
try std.testing.expectEqualStrings("u8", l.mangleTypeName(.u8));
try std.testing.expectEqualStrings("f32", l.mangleTypeName(.f32));
try std.testing.expectEqualStrings("bool", l.mangleTypeName(.bool));
try std.testing.expectEqualStrings("Any", l.mangleTypeName(.any));
try std.testing.expectEqualStrings("string", l.mangleTypeName(.string));
// Compound shapes — prefix + recursive inner fragment.
try std.testing.expectEqualStrings("ptr_s64", l.mangleTypeName(tt.ptrTo(.s64)));
try std.testing.expectEqualStrings("opt_s64", l.mangleTypeName(tt.optionalOf(.s64)));
try std.testing.expectEqualStrings("ptr_opt_u8", l.mangleTypeName(tt.ptrTo(tt.optionalOf(.u8))));
try std.testing.expectEqualStrings("SL_f64", l.mangleTypeName(tt.intern(.{ .slice = .{ .element = .f64 } })));
try std.testing.expectEqualStrings("mptr_u8", l.mangleTypeName(tt.intern(.{ .many_pointer = .{ .element = .u8 } })));
try std.testing.expectEqualStrings("AR_4_s32", l.mangleTypeName(tt.intern(.{ .array = .{ .element = .s32, .length = 4 } })));
try std.testing.expectEqualStrings("vec_3_f32", l.mangleTypeName(tt.intern(.{ .vector = .{ .element = .f32, .length = 3 } })));
// Named aggregate → its declared name.
const pt = tt.intern(.{ .@"struct" = .{ .name = tt.internString("Point"), .fields = &.{} } });
try std.testing.expectEqualStrings("Point", l.mangleTypeName(pt));
// Tuple: "tu" + "_<frag>" per field.
const tup = tt.intern(.{ .tuple = .{ .fields = &[_]TypeId{ .s64, .bool }, .names = null } });
try std.testing.expectEqualStrings("tu_s64_bool", l.mangleTypeName(tup));
}
test "generics: inferGenericReturnType binds explicit type args, resolves return" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const alloc = arena.allocator();
var module = ir_mod.Module.init(alloc);
defer module.deinit();
var l = Lowering.init(&module);
// pair :: ($T: Type, a: T, b: T) -> T — the return type IS the bound `T`.
const tps = [_]ast.StructTypeParam{.{ .name = "T", .constraint = typeKeyword(alloc, "Type") }};
const params = [_]ast.Param{
.{ .name = "T", .name_span = .{ .start = 0, .end = 0 }, .type_expr = typeKeyword(alloc, "Type") },
.{ .name = "a", .name_span = .{ .start = 0, .end = 0 }, .type_expr = typeKeyword(alloc, "T") },
.{ .name = "b", .name_span = .{ .start = 0, .end = 0 }, .type_expr = typeKeyword(alloc, "T") },
};
const body = alloc.create(Node) catch unreachable;
body.* = .{ .span = .{ .start = 0, .end = 0 }, .data = .{ .block = .{ .stmts = &.{} } } };
const fd = ast.FnDecl{ .name = "pair", .params = &params, .return_type = typeKeyword(alloc, "T"), .body = body, .type_params = &tps };
// Explicit type arg in position 0 binds `T`; the inferred return follows it.
const mkCall = struct {
fn f(a: std.mem.Allocator, type_name: []const u8) ast.Call {
const targ = typeKeyword(a, type_name);
const x = a.create(Node) catch unreachable;
x.* = .{ .span = .{ .start = 0, .end = 0 }, .data = .{ .int_literal = .{ .value = 1 } } };
const y = a.create(Node) catch unreachable;
y.* = .{ .span = .{ .start = 0, .end = 0 }, .data = .{ .int_literal = .{ .value = 2 } } };
const callee = a.create(Node) catch unreachable;
callee.* = .{ .span = .{ .start = 0, .end = 0 }, .data = .{ .identifier = .{ .name = "pair" } } };
const args = a.alloc(*Node, 3) catch unreachable;
args[0] = targ;
args[1] = x;
args[2] = y;
return .{ .callee = callee, .args = args };
}
}.f;
const c_s64 = mkCall(alloc, "s64");
try std.testing.expectEqual(TypeId.s64, l.inferGenericReturnType(&fd, &c_s64));
const c_f64 = mkCall(alloc, "f64");
try std.testing.expectEqual(TypeId.f64, l.inferGenericReturnType(&fd, &c_f64));
}