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

lang: rename signed integer types sN -> iN

Browse Source 
Surface rename of the signed integer family: s1..s64 become i1..i64
(u1..u64, usize, isize unchanged). 'string' keeps the s-prefix arm in
name classification; width parsing moves to the i-prefix arm next to
isize.

Internal TypeId tags follow the surface (.s8/.s16/.s32/.s64 ->
.i8/.i16/.i32/.i64), as do mono-key mangle fragments (ptr_i64,
tu_i64_bool) and all display/diagnostic formatting (i{d}).

Migrated in the same sweep: stdlib + examples + issue repros + FFI C
companions (shared symbol names like ffi_id_i64), expected
stdout/stderr/ir snapshots, specs.md, readme.md, CLAUDE.md/AGENTS.md,
implementation_plan.md, docs/, issue writeups. Vendored stb_image and
historical flow state left untouched.

zig build test: 426/426; examples suite: 595/595.
This commit is contained in:
agra
2026-06-12 09:31:53 +03:00
parent 515ecebea7
commit d8076b9333
1054 changed files with 6836 additions and 6839 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
src/parser.zig
View File

@@ -640,14 +640,14 @@ pub const Parser = struct {
}
if (self.current.tag.isTypeKeyword() or self.isIdentLike()) {
// A backtick raw identifier (`` `s2 ``) in type position is the
// LITERAL name `s2` used as a type reference — never the builtin /
// A backtick raw identifier (`` `i2 ``) in type position is the
// LITERAL name `i2` used as a type reference — never the builtin /
// reserved keyword. The raw flag rides the type ATOM through the
// SAME qualified-path / `Closure` / parameterized continuations as a
// bare name (so `` `s2(s64) ``, `` `s2.Inner ``, `` *`s2 `` all
// bare name (so `` `i2(i64) ``, `` `i2.Inner ``, `` *`i2 `` all
// parse); it is threaded onto the final `type_expr` /
// `parameterized_type_expr` so resolution skips the builtin
// classifier and looks up a `` `s2 ``-declared type.
// classifier and looks up a `` `i2 ``-declared type.
const atom_is_raw = self.current.is_raw;
var name = self.tokenSlice(self.current);
self.advance();
@@ -2787,10 +2787,10 @@ pub const Parser = struct {
.identifier => {
const name = self.tokenSlice(self.current);
const is_raw = self.current.is_raw;
// A backtick raw identifier (`` `s2 ``) is NEVER type-classified —
// A backtick raw identifier (`` `i2 ``) is NEVER type-classified —
// it is always a value identifier, bypassing the reserved-type-name
// rule. Only a bare spelling is checked for a type name
// (e.g. s32, u8, s128).
// (e.g. i32, u8, s128).
if (!is_raw and Type.fromName(name) != null) {
self.advance();
return try self.createNode(start, .{ .type_expr = .{ .name = name } });
@@ -2900,7 +2900,7 @@ pub const Parser = struct {
return try self.parseEnumDecl("__anon", start, false);
},
.kw_union => {
// Anonymous C-style union expression: union { f: f32; i: s32; }
// Anonymous C-style union expression: union { f: f32; i: i32; }
return try self.parseUnionDecl("__anon", start, false);
},
.kw_if => {
@@ -3978,7 +3978,7 @@ test "parse minimal main" {
test "block value: trailing expr without `;` produces a value" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var parser = Parser.init(arena.allocator(), "f :: () -> s32 { 42 }");
var parser = Parser.init(arena.allocator(), "f :: () -> i32 { 42 }");
const root = try parser.parse();
const body = root.data.root.decls[0].data.fn_decl.body;
try std.testing.expect(body.data.block.produces_value);
@@ -3988,7 +3988,7 @@ test "block value: trailing expr without `;` produces a value" {
test "block value: trailing `;` discards the value" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var parser = Parser.init(arena.allocator(), "f :: () -> s32 { 42; }");
var parser = Parser.init(arena.allocator(), "f :: () -> i32 { 42; }");
const root = try parser.parse();
const body = root.data.root.decls[0].data.fn_decl.body;
try std.testing.expect(!body.data.block.produces_value);
@@ -3998,7 +3998,7 @@ test "block value: trailing `;` discards the value" {
test "block value: match arms are exempt (keep `;`, still produce a value)" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var parser = Parser.init(arena.allocator(), "f :: (n: s32) -> s32 { if n == { case 1: 5; else: 0; } }");
var parser = Parser.init(arena.allocator(), "f :: (n: i32) -> i32 { if n == { case 1: 5; else: 0; } }");
const root = try parser.parse();
const body = root.data.root.decls[0].data.fn_decl.body;
// Function body's trailing match has no `;` → the body is a value.
@@ -4092,7 +4092,7 @@ test "parse void function with builtin body" {
}
test "parse void function with foreign body" {
const source = "InitWindow :: (width: s32, height: s32, title: *u8) -> void #foreign rl;";
const source = "InitWindow :: (width: i32, height: i32, title: *u8) -> void #foreign rl;";
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var parser = Parser.init(arena.allocator(), source);
@@ -4170,7 +4170,7 @@ test "parse lambda with generic params" {
}
test "parse lambda with return type" {
const source = "f :: (x: s32) -> s32 => x;";
const source = "f :: (x: i32) -> i32 => x;";
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var parser = Parser.init(arena.allocator(), source);
@@ -4180,7 +4180,7 @@ test "parse lambda with return type" {
const fd = decl.data.fn_decl;
try std.testing.expect(fd.return_type != null);
try std.testing.expect(fd.return_type.?.data == .type_expr);
try std.testing.expectEqualStrings("s32", fd.return_type.?.data.type_expr.name);
try std.testing.expectEqualStrings("i32", fd.return_type.?.data.type_expr.name);
}
test "parse match with else arm" {
@@ -4315,7 +4315,7 @@ test "parse pack expansion: tuple type (..F(Ts))" {
}
test "parse pack expansion: closure sig projection Closure(..sources.T)" {
const source = "h :: (cb: Closure(..sources.T) -> s32) => cb;";
const source = "h :: (cb: Closure(..sources.T) -> i32) => cb;";
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var parser = Parser.init(arena.allocator(), source);
@@ -4327,7 +4327,7 @@ test "parse pack expansion: closure sig projection Closure(..sources.T)" {
}
test "parse closure sig bare pack Closure(..Ts) has no projection" {
const source = "j :: (cb: Closure(..Ts) -> s32) => cb;";
const source = "j :: (cb: Closure(..Ts) -> i32) => cb;";
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var parser = Parser.init(arena.allocator(), source);
@@ -4405,7 +4405,7 @@ test "parse bare failable return: named `!Foo`" {
}
test "parse multi-return with inferred `!` as trailing element" {
const source = "f :: () -> (s32, !) { 0; }";
const source = "f :: () -> (i32, !) { 0; }";
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var parser = Parser.init(arena.allocator(), source);
@@ -4415,13 +4415,13 @@ test "parse multi-return with inferred `!` as trailing element" {
const fields = rt.data.tuple_type_expr.field_types;
try std.testing.expectEqual(@as(usize, 2), fields.len);
try std.testing.expect(fields[0].data == .type_expr);
try std.testing.expectEqualStrings("s32", fields[0].data.type_expr.name);
try std.testing.expectEqualStrings("i32", fields[0].data.type_expr.name);
try std.testing.expect(fields[1].data == .error_type_expr);
try std.testing.expect(fields[1].data.error_type_expr.name == null);
}
test "parse multi-return with named `!Foo` as trailing element" {
const source = "f :: () -> (s32, s64, !ParseErr) { 0; }";
const source = "f :: () -> (i32, i64, !ParseErr) { 0; }";
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var parser = Parser.init(arena.allocator(), source);
@@ -4435,7 +4435,7 @@ test "parse multi-return with named `!Foo` as trailing element" {
}
test "parse error type rejected when not the trailing result element" {
const source = "f :: () -> (!, s32) { 0; }";
const source = "f :: () -> (!, i32) { 0; }";
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var parser = Parser.init(arena.allocator(), source);
@@ -4443,7 +4443,7 @@ test "parse error type rejected when not the trailing result element" {
}
test "parse error type rejected in the middle of a result list" {
const source = "f :: () -> (s32, !, s64) { 0; }";
const source = "f :: () -> (i32, !, i64) { 0; }";
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var parser = Parser.init(arena.allocator(), source);
@@ -4679,7 +4679,7 @@ test "E1.7 return inside a closure within a cleanup body is allowed" {
// flags, so `return` from the closure body is legal even inside `defer`.
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
var parser = Parser.init(arena.allocator(), "f :: () { defer g((x: s32) -> s32 { return x; }); }");
var parser = Parser.init(arena.allocator(), "f :: () { defer g((x: i32) -> i32 { return x; }); }");
_ = try parser.parse();
}
@@ -4812,7 +4812,7 @@ test "E0.3 or value-terminator: parse(s) or 0" {
test "E0.3 full failable function parses end-to-end (all E0 forms)" {
const source =
\\parse :: (s: string) -> (s32, !ParseErr) {
\\parse :: (s: string) -> (i32, !ParseErr) {
\\ onfail (e) { cleanup(s); }
\\ v := try inner(s) or 0;
\\ w := other(s) catch (e2) { return 0; };