From 7ed6b397446cfa213ebe5b5437e3dab03eca9c16 Mon Sep 17 00:00:00 2001 From: Hojun-Cho Date: Mon, 11 May 2026 14:38:20 +0900 Subject: [PATCH] selfhost/cmd/wcc/typ: drop ty_ prefix underscore on tctx primitives --- selfhost/cmd/w6c/main.combined.ww | 134 +++++++++++++-------------- selfhost/cmd/wcc/cgen.ww | 2 +- selfhost/cmd/wcc/check.ww | 34 +++---- selfhost/cmd/wcc/typ.ww | 98 ++++++++++---------- selfhost/cmd/wwdump/main.combined.ww | 134 +++++++++++++-------------- 5 files changed, 201 insertions(+), 201 deletions(-) diff --git a/selfhost/cmd/w6c/main.combined.ww b/selfhost/cmd/w6c/main.combined.ww index 89d8e10c..1daab83a 100644 --- a/selfhost/cmd/w6c/main.combined.ww +++ b/selfhost/cmd/w6c/main.combined.ww @@ -2901,7 +2901,7 @@ export fn parsefile(p: *parser) *node = { // selfhost/cmd/wcc/type.ww — port of cmd/wcc/type.c. // // Status: full structural port. The C version uses module-globals for -// the primitive types (ty_void, ty_i32, …); ww doesn't have writable +// the primitive types (tyvoid, tyi32, …); ww doesn't have writable // global storage yet, so we bundle the primitives into a `tctx` that // the checker passes around explicitly. typesinit fills the tctx // once per arena. @@ -2982,30 +2982,30 @@ type tinfo = struct { type tctx = struct { a: *arena, - ty_void: *tinfo, - ty_bool: *tinfo, - ty_rune: *tinfo, - ty_i8: *tinfo, - ty_i16: *tinfo, - ty_i32: *tinfo, - ty_i64: *tinfo, - ty_u8: *tinfo, - ty_u16: *tinfo, - ty_u32: *tinfo, - ty_u64: *tinfo, - ty_int: *tinfo, - ty_uint: *tinfo, - ty_uintptr: *tinfo, - ty_f32: *tinfo, - ty_f64: *tinfo, - ty_str: *tinfo, - ty_err: *tinfo, - ty_untyped_int: *tinfo, - ty_untyped_float: *tinfo, - ty_untyped_str: *tinfo, - ty_untyped_rune: *tinfo, - ty_untyped_bool: *tinfo, - ty_untyped_nil: *tinfo, + tyvoid: *tinfo, + tybool: *tinfo, + tyrune: *tinfo, + tyi8: *tinfo, + tyi16: *tinfo, + tyi32: *tinfo, + tyi64: *tinfo, + tyu8: *tinfo, + tyu16: *tinfo, + tyu32: *tinfo, + tyu64: *tinfo, + tyint: *tinfo, + tyuint: *tinfo, + tyuintptr: *tinfo, + tyf32: *tinfo, + tyf64: *tinfo, + tystr: *tinfo, + tyerr: *tinfo, + tyuntypedint: *tinfo, + tyuntypedfloat: *tinfo, + tyuntypedstr: *tinfo, + tyuntypedrune: *tinfo, + tyuntypedbool: *tinfo, + tyuntypednil: *tinfo, }; // ---- constructors ----------------------------------------------------- @@ -3026,31 +3026,31 @@ fn prim(a: *arena, k: i32, nm: str, sz: u64, al: u64) *tinfo = { export fn typesinit(c: *tctx, a: *arena) void = { c.a = a; - c.ty_void = prim(a, TY_VOID, "void", 0u64, 1u64); - c.ty_bool = prim(a, TY_BOOL, "bool", 1u64, 1u64); - c.ty_rune = prim(a, TY_RUNE, "rune", 4u64, 4u64); - c.ty_i8 = prim(a, TY_I8, "i8", 1u64, 1u64); - c.ty_i16 = prim(a, TY_I16, "i16", 2u64, 2u64); - c.ty_i32 = prim(a, TY_I32, "i32", 4u64, 4u64); - c.ty_i64 = prim(a, TY_I64, "i64", 8u64, 8u64); - c.ty_u8 = prim(a, TY_U8, "u8", 1u64, 1u64); - c.ty_u16 = prim(a, TY_U16, "u16", 2u64, 2u64); - c.ty_u32 = prim(a, TY_U32, "u32", 4u64, 4u64); - c.ty_u64 = prim(a, TY_U64, "u64", 8u64, 8u64); - c.ty_int = prim(a, TY_INT, "int", 8u64, 8u64); - c.ty_uint = prim(a, TY_UINT, "uint", 8u64, 8u64); - c.ty_uintptr= prim(a, TY_UINTPTR, "uintptr", 8u64, 8u64); - c.ty_f32 = prim(a, TY_F32, "f32", 4u64, 4u64); - c.ty_f64 = prim(a, TY_F64, "f64", 8u64, 8u64); - c.ty_str = prim(a, TY_STR, "str", 16u64, 8u64); - c.ty_err = prim(a, TY_ERR, "", 0u64, 1u64); + c.tyvoid = prim(a, TY_VOID, "void", 0u64, 1u64); + c.tybool = prim(a, TY_BOOL, "bool", 1u64, 1u64); + c.tyrune = prim(a, TY_RUNE, "rune", 4u64, 4u64); + c.tyi8 = prim(a, TY_I8, "i8", 1u64, 1u64); + c.tyi16 = prim(a, TY_I16, "i16", 2u64, 2u64); + c.tyi32 = prim(a, TY_I32, "i32", 4u64, 4u64); + c.tyi64 = prim(a, TY_I64, "i64", 8u64, 8u64); + c.tyu8 = prim(a, TY_U8, "u8", 1u64, 1u64); + c.tyu16 = prim(a, TY_U16, "u16", 2u64, 2u64); + c.tyu32 = prim(a, TY_U32, "u32", 4u64, 4u64); + c.tyu64 = prim(a, TY_U64, "u64", 8u64, 8u64); + c.tyint = prim(a, TY_INT, "int", 8u64, 8u64); + c.tyuint = prim(a, TY_UINT, "uint", 8u64, 8u64); + c.tyuintptr= prim(a, TY_UINTPTR, "uintptr", 8u64, 8u64); + c.tyf32 = prim(a, TY_F32, "f32", 4u64, 4u64); + c.tyf64 = prim(a, TY_F64, "f64", 8u64, 8u64); + c.tystr = prim(a, TY_STR, "str", 16u64, 8u64); + c.tyerr = prim(a, TY_ERR, "", 0u64, 1u64); - c.ty_untyped_int = prim(a, TY_UNTYPED_INT, "untyped_int", 0u64, 1u64); - c.ty_untyped_float = prim(a, TY_UNTYPED_FLOAT, "untyped_float", 0u64, 1u64); - c.ty_untyped_str = prim(a, TY_UNTYPED_STR, "untyped_str", 0u64, 1u64); - c.ty_untyped_rune = prim(a, TY_UNTYPED_RUNE, "untyped_rune", 0u64, 1u64); - c.ty_untyped_bool = prim(a, TY_UNTYPED_BOOL, "untyped_bool", 0u64, 1u64); - c.ty_untyped_nil = prim(a, TY_UNTYPED_NIL, "untyped_nil", 0u64, 1u64); + c.tyuntypedint = prim(a, TY_UNTYPED_INT, "untyped_int", 0u64, 1u64); + c.tyuntypedfloat = prim(a, TY_UNTYPED_FLOAT, "untyped_float", 0u64, 1u64); + c.tyuntypedstr = prim(a, TY_UNTYPED_STR, "untyped_str", 0u64, 1u64); + c.tyuntypedrune = prim(a, TY_UNTYPED_RUNE, "untyped_rune", 0u64, 1u64); + c.tyuntypedbool = prim(a, TY_UNTYPED_BOOL, "untyped_bool", 0u64, 1u64); + c.tyuntypednil = prim(a, TY_UNTYPED_NIL, "untyped_nil", 0u64, 1u64); }; export fn typeptr(a: *arena, sub: *tinfo) *tinfo = { @@ -3379,23 +3379,23 @@ type checker = struct { // seedprimitives — install the built-in type names so `i32`, `str`, // etc. can be looked up like ordinary symbols. fn seedprimitives(c: *checker) void = { - scopedefine(c.top, "void", SK_TYPE, c.tc.ty_void, nil); - scopedefine(c.top, "bool", SK_TYPE, c.tc.ty_bool, nil); - scopedefine(c.top, "rune", SK_TYPE, c.tc.ty_rune, nil); - scopedefine(c.top, "i8", SK_TYPE, c.tc.ty_i8, nil); - scopedefine(c.top, "i16", SK_TYPE, c.tc.ty_i16, nil); - scopedefine(c.top, "i32", SK_TYPE, c.tc.ty_i32, nil); - scopedefine(c.top, "i64", SK_TYPE, c.tc.ty_i64, nil); - scopedefine(c.top, "u8", SK_TYPE, c.tc.ty_u8, nil); - scopedefine(c.top, "u16", SK_TYPE, c.tc.ty_u16, nil); - scopedefine(c.top, "u32", SK_TYPE, c.tc.ty_u32, nil); - scopedefine(c.top, "u64", SK_TYPE, c.tc.ty_u64, nil); - scopedefine(c.top, "int", SK_TYPE, c.tc.ty_int, nil); - scopedefine(c.top, "uint", SK_TYPE, c.tc.ty_uint, nil); - scopedefine(c.top, "uintptr", SK_TYPE, c.tc.ty_uintptr, nil); - scopedefine(c.top, "f32", SK_TYPE, c.tc.ty_f32, nil); - scopedefine(c.top, "f64", SK_TYPE, c.tc.ty_f64, nil); - scopedefine(c.top, "str", SK_TYPE, c.tc.ty_str, nil); + scopedefine(c.top, "void", SK_TYPE, c.tc.tyvoid, nil); + scopedefine(c.top, "bool", SK_TYPE, c.tc.tybool, nil); + scopedefine(c.top, "rune", SK_TYPE, c.tc.tyrune, nil); + scopedefine(c.top, "i8", SK_TYPE, c.tc.tyi8, nil); + scopedefine(c.top, "i16", SK_TYPE, c.tc.tyi16, nil); + scopedefine(c.top, "i32", SK_TYPE, c.tc.tyi32, nil); + scopedefine(c.top, "i64", SK_TYPE, c.tc.tyi64, nil); + scopedefine(c.top, "u8", SK_TYPE, c.tc.tyu8, nil); + scopedefine(c.top, "u16", SK_TYPE, c.tc.tyu16, nil); + scopedefine(c.top, "u32", SK_TYPE, c.tc.tyu32, nil); + scopedefine(c.top, "u64", SK_TYPE, c.tc.tyu64, nil); + scopedefine(c.top, "int", SK_TYPE, c.tc.tyint, nil); + scopedefine(c.top, "uint", SK_TYPE, c.tc.tyuint, nil); + scopedefine(c.top, "uintptr", SK_TYPE, c.tc.tyuintptr, nil); + scopedefine(c.top, "f32", SK_TYPE, c.tc.tyf32, nil); + scopedefine(c.top, "f64", SK_TYPE, c.tc.tyf64, nil); + scopedefine(c.top, "str", SK_TYPE, c.tc.tystr, nil); // `nil`, `true`, `false` are keywords — handled at the lex/parser // level, no symbol needed. // `len`, `alloc`, `free` are pseudo-builtins; scopedefine them so @@ -5199,7 +5199,7 @@ fn cgexpr(c: *cgen, n: *node) void = { // Module-qualified value reference: `mod.name` where `mod` // is N_IDENT bound as SK_USE and the leaf isn't a local. // Treat as a SB symbol — `MOVQ leaf(SB), AX`. Same fallback - // the C cgen takes when bt is NULL/ty_err. + // the C cgen takes when bt is NULL/tyerr. if (lhs != nil) { if (lhs.kind == N_IDENT) { emitline("\tMOVQ\t"); diff --git a/selfhost/cmd/wcc/cgen.ww b/selfhost/cmd/wcc/cgen.ww index cb79a866..cedf42b2 100644 --- a/selfhost/cmd/wcc/cgen.ww +++ b/selfhost/cmd/wcc/cgen.ww @@ -1607,7 +1607,7 @@ fn cgexpr(c: *cgen, n: *node) void = { // Module-qualified value reference: `mod.name` where `mod` // is N_IDENT bound as SK_USE and the leaf isn't a local. // Treat as a SB symbol — `MOVQ leaf(SB), AX`. Same fallback - // the C cgen takes when bt is NULL/ty_err. + // the C cgen takes when bt is NULL/tyerr. if (lhs != nil) { if (lhs.kind == N_IDENT) { emitline("\tMOVQ\t"); diff --git a/selfhost/cmd/wcc/check.ww b/selfhost/cmd/wcc/check.ww index 82353c68..4efb48a7 100644 --- a/selfhost/cmd/wcc/check.ww +++ b/selfhost/cmd/wcc/check.ww @@ -35,23 +35,23 @@ type checker = struct { // seedprimitives — install the built-in type names so `i32`, `str`, // etc. can be looked up like ordinary symbols. fn seedprimitives(c: *checker) void = { - scopedefine(c.top, "void", SK_TYPE, c.tc.ty_void, nil); - scopedefine(c.top, "bool", SK_TYPE, c.tc.ty_bool, nil); - scopedefine(c.top, "rune", SK_TYPE, c.tc.ty_rune, nil); - scopedefine(c.top, "i8", SK_TYPE, c.tc.ty_i8, nil); - scopedefine(c.top, "i16", SK_TYPE, c.tc.ty_i16, nil); - scopedefine(c.top, "i32", SK_TYPE, c.tc.ty_i32, nil); - scopedefine(c.top, "i64", SK_TYPE, c.tc.ty_i64, nil); - scopedefine(c.top, "u8", SK_TYPE, c.tc.ty_u8, nil); - scopedefine(c.top, "u16", SK_TYPE, c.tc.ty_u16, nil); - scopedefine(c.top, "u32", SK_TYPE, c.tc.ty_u32, nil); - scopedefine(c.top, "u64", SK_TYPE, c.tc.ty_u64, nil); - scopedefine(c.top, "int", SK_TYPE, c.tc.ty_int, nil); - scopedefine(c.top, "uint", SK_TYPE, c.tc.ty_uint, nil); - scopedefine(c.top, "uintptr", SK_TYPE, c.tc.ty_uintptr, nil); - scopedefine(c.top, "f32", SK_TYPE, c.tc.ty_f32, nil); - scopedefine(c.top, "f64", SK_TYPE, c.tc.ty_f64, nil); - scopedefine(c.top, "str", SK_TYPE, c.tc.ty_str, nil); + scopedefine(c.top, "void", SK_TYPE, c.tc.tyvoid, nil); + scopedefine(c.top, "bool", SK_TYPE, c.tc.tybool, nil); + scopedefine(c.top, "rune", SK_TYPE, c.tc.tyrune, nil); + scopedefine(c.top, "i8", SK_TYPE, c.tc.tyi8, nil); + scopedefine(c.top, "i16", SK_TYPE, c.tc.tyi16, nil); + scopedefine(c.top, "i32", SK_TYPE, c.tc.tyi32, nil); + scopedefine(c.top, "i64", SK_TYPE, c.tc.tyi64, nil); + scopedefine(c.top, "u8", SK_TYPE, c.tc.tyu8, nil); + scopedefine(c.top, "u16", SK_TYPE, c.tc.tyu16, nil); + scopedefine(c.top, "u32", SK_TYPE, c.tc.tyu32, nil); + scopedefine(c.top, "u64", SK_TYPE, c.tc.tyu64, nil); + scopedefine(c.top, "int", SK_TYPE, c.tc.tyint, nil); + scopedefine(c.top, "uint", SK_TYPE, c.tc.tyuint, nil); + scopedefine(c.top, "uintptr", SK_TYPE, c.tc.tyuintptr, nil); + scopedefine(c.top, "f32", SK_TYPE, c.tc.tyf32, nil); + scopedefine(c.top, "f64", SK_TYPE, c.tc.tyf64, nil); + scopedefine(c.top, "str", SK_TYPE, c.tc.tystr, nil); // `nil`, `true`, `false` are keywords — handled at the lex/parser // level, no symbol needed. // `len`, `alloc`, `free` are pseudo-builtins; scopedefine them so diff --git a/selfhost/cmd/wcc/typ.ww b/selfhost/cmd/wcc/typ.ww index 9edbeb0d..75ca603b 100644 --- a/selfhost/cmd/wcc/typ.ww +++ b/selfhost/cmd/wcc/typ.ww @@ -1,7 +1,7 @@ // selfhost/cmd/wcc/type.ww — port of cmd/wcc/type.c. // // Status: full structural port. The C version uses module-globals for -// the primitive types (ty_void, ty_i32, …); ww doesn't have writable +// the primitive types (tyvoid, tyi32, …); ww doesn't have writable // global storage yet, so we bundle the primitives into a `tctx` that // the checker passes around explicitly. typesinit fills the tctx // once per arena. @@ -82,30 +82,30 @@ type tinfo = struct { type tctx = struct { a: *arena, - ty_void: *tinfo, - ty_bool: *tinfo, - ty_rune: *tinfo, - ty_i8: *tinfo, - ty_i16: *tinfo, - ty_i32: *tinfo, - ty_i64: *tinfo, - ty_u8: *tinfo, - ty_u16: *tinfo, - ty_u32: *tinfo, - ty_u64: *tinfo, - ty_int: *tinfo, - ty_uint: *tinfo, - ty_uintptr: *tinfo, - ty_f32: *tinfo, - ty_f64: *tinfo, - ty_str: *tinfo, - ty_err: *tinfo, - ty_untyped_int: *tinfo, - ty_untyped_float: *tinfo, - ty_untyped_str: *tinfo, - ty_untyped_rune: *tinfo, - ty_untyped_bool: *tinfo, - ty_untyped_nil: *tinfo, + tyvoid: *tinfo, + tybool: *tinfo, + tyrune: *tinfo, + tyi8: *tinfo, + tyi16: *tinfo, + tyi32: *tinfo, + tyi64: *tinfo, + tyu8: *tinfo, + tyu16: *tinfo, + tyu32: *tinfo, + tyu64: *tinfo, + tyint: *tinfo, + tyuint: *tinfo, + tyuintptr: *tinfo, + tyf32: *tinfo, + tyf64: *tinfo, + tystr: *tinfo, + tyerr: *tinfo, + tyuntypedint: *tinfo, + tyuntypedfloat: *tinfo, + tyuntypedstr: *tinfo, + tyuntypedrune: *tinfo, + tyuntypedbool: *tinfo, + tyuntypednil: *tinfo, }; // ---- constructors ----------------------------------------------------- @@ -126,31 +126,31 @@ fn prim(a: *arena, k: i32, nm: str, sz: u64, al: u64) *tinfo = { export fn typesinit(c: *tctx, a: *arena) void = { c.a = a; - c.ty_void = prim(a, TY_VOID, "void", 0u64, 1u64); - c.ty_bool = prim(a, TY_BOOL, "bool", 1u64, 1u64); - c.ty_rune = prim(a, TY_RUNE, "rune", 4u64, 4u64); - c.ty_i8 = prim(a, TY_I8, "i8", 1u64, 1u64); - c.ty_i16 = prim(a, TY_I16, "i16", 2u64, 2u64); - c.ty_i32 = prim(a, TY_I32, "i32", 4u64, 4u64); - c.ty_i64 = prim(a, TY_I64, "i64", 8u64, 8u64); - c.ty_u8 = prim(a, TY_U8, "u8", 1u64, 1u64); - c.ty_u16 = prim(a, TY_U16, "u16", 2u64, 2u64); - c.ty_u32 = prim(a, TY_U32, "u32", 4u64, 4u64); - c.ty_u64 = prim(a, TY_U64, "u64", 8u64, 8u64); - c.ty_int = prim(a, TY_INT, "int", 8u64, 8u64); - c.ty_uint = prim(a, TY_UINT, "uint", 8u64, 8u64); - c.ty_uintptr= prim(a, TY_UINTPTR, "uintptr", 8u64, 8u64); - c.ty_f32 = prim(a, TY_F32, "f32", 4u64, 4u64); - c.ty_f64 = prim(a, TY_F64, "f64", 8u64, 8u64); - c.ty_str = prim(a, TY_STR, "str", 16u64, 8u64); - c.ty_err = prim(a, TY_ERR, "", 0u64, 1u64); + c.tyvoid = prim(a, TY_VOID, "void", 0u64, 1u64); + c.tybool = prim(a, TY_BOOL, "bool", 1u64, 1u64); + c.tyrune = prim(a, TY_RUNE, "rune", 4u64, 4u64); + c.tyi8 = prim(a, TY_I8, "i8", 1u64, 1u64); + c.tyi16 = prim(a, TY_I16, "i16", 2u64, 2u64); + c.tyi32 = prim(a, TY_I32, "i32", 4u64, 4u64); + c.tyi64 = prim(a, TY_I64, "i64", 8u64, 8u64); + c.tyu8 = prim(a, TY_U8, "u8", 1u64, 1u64); + c.tyu16 = prim(a, TY_U16, "u16", 2u64, 2u64); + c.tyu32 = prim(a, TY_U32, "u32", 4u64, 4u64); + c.tyu64 = prim(a, TY_U64, "u64", 8u64, 8u64); + c.tyint = prim(a, TY_INT, "int", 8u64, 8u64); + c.tyuint = prim(a, TY_UINT, "uint", 8u64, 8u64); + c.tyuintptr= prim(a, TY_UINTPTR, "uintptr", 8u64, 8u64); + c.tyf32 = prim(a, TY_F32, "f32", 4u64, 4u64); + c.tyf64 = prim(a, TY_F64, "f64", 8u64, 8u64); + c.tystr = prim(a, TY_STR, "str", 16u64, 8u64); + c.tyerr = prim(a, TY_ERR, "", 0u64, 1u64); - c.ty_untyped_int = prim(a, TY_UNTYPED_INT, "untyped_int", 0u64, 1u64); - c.ty_untyped_float = prim(a, TY_UNTYPED_FLOAT, "untyped_float", 0u64, 1u64); - c.ty_untyped_str = prim(a, TY_UNTYPED_STR, "untyped_str", 0u64, 1u64); - c.ty_untyped_rune = prim(a, TY_UNTYPED_RUNE, "untyped_rune", 0u64, 1u64); - c.ty_untyped_bool = prim(a, TY_UNTYPED_BOOL, "untyped_bool", 0u64, 1u64); - c.ty_untyped_nil = prim(a, TY_UNTYPED_NIL, "untyped_nil", 0u64, 1u64); + c.tyuntypedint = prim(a, TY_UNTYPED_INT, "untyped_int", 0u64, 1u64); + c.tyuntypedfloat = prim(a, TY_UNTYPED_FLOAT, "untyped_float", 0u64, 1u64); + c.tyuntypedstr = prim(a, TY_UNTYPED_STR, "untyped_str", 0u64, 1u64); + c.tyuntypedrune = prim(a, TY_UNTYPED_RUNE, "untyped_rune", 0u64, 1u64); + c.tyuntypedbool = prim(a, TY_UNTYPED_BOOL, "untyped_bool", 0u64, 1u64); + c.tyuntypednil = prim(a, TY_UNTYPED_NIL, "untyped_nil", 0u64, 1u64); }; export fn typeptr(a: *arena, sub: *tinfo) *tinfo = { diff --git a/selfhost/cmd/wwdump/main.combined.ww b/selfhost/cmd/wwdump/main.combined.ww index 5c613a16..22429e78 100644 --- a/selfhost/cmd/wwdump/main.combined.ww +++ b/selfhost/cmd/wwdump/main.combined.ww @@ -2901,7 +2901,7 @@ export fn parsefile(p: *parser) *node = { // selfhost/cmd/wcc/type.ww — port of cmd/wcc/type.c. // // Status: full structural port. The C version uses module-globals for -// the primitive types (ty_void, ty_i32, …); ww doesn't have writable +// the primitive types (tyvoid, tyi32, …); ww doesn't have writable // global storage yet, so we bundle the primitives into a `tctx` that // the checker passes around explicitly. typesinit fills the tctx // once per arena. @@ -2982,30 +2982,30 @@ type tinfo = struct { type tctx = struct { a: *arena, - ty_void: *tinfo, - ty_bool: *tinfo, - ty_rune: *tinfo, - ty_i8: *tinfo, - ty_i16: *tinfo, - ty_i32: *tinfo, - ty_i64: *tinfo, - ty_u8: *tinfo, - ty_u16: *tinfo, - ty_u32: *tinfo, - ty_u64: *tinfo, - ty_int: *tinfo, - ty_uint: *tinfo, - ty_uintptr: *tinfo, - ty_f32: *tinfo, - ty_f64: *tinfo, - ty_str: *tinfo, - ty_err: *tinfo, - ty_untyped_int: *tinfo, - ty_untyped_float: *tinfo, - ty_untyped_str: *tinfo, - ty_untyped_rune: *tinfo, - ty_untyped_bool: *tinfo, - ty_untyped_nil: *tinfo, + tyvoid: *tinfo, + tybool: *tinfo, + tyrune: *tinfo, + tyi8: *tinfo, + tyi16: *tinfo, + tyi32: *tinfo, + tyi64: *tinfo, + tyu8: *tinfo, + tyu16: *tinfo, + tyu32: *tinfo, + tyu64: *tinfo, + tyint: *tinfo, + tyuint: *tinfo, + tyuintptr: *tinfo, + tyf32: *tinfo, + tyf64: *tinfo, + tystr: *tinfo, + tyerr: *tinfo, + tyuntypedint: *tinfo, + tyuntypedfloat: *tinfo, + tyuntypedstr: *tinfo, + tyuntypedrune: *tinfo, + tyuntypedbool: *tinfo, + tyuntypednil: *tinfo, }; // ---- constructors ----------------------------------------------------- @@ -3026,31 +3026,31 @@ fn prim(a: *arena, k: i32, nm: str, sz: u64, al: u64) *tinfo = { export fn typesinit(c: *tctx, a: *arena) void = { c.a = a; - c.ty_void = prim(a, TY_VOID, "void", 0u64, 1u64); - c.ty_bool = prim(a, TY_BOOL, "bool", 1u64, 1u64); - c.ty_rune = prim(a, TY_RUNE, "rune", 4u64, 4u64); - c.ty_i8 = prim(a, TY_I8, "i8", 1u64, 1u64); - c.ty_i16 = prim(a, TY_I16, "i16", 2u64, 2u64); - c.ty_i32 = prim(a, TY_I32, "i32", 4u64, 4u64); - c.ty_i64 = prim(a, TY_I64, "i64", 8u64, 8u64); - c.ty_u8 = prim(a, TY_U8, "u8", 1u64, 1u64); - c.ty_u16 = prim(a, TY_U16, "u16", 2u64, 2u64); - c.ty_u32 = prim(a, TY_U32, "u32", 4u64, 4u64); - c.ty_u64 = prim(a, TY_U64, "u64", 8u64, 8u64); - c.ty_int = prim(a, TY_INT, "int", 8u64, 8u64); - c.ty_uint = prim(a, TY_UINT, "uint", 8u64, 8u64); - c.ty_uintptr= prim(a, TY_UINTPTR, "uintptr", 8u64, 8u64); - c.ty_f32 = prim(a, TY_F32, "f32", 4u64, 4u64); - c.ty_f64 = prim(a, TY_F64, "f64", 8u64, 8u64); - c.ty_str = prim(a, TY_STR, "str", 16u64, 8u64); - c.ty_err = prim(a, TY_ERR, "", 0u64, 1u64); + c.tyvoid = prim(a, TY_VOID, "void", 0u64, 1u64); + c.tybool = prim(a, TY_BOOL, "bool", 1u64, 1u64); + c.tyrune = prim(a, TY_RUNE, "rune", 4u64, 4u64); + c.tyi8 = prim(a, TY_I8, "i8", 1u64, 1u64); + c.tyi16 = prim(a, TY_I16, "i16", 2u64, 2u64); + c.tyi32 = prim(a, TY_I32, "i32", 4u64, 4u64); + c.tyi64 = prim(a, TY_I64, "i64", 8u64, 8u64); + c.tyu8 = prim(a, TY_U8, "u8", 1u64, 1u64); + c.tyu16 = prim(a, TY_U16, "u16", 2u64, 2u64); + c.tyu32 = prim(a, TY_U32, "u32", 4u64, 4u64); + c.tyu64 = prim(a, TY_U64, "u64", 8u64, 8u64); + c.tyint = prim(a, TY_INT, "int", 8u64, 8u64); + c.tyuint = prim(a, TY_UINT, "uint", 8u64, 8u64); + c.tyuintptr= prim(a, TY_UINTPTR, "uintptr", 8u64, 8u64); + c.tyf32 = prim(a, TY_F32, "f32", 4u64, 4u64); + c.tyf64 = prim(a, TY_F64, "f64", 8u64, 8u64); + c.tystr = prim(a, TY_STR, "str", 16u64, 8u64); + c.tyerr = prim(a, TY_ERR, "", 0u64, 1u64); - c.ty_untyped_int = prim(a, TY_UNTYPED_INT, "untyped_int", 0u64, 1u64); - c.ty_untyped_float = prim(a, TY_UNTYPED_FLOAT, "untyped_float", 0u64, 1u64); - c.ty_untyped_str = prim(a, TY_UNTYPED_STR, "untyped_str", 0u64, 1u64); - c.ty_untyped_rune = prim(a, TY_UNTYPED_RUNE, "untyped_rune", 0u64, 1u64); - c.ty_untyped_bool = prim(a, TY_UNTYPED_BOOL, "untyped_bool", 0u64, 1u64); - c.ty_untyped_nil = prim(a, TY_UNTYPED_NIL, "untyped_nil", 0u64, 1u64); + c.tyuntypedint = prim(a, TY_UNTYPED_INT, "untyped_int", 0u64, 1u64); + c.tyuntypedfloat = prim(a, TY_UNTYPED_FLOAT, "untyped_float", 0u64, 1u64); + c.tyuntypedstr = prim(a, TY_UNTYPED_STR, "untyped_str", 0u64, 1u64); + c.tyuntypedrune = prim(a, TY_UNTYPED_RUNE, "untyped_rune", 0u64, 1u64); + c.tyuntypedbool = prim(a, TY_UNTYPED_BOOL, "untyped_bool", 0u64, 1u64); + c.tyuntypednil = prim(a, TY_UNTYPED_NIL, "untyped_nil", 0u64, 1u64); }; export fn typeptr(a: *arena, sub: *tinfo) *tinfo = { @@ -3379,23 +3379,23 @@ type checker = struct { // seedprimitives — install the built-in type names so `i32`, `str`, // etc. can be looked up like ordinary symbols. fn seedprimitives(c: *checker) void = { - scopedefine(c.top, "void", SK_TYPE, c.tc.ty_void, nil); - scopedefine(c.top, "bool", SK_TYPE, c.tc.ty_bool, nil); - scopedefine(c.top, "rune", SK_TYPE, c.tc.ty_rune, nil); - scopedefine(c.top, "i8", SK_TYPE, c.tc.ty_i8, nil); - scopedefine(c.top, "i16", SK_TYPE, c.tc.ty_i16, nil); - scopedefine(c.top, "i32", SK_TYPE, c.tc.ty_i32, nil); - scopedefine(c.top, "i64", SK_TYPE, c.tc.ty_i64, nil); - scopedefine(c.top, "u8", SK_TYPE, c.tc.ty_u8, nil); - scopedefine(c.top, "u16", SK_TYPE, c.tc.ty_u16, nil); - scopedefine(c.top, "u32", SK_TYPE, c.tc.ty_u32, nil); - scopedefine(c.top, "u64", SK_TYPE, c.tc.ty_u64, nil); - scopedefine(c.top, "int", SK_TYPE, c.tc.ty_int, nil); - scopedefine(c.top, "uint", SK_TYPE, c.tc.ty_uint, nil); - scopedefine(c.top, "uintptr", SK_TYPE, c.tc.ty_uintptr, nil); - scopedefine(c.top, "f32", SK_TYPE, c.tc.ty_f32, nil); - scopedefine(c.top, "f64", SK_TYPE, c.tc.ty_f64, nil); - scopedefine(c.top, "str", SK_TYPE, c.tc.ty_str, nil); + scopedefine(c.top, "void", SK_TYPE, c.tc.tyvoid, nil); + scopedefine(c.top, "bool", SK_TYPE, c.tc.tybool, nil); + scopedefine(c.top, "rune", SK_TYPE, c.tc.tyrune, nil); + scopedefine(c.top, "i8", SK_TYPE, c.tc.tyi8, nil); + scopedefine(c.top, "i16", SK_TYPE, c.tc.tyi16, nil); + scopedefine(c.top, "i32", SK_TYPE, c.tc.tyi32, nil); + scopedefine(c.top, "i64", SK_TYPE, c.tc.tyi64, nil); + scopedefine(c.top, "u8", SK_TYPE, c.tc.tyu8, nil); + scopedefine(c.top, "u16", SK_TYPE, c.tc.tyu16, nil); + scopedefine(c.top, "u32", SK_TYPE, c.tc.tyu32, nil); + scopedefine(c.top, "u64", SK_TYPE, c.tc.tyu64, nil); + scopedefine(c.top, "int", SK_TYPE, c.tc.tyint, nil); + scopedefine(c.top, "uint", SK_TYPE, c.tc.tyuint, nil); + scopedefine(c.top, "uintptr", SK_TYPE, c.tc.tyuintptr, nil); + scopedefine(c.top, "f32", SK_TYPE, c.tc.tyf32, nil); + scopedefine(c.top, "f64", SK_TYPE, c.tc.tyf64, nil); + scopedefine(c.top, "str", SK_TYPE, c.tc.tystr, nil); // `nil`, `true`, `false` are keywords — handled at the lex/parser // level, no symbol needed. // `len`, `alloc`, `free` are pseudo-builtins; scopedefine them so @@ -5199,7 +5199,7 @@ fn cgexpr(c: *cgen, n: *node) void = { // Module-qualified value reference: `mod.name` where `mod` // is N_IDENT bound as SK_USE and the leaf isn't a local. // Treat as a SB symbol — `MOVQ leaf(SB), AX`. Same fallback - // the C cgen takes when bt is NULL/ty_err. + // the C cgen takes when bt is NULL/tyerr. if (lhs != nil) { if (lhs.kind == N_IDENT) { emitline("\tMOVQ\t");