From 724a919fc1f2d4f3214da186733ac67d930ebce5 Mon Sep 17 00:00:00 2001 From: agra Date: Thu, 4 Jun 2026 21:46:31 +0300 Subject: [PATCH] =?UTF-8?q?feat(lang):=20raw=20provenance=20through=20ALL?= =?UTF-8?q?=20sema=20compound=20type=20metadata=20=E2=80=94=20finish=20uni?= =?UTF-8?q?versal=20raw=20identifier=20in=20the=20LSP=20classifier=20[F0.6?= =?UTF-8?q?]?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The codegen-side resolver was already raw-aware for the universal model; the sema/LSP editor index (the second classifier) only honored the DIRECT raw type. A COMPOUND raw type (`*`s2`, `?`s2`, `[N]`s2`, `[]`s2`, `[*]`s2`) stores its inner type-name as a bare string on the Type info struct, and every resolution site re-read it with skip_builtin=false — so the index reclassified a user type named `s2` as the builtin int, diverging from codegen (issue-0083 class, LSP surface only; codegen unchanged). Structural cure: every compound info struct (Pointer/Optional/Slice/ ManyPointer/Array) carries a REQUIRED is_raw bit (no default — a future construction site cannot drop it). is_raw is set at every construction site (resolveTypeNode arms, fieldType arms, variadic slice, .ptr/slice_expr derivation, for-loop by-ref, substType) and passed as skip_builtin at every resolution site (elementTypeOf, field-access pointer unwrap, index, deref, optional unwrap/null-coalesce, if/while optional binding, match subject). Optional-unwrap + deref sites converted from Type.fromName/pointerPointeeType (builtin-only, divergent) to resolveTypeNameStr(name, is_raw); the now-dead pointerPointeeType removed. Tests: src/sema.test.zig gains pointer/optional/array raw-vs-bare regressions (raw → user type, bare → builtin control) — each FAILS on pre-fix sema, PASSES after — plus a parameterized-raw coverage test. --- issues/0089-backtick-raw-identifier.md | 15 ++- src/sema.test.zig | 129 +++++++++++++++++++++++++ src/sema.zig | 102 ++++++++++++------- src/types.zig | 25 +++-- 4 files changed, 223 insertions(+), 48 deletions(-) diff --git a/issues/0089-backtick-raw-identifier.md b/issues/0089-backtick-raw-identifier.md index 49c1fd1..77efe16 100644 --- a/issues/0089-backtick-raw-identifier.md +++ b/issues/0089-backtick-raw-identifier.md @@ -35,7 +35,15 @@ > builtin int. The SECOND (editor/LSP) classifier in [src/sema.zig] > (`Type.fromTypeExpr` / `resolveTypeNode` / `resolveTypeNameStr`) honors > `is_raw` too, so a backtick reserved-name annotation resolves to the user type -> in hover/completion, not the builtin (no two-resolver divergence). +> in hover/completion, not the builtin (no two-resolver divergence). The raw bit +> is carried STRUCTURALLY through every COMPOUND shape's inner-name metadata — +> `PointerTypeInfo` / `OptionalTypeInfo` / `SliceTypeInfo` / `ManyPointerTypeInfo` +> / `ArrayTypeInfo` each store a REQUIRED `is_raw` ([src/types.zig], no default, +> so a future construction site cannot drop it) that every `resolveTypeNameStr` +> call passes as its `skip_builtin` — so `` *`s2 ``, `` ?`s2 ``, `` [N]`s2 ``, +> `` []`s2 ``, `` [*]`s2 `` field-access / unwrap / index / deref in the editor +> index all reach the user type instead of reclassifying the inner `s2` to the +> builtin (the divergence the DIRECT-only attempt left for compound forms). > - **Declaration position.** A bare reserved-name declaration of EVERY kind > still errors (issue 0076 preserved); the backtick form is exempt. The check > and the exemption are made structurally symmetric: @@ -82,7 +90,10 @@ > `examples/1142-diagnostics-reserved-name-struct-const.sx` (bare struct-body const, > caret on the name). Backtick lexer + `resolveNamed(skip_builtin)` unit tests in > `src/lexer.zig` / `src/ir/type_resolver.test.zig`; the editor/LSP raw-type -> resolution (the second classifier) is pinned in `src/sema.test.zig`. +> resolution (the second classifier) is pinned in `src/sema.test.zig` — the direct +> case plus raw provenance through every compound shape (`` *`s2 `` field access, +> `` ?`s2 `` unwrap, `` [N]`s2 `` index, parameterized `` `s2(s64) ``), each with a +> bare-spelling control that stays the builtin (fail-before verified). > > The original report is preserved below. diff --git a/src/sema.test.zig b/src/sema.test.zig index 09dd22f..150bac5 100644 --- a/src/sema.test.zig +++ b/src/sema.test.zig @@ -84,3 +84,132 @@ test "sema: a raw struct-field annotation resolves to the user type; bare stays try std.testing.expect(b_ty.? == .unsigned); try std.testing.expectEqual(@as(u8, 8), b_ty.?.unsigned); } + +// ── issue 0089: raw provenance through sema's COMPOUND type metadata ──────── +// +// The direct-case fix (above) only covered a bare `` `s2 `` reference. A +// COMPOUND raw type (`*`s2`, `?`s2`, `[N]`s2`, …) stores its inner name as a +// bare string on the Type's info struct; the resolver re-reads that name via +// `resolveTypeNameStr`. Before threading `is_raw` ALONGSIDE the stored name, +// the resolver passed `skip_builtin = false`, so the LSP index reclassified a +// user type named `s2` as the builtin int — diverging from codegen. These +// pin every compound form: the raw inner resolves to the user type (FAILS on +// pre-fix sema), the bare inner stays the builtin (control, preserved). + +fn symType(res: sema.SemaResult, name: []const u8) ?Type { + for (res.symbols) |sym| { + if (std.mem.eql(u8, sym.name, name)) return sym.ty; + } + return null; +} + +test "sema: field access through a raw `*`s2` pointer resolves the user field; bare `*s2` stays builtin" { + var arena = std.heap.ArenaAllocator.init(std.testing.allocator); + defer arena.deinit(); + const alloc = arena.allocator(); + + const src = + \\`s2 :: struct { x: s64; } + \\f :: (p: *`s2) { y := p.x; } + \\g :: (q: *s2) { w := q.*; } + \\ + ; + var parser = Parser.init(alloc, src); + const root = try parser.parse(); + var analyzer = sema.Analyzer.init(alloc); + const res = try analyzer.analyze(root); + + // RAW: `p: *`s2` → field `x` on the user struct → s64. (Pre-fix: the + // pointee `s2` reclassified to the 2-bit int, `.x` not found → unresolved.) + const y = symType(res, "y") orelse return error.MissingSymbol; + try std.testing.expect(y == .signed); + try std.testing.expectEqual(@as(u8, 64), y.signed); + + // CONTROL: `q: *s2` (bare) → deref yields the builtin 2-bit signed int. + const w = symType(res, "w") orelse return error.MissingSymbol; + try std.testing.expect(w == .signed); + try std.testing.expectEqual(@as(u8, 2), w.signed); +} + +test "sema: unwrapping a raw `?`s2` optional resolves the user field; bare `?s2` stays builtin" { + var arena = std.heap.ArenaAllocator.init(std.testing.allocator); + defer arena.deinit(); + const alloc = arena.allocator(); + + const src = + \\`s2 :: struct { x: s64; } + \\f :: (o: ?`s2) { if val := o { y := val.x; } } + \\g :: (b: ?s2) { if v := b { w := v; } } + \\ + ; + var parser = Parser.init(alloc, src); + const root = try parser.parse(); + var analyzer = sema.Analyzer.init(alloc); + const res = try analyzer.analyze(root); + + // RAW: `o: ?`s2` → `if val := o` unwraps to the user struct → `val.x` is s64. + // (Pre-fix: the optional child `s2` reclassified to the 2-bit int.) + const y = symType(res, "y") orelse return error.MissingSymbol; + try std.testing.expect(y == .signed); + try std.testing.expectEqual(@as(u8, 64), y.signed); + + // CONTROL: `b: ?s2` (bare) unwraps to the builtin 2-bit signed int. + const w = symType(res, "w") orelse return error.MissingSymbol; + try std.testing.expect(w == .signed); + try std.testing.expectEqual(@as(u8, 2), w.signed); +} + +test "sema: indexing a raw `[N]`s2` array resolves the user element; bare `[N]s2` stays builtin" { + var arena = std.heap.ArenaAllocator.init(std.testing.allocator); + defer arena.deinit(); + const alloc = arena.allocator(); + + const src = + \\`s2 :: struct { x: s64; } + \\f :: (a: [4]`s2, b: [4]s2) { y := a[0]; w := b[0]; } + \\ + ; + var parser = Parser.init(alloc, src); + const root = try parser.parse(); + var analyzer = sema.Analyzer.init(alloc); + const res = try analyzer.analyze(root); + + // RAW: `a: [4]`s2` → element is the user struct. (Pre-fix: reclassified to + // the 2-bit int.) + const y = symType(res, "y") orelse return error.MissingSymbol; + try std.testing.expect(y == .struct_type); + try std.testing.expectEqualStrings("s2", y.struct_type); + + // CONTROL: `b: [4]s2` (bare) → element is the builtin 2-bit signed int. + const w = symType(res, "w") orelse return error.MissingSymbol; + try std.testing.expect(w == .signed); + try std.testing.expectEqual(@as(u8, 2), w.signed); +} + +// Parameterized raw type (`` `s2(s64) ``). Unlike the shapes above this never +// had the divergence — instantiation resolves the base name straight against +// `struct_types` (no builtin classifier in the path), so it passes before AND +// after. Included as coverage that the universal model holds for the +// parameterized form too: a `` `s2 ``-declared generic instantiates and its +// field resolves. +test "sema: a raw parameterized type `` `s2(s64) `` instantiates the user generic" { + var arena = std.heap.ArenaAllocator.init(std.testing.allocator); + defer arena.deinit(); + const alloc = arena.allocator(); + + const src = + \\`s2 :: struct ($T: Type) { items: [*]T = null; n: s64 = 0; } + \\f :: (v: `s2(s64)) { y := v.n; } + \\ + ; + var parser = Parser.init(alloc, src); + const root = try parser.parse(); + var analyzer = sema.Analyzer.init(alloc); + const res = try analyzer.analyze(root); + + // `v: `s2(s64)` instantiates the `` `s2 ``-declared generic; its concrete + // field `n` resolves to s64 (the raw base name was not misread as a builtin). + const y = symType(res, "y") orelse return error.MissingSymbol; + try std.testing.expect(y == .signed); + try std.testing.expectEqual(@as(u8, 64), y.signed); +} diff --git a/src/sema.zig b/src/sema.zig index ffa8964..9e2f7be 100644 --- a/src/sema.zig +++ b/src/sema.zig @@ -193,7 +193,12 @@ pub const Analyzer = struct { .slice_type_expr => |st| if (st.element_type.data == .type_expr) st.element_type.data.type_expr.name else "", else => "", }; - try param_types.append(self.allocator, .{ .slice_type = .{ .element_name = elem_name } }); + const elem_raw = switch (param.type_expr.data) { + .type_expr => |te| te.is_raw, + .slice_type_expr => |st| typeExprIsRaw(st.element_type), + else => false, + }; + try param_types.append(self.allocator, .{ .slice_type = .{ .element_name = elem_name, .is_raw = elem_raw } }); } else { try param_types.append(self.allocator, pt); } @@ -362,35 +367,35 @@ pub const Analyzer = struct { const length: u32 = @intCast(ate.length.data.int_literal.value); const elem_type = self.resolveTypeNode(ate.element_type); const elem_name = elem_type.displayName(self.allocator) catch return .void_type; - return .{ .array_type = .{ .element_name = elem_name, .length = length } }; + return .{ .array_type = .{ .element_name = elem_name, .length = length, .is_raw = typeExprIsRaw(ate.element_type) } }; } // Slice type: []T if (tn.data == .slice_type_expr) { const ste = tn.data.slice_type_expr; const elem_type = self.resolveTypeNode(ste.element_type); const elem_name = elem_type.displayName(self.allocator) catch return .void_type; - return .{ .slice_type = .{ .element_name = elem_name } }; + return .{ .slice_type = .{ .element_name = elem_name, .is_raw = typeExprIsRaw(ste.element_type) } }; } // Optional type: ?T if (tn.data == .optional_type_expr) { const ote = tn.data.optional_type_expr; const inner_type = self.resolveTypeNode(ote.inner_type); const inner_name = inner_type.displayName(self.allocator) catch return .void_type; - return .{ .optional_type = .{ .child_name = inner_name } }; + return .{ .optional_type = .{ .child_name = inner_name, .is_raw = typeExprIsRaw(ote.inner_type) } }; } // Pointer type: *T if (tn.data == .pointer_type_expr) { const pte = tn.data.pointer_type_expr; const pointee_type = self.resolveTypeNode(pte.pointee_type); const pointee_name = pointee_type.displayName(self.allocator) catch return .void_type; - return .{ .pointer_type = .{ .pointee_name = pointee_name } }; + return .{ .pointer_type = .{ .pointee_name = pointee_name, .is_raw = typeExprIsRaw(pte.pointee_type) } }; } // Many-pointer type: [*]T if (tn.data == .many_pointer_type_expr) { const mpte = tn.data.many_pointer_type_expr; const elem_type = self.resolveTypeNode(mpte.element_type); const elem_name = elem_type.displayName(self.allocator) catch return .void_type; - return .{ .many_pointer_type = .{ .element_name = elem_name } }; + return .{ .many_pointer_type = .{ .element_name = elem_name, .is_raw = typeExprIsRaw(mpte.element_type) } }; } // Function pointer type: (ParamTypes) -> ReturnType if (tn.data == .function_type_expr) { @@ -466,6 +471,31 @@ pub const Analyzer = struct { }; } + /// The backtick raw bit of an inner type-name node (`` `s2 ``). A compound + /// shape (`*T`, `?T`, `[]T`, …) stores its inner name as a bare string, so + /// this bit must travel ALONGSIDE that name (issue 0089) — otherwise the + /// resolver re-reads `s2` as the builtin int. Non-leaf nodes are never raw. + fn typeExprIsRaw(node: *Node) bool { + return switch (node.data) { + .type_expr => |te| te.is_raw, + .identifier => |id| id.is_raw, + else => false, + }; + } + + /// When a compound shape stores the NAME of an ALREADY-resolved inner type + /// (no syntactic node to read `is_raw` from — e.g. a for-loop element), a + /// user nominal type must be re-resolved with `skip_builtin` so a struct/ + /// enum/union named `s2` is not reclassified as the builtin. Builtins keep + /// `false`. Harmless for non-colliding names (the registry lookup is the + /// same either way). + fn innerNameIsRaw(inner: Type) bool { + return switch (inner) { + .struct_type, .enum_type, .union_type => true, + else => false, + }; + } + /// Resolve a struct field's declared type, preserving the raw element/ /// pointee name of pointer/slice shapes so generic params (`T`) survive /// into `instantiateGeneric`'s substitution. Bare names resolve through the @@ -474,9 +504,9 @@ pub const Analyzer = struct { return switch (node.data) { .type_expr => |te| self.resolveTypeNameStr(te.name, te.is_raw), .identifier => |id| self.resolveTypeNameStr(id.name, id.is_raw), - .many_pointer_type_expr => |mp| .{ .many_pointer_type = .{ .element_name = self.typeExprName(mp.element_type) } }, - .pointer_type_expr => |p| .{ .pointer_type = .{ .pointee_name = self.typeExprName(p.pointee_type) } }, - .slice_type_expr => |s| .{ .slice_type = .{ .element_name = self.typeExprName(s.element_type) } }, + .many_pointer_type_expr => |mp| .{ .many_pointer_type = .{ .element_name = self.typeExprName(mp.element_type), .is_raw = typeExprIsRaw(mp.element_type) } }, + .pointer_type_expr => |p| .{ .pointer_type = .{ .pointee_name = self.typeExprName(p.pointee_type), .is_raw = typeExprIsRaw(p.pointee_type) } }, + .slice_type_expr => |s| .{ .slice_type = .{ .element_name = self.typeExprName(s.element_type), .is_raw = typeExprIsRaw(s.element_type) } }, .parameterized_type_expr => |pte| self.instantiateGeneric(pte.name, pte.args) orelse self.resolveTypeNode(node), else => self.resolveTypeNode(node), }; @@ -488,15 +518,15 @@ pub const Analyzer = struct { /// pointee first (so `*List(Move)` still iterates `Move`). fn elementTypeOf(self: *Analyzer, ty: Type) ?Type { return switch (ty) { - .array_type => |i| self.resolveTypeNameStr(i.element_name, false), - .slice_type => |i| self.resolveTypeNameStr(i.element_name, false), - .many_pointer_type => |i| self.resolveTypeNameStr(i.element_name, false), - .pointer_type => |i| self.elementTypeOf(self.resolveTypeNameStr(i.pointee_name, false)), + .array_type => |i| self.resolveTypeNameStr(i.element_name, i.is_raw), + .slice_type => |i| self.resolveTypeNameStr(i.element_name, i.is_raw), + .many_pointer_type => |i| self.resolveTypeNameStr(i.element_name, i.is_raw), + .pointer_type => |i| self.elementTypeOf(self.resolveTypeNameStr(i.pointee_name, i.is_raw)), .struct_type => |name| blk: { const info = self.struct_types.get(name) orelse break :blk null; for (info.field_names, info.field_types) |fname, fty| { if (std.mem.eql(u8, fname, "items") and fty == .many_pointer_type) { - break :blk self.resolveTypeNameStr(fty.many_pointer_type.element_name, false); + break :blk self.resolveTypeNameStr(fty.many_pointer_type.element_name, fty.many_pointer_type.is_raw); } } break :blk null; @@ -527,10 +557,10 @@ pub const Analyzer = struct { /// name-carrying shapes need rewriting; the rest pass through. fn substType(ty: Type, params: []const []const u8, args: []const []const u8) Type { return switch (ty) { - .many_pointer_type => |i| .{ .many_pointer_type = .{ .element_name = substName(i.element_name, params, args) } }, - .slice_type => |i| .{ .slice_type = .{ .element_name = substName(i.element_name, params, args) } }, - .array_type => |i| .{ .array_type = .{ .length = i.length, .element_name = substName(i.element_name, params, args) } }, - .pointer_type => |i| .{ .pointer_type = .{ .pointee_name = substName(i.pointee_name, params, args) } }, + .many_pointer_type => |i| .{ .many_pointer_type = .{ .element_name = substName(i.element_name, params, args), .is_raw = i.is_raw } }, + .slice_type => |i| .{ .slice_type = .{ .element_name = substName(i.element_name, params, args), .is_raw = i.is_raw } }, + .array_type => |i| .{ .array_type = .{ .length = i.length, .element_name = substName(i.element_name, params, args), .is_raw = i.is_raw } }, + .pointer_type => |i| .{ .pointer_type = .{ .pointee_name = substName(i.pointee_name, params, args), .is_raw = i.is_raw } }, .struct_type => |n| .{ .struct_type = substName(n, params, args) }, else => ty, }; @@ -654,16 +684,16 @@ pub const Analyzer = struct { var obj_ty = self.inferExprType(fa.object); // `p.field` where `p` is `*T` resolves on the pointee `T`. if (obj_ty.isPointer()) { - obj_ty = self.resolveTypeNameStr(obj_ty.pointer_type.pointee_name, false); + obj_ty = self.resolveTypeNameStr(obj_ty.pointer_type.pointee_name, obj_ty.pointer_type.is_raw); } // `.len` / `.ptr` on the built-in containers (string, slice, array). if (std.mem.eql(u8, fa.field, "len")) { if (obj_ty == .string_type or obj_ty.isSlice() or obj_ty.isArray()) return Type.s(64); } if (std.mem.eql(u8, fa.field, "ptr")) { - if (obj_ty == .string_type) return .{ .many_pointer_type = .{ .element_name = "u8" } }; - if (obj_ty.isSlice()) return .{ .many_pointer_type = .{ .element_name = obj_ty.slice_type.element_name } }; - if (obj_ty.isArray()) return .{ .many_pointer_type = .{ .element_name = obj_ty.array_type.element_name } }; + if (obj_ty == .string_type) return .{ .many_pointer_type = .{ .element_name = "u8", .is_raw = false } }; + if (obj_ty.isSlice()) return .{ .many_pointer_type = .{ .element_name = obj_ty.slice_type.element_name, .is_raw = obj_ty.slice_type.is_raw } }; + if (obj_ty.isArray()) return .{ .many_pointer_type = .{ .element_name = obj_ty.array_type.element_name, .is_raw = obj_ty.array_type.is_raw } }; } if (obj_ty.isStruct()) { if (self.struct_types.get(obj_ty.struct_type)) |info| { @@ -675,23 +705,23 @@ pub const Analyzer = struct { } } if (obj_ty.isArray()) { - return Type.fromName(obj_ty.array_type.element_name) orelse Type.unresolved; + return self.resolveTypeNameStr(obj_ty.array_type.element_name, obj_ty.array_type.is_raw); } return Type.unresolved; }, .index_expr => |ie| { const obj_ty = self.inferExprType(ie.object); if (obj_ty == .string_type) return Type.u(8); - if (obj_ty.isArray()) return self.resolveTypeNameStr(obj_ty.array_type.element_name, false); - if (obj_ty.isManyPointer()) return self.resolveTypeNameStr(obj_ty.many_pointer_type.element_name, false); - if (obj_ty.isSlice()) return self.resolveTypeNameStr(obj_ty.slice_type.element_name, false); + if (obj_ty.isArray()) return self.resolveTypeNameStr(obj_ty.array_type.element_name, obj_ty.array_type.is_raw); + if (obj_ty.isManyPointer()) return self.resolveTypeNameStr(obj_ty.many_pointer_type.element_name, obj_ty.many_pointer_type.is_raw); + if (obj_ty.isSlice()) return self.resolveTypeNameStr(obj_ty.slice_type.element_name, obj_ty.slice_type.is_raw); return Type.unresolved; }, .slice_expr => |se| { const obj_ty = self.inferExprType(se.object); if (obj_ty == .string_type) return .string_type; - if (obj_ty.isArray()) return .{ .slice_type = .{ .element_name = obj_ty.array_type.element_name } }; - if (obj_ty.isManyPointer()) return .{ .slice_type = .{ .element_name = obj_ty.many_pointer_type.element_name } }; + if (obj_ty.isArray()) return .{ .slice_type = .{ .element_name = obj_ty.array_type.element_name, .is_raw = obj_ty.array_type.is_raw } }; + if (obj_ty.isManyPointer()) return .{ .slice_type = .{ .element_name = obj_ty.many_pointer_type.element_name, .is_raw = obj_ty.many_pointer_type.is_raw } }; if (obj_ty.isSlice()) return obj_ty; return .void_type; }, @@ -721,17 +751,17 @@ pub const Analyzer = struct { }, .force_unwrap => |fu| { const opt_ty = self.inferExprType(fu.operand); - if (opt_ty.isOptional()) return Type.fromName(opt_ty.optional_type.child_name) orelse .void_type; + if (opt_ty.isOptional()) return self.resolveTypeNameStr(opt_ty.optional_type.child_name, opt_ty.optional_type.is_raw); return .void_type; }, .null_coalesce => |nc| { const opt_ty = self.inferExprType(nc.lhs); - if (opt_ty.isOptional()) return Type.fromName(opt_ty.optional_type.child_name) orelse .void_type; + if (opt_ty.isOptional()) return self.resolveTypeNameStr(opt_ty.optional_type.child_name, opt_ty.optional_type.is_raw); return self.inferExprType(nc.rhs); }, .deref_expr => |de| { const ptr_ty = self.inferExprType(de.operand); - if (ptr_ty.isPointer()) return ptr_ty.pointerPointeeType() orelse .void_type; + if (ptr_ty.isPointer()) return self.resolveTypeNameStr(ptr_ty.pointer_type.pointee_name, ptr_ty.pointer_type.is_raw); return .void_type; }, .null_literal => .void_type, @@ -1066,7 +1096,7 @@ pub const Analyzer = struct { .field_access => |fa| { try self.analyzeNode(fa.object); var owner_ty = self.inferExprType(fa.object); - if (owner_ty.isPointer()) owner_ty = self.resolveTypeNameStr(owner_ty.pointer_type.pointee_name, false); + if (owner_ty.isPointer()) owner_ty = self.resolveTypeNameStr(owner_ty.pointer_type.pointee_name, owner_ty.pointer_type.is_raw); self.recordMemberRef(fa.field, owner_ty.toName() orelse "", false); }, .enum_literal => |el| { @@ -1078,7 +1108,7 @@ pub const Analyzer = struct { // `if val := expr { ... }` — val is the unwrapped optional const cond_ty = self.inferExprType(ie.condition); const inner_ty: ?Type = if (cond_ty.isOptional()) - Type.fromName(cond_ty.optional_type.child_name) + self.resolveTypeNameStr(cond_ty.optional_type.child_name, cond_ty.optional_type.is_raw) else null; try self.pushScope(); @@ -1095,7 +1125,7 @@ pub const Analyzer = struct { .match_expr => |me| { try self.analyzeNode(me.subject); var subj_ty = self.inferExprType(me.subject); - if (subj_ty.isPointer()) subj_ty = self.resolveTypeNameStr(subj_ty.pointer_type.pointee_name, false); + if (subj_ty.isPointer()) subj_ty = self.resolveTypeNameStr(subj_ty.pointer_type.pointee_name, subj_ty.pointer_type.is_raw); const subj_owner = subj_ty.toName() orelse ""; for (me.arms) |arm| { if (arm.pattern) |pat| { @@ -1114,7 +1144,7 @@ pub const Analyzer = struct { if (we.binding_name) |bname| { const cond_ty = self.inferExprType(we.condition); const inner_ty: ?Type = if (cond_ty.isOptional()) - Type.fromName(cond_ty.optional_type.child_name) + self.resolveTypeNameStr(cond_ty.optional_type.child_name, cond_ty.optional_type.is_raw) else null; try self.pushScope(); @@ -1134,7 +1164,7 @@ pub const Analyzer = struct { cap_ty = .{ .signed = 64 }; } else if (self.elementTypeOf(self.inferExprType(fe.iterable))) |elem| { cap_ty = if (fe.capture_by_ref) - (if (elem.toName()) |en| Type{ .pointer_type = .{ .pointee_name = en } } else elem) + (if (elem.toName()) |en| Type{ .pointer_type = .{ .pointee_name = en, .is_raw = innerNameIsRaw(elem) } } else elem) else elem; } diff --git a/src/types.zig b/src/types.zig index 168760a..30adae6 100644 --- a/src/types.zig +++ b/src/types.zig @@ -42,16 +42,26 @@ pub const Type = union(enum) { /// `ir.TypeId.unresolved`. unresolved, + /// `is_raw` records whether the inner type-name came from a backtick raw + /// reference (`` `s2 ``) or an already-resolved user type. It is the + /// `skip_builtin` the resolver MUST pass when re-resolving the stored inner + /// name (issue 0089) — without it `resolveTypeNameStr` would reclassify a + /// user type named `s2` as the builtin int, diverging from codegen. The + /// field is REQUIRED (no default) so a future construction site cannot + /// silently drop the bit, the way the LSP index did for compound shapes. pub const SliceTypeInfo = struct { element_name: []const u8, + is_raw: bool, }; pub const PointerTypeInfo = struct { pointee_name: []const u8, + is_raw: bool, }; pub const ManyPointerTypeInfo = struct { element_name: []const u8, + is_raw: bool, }; pub const FunctionTypeInfo = struct { @@ -67,6 +77,7 @@ pub const Type = union(enum) { pub const ArrayTypeInfo = struct { element_name: []const u8, length: u32, + is_raw: bool, }; pub const VectorTypeInfo = struct { @@ -76,6 +87,7 @@ pub const Type = union(enum) { pub const OptionalTypeInfo = struct { child_name: []const u8, + is_raw: bool, }; pub const MetaTypeInfo = struct { @@ -125,7 +137,7 @@ pub const Type = union(enum) { if (std.mem.eql(u8, name, "f64")) return .f64; return null; }, - '?' => if (name.len >= 2) .{ .optional_type = .{ .child_name = name[1..] } } else null, + '?' => if (name.len >= 2) .{ .optional_type = .{ .child_name = name[1..], .is_raw = false } } else null, 'A' => if (std.mem.eql(u8, name, "Any")) .any_type else null, 'v' => if (std.mem.eql(u8, name, "void")) .void_type else null, '[' => { @@ -141,11 +153,11 @@ pub const Type = union(enum) { } // Many-pointer: [*]T if (name.len >= 4 and name[1] == '*' and name[2] == ']') { - return .{ .many_pointer_type = .{ .element_name = name[3..] } }; + return .{ .many_pointer_type = .{ .element_name = name[3..], .is_raw = false } }; } return null; }, - '*' => if (name.len >= 2) .{ .pointer_type = .{ .pointee_name = name[1..] } } else null, + '*' => if (name.len >= 2) .{ .pointer_type = .{ .pointee_name = name[1..], .is_raw = false } } else null, 'V' => { // Vector(N,T) if (name.len >= 10 and std.mem.startsWith(u8, name, "Vector(") and name[name.len - 1] == ')') { @@ -235,13 +247,6 @@ pub const Type = union(enum) { }; } - pub fn pointerPointeeType(self: Type) ?Type { - return switch (self) { - .pointer_type => |info| fromName(info.pointee_name), - else => null, - }; - } - pub fn isManyPointer(self: Type) bool { return switch (self) { .many_pointer_type => true,