Hojun-Cho/ww
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

w6c+wcc+selfhost+lib: int-cast truncate + use_alias, 5 new modules

Browse Source 
Two cgen/check bugs surfaced by new lib modules, plus the modules
themselves (crc64, siphash, random, base64, base32).

  1. `(big_u64): u32` (and `: u16`, `: u8`, `: bool`) didn't truncate.
     N_CAST emitted nothing for int↔int; the value stayed in AX with
     its upper bits intact and downstream CMPQ/DIVQ misread the slot.
     The TK_TILDE path already had clamp logic for the same reason —
     N_CAST was the missing case. Both stages now MOVL r,r for u32 and
     ANDQ $mask for u8/u16/bool. Signed-narrow (i8/i16/i32) stays
     no-op until w6a grows reg-reg MOVSBQ/MOVSWQ/MOVSXD. selfhost
     cgcast walks alias chains via aliaslookup before checking
     primsize/typenameisunsigned so `(u: random)` where
     `type random = u64` still bypasses the clamp.
     See cmd/w6c/cgen.c N_CAST and selfhost/cmd/wcc/cgenexpr.ww cgcast.

  2. `mod.mod` type refs (`random.random` when the imported module
     declares `export type random = u64;`) failed with "unknown type".
     The driver concatenates imports into one flat scope, so SK_USE
     `random` collided with SK_TYPE `random` and scope_define silently
     dropped the use. resolve_typename's leaf lookup required
     `kind == SK_USE` and gave up. Adds a `use_alias` flag to Sym; the
     pass-1 decl scan now marks colliding syms in both directions
     (use-after-type and type-after-use). resolve_typename and the
     N_DOT cexpr branch treat `use_alias` like SK_USE for qualified
     lookup. selfhost check.ww was already lenient on this path so no
     ww-side change was needed; bootstrap fixed point (990-995) holds.
     See cmd/wcc/check.c installdecl pass + N_DOT/resolve_typename and
     cmd/wcc/ww.h Sym.use_alias.

New modules under lib/, each with @test vectors in *_test.ww and wired
into test/wcc/900_stdlib.c (26 modules → all compile):

  - lib/hash/crc64       ECMA, ISO  (mirror of crc32 shape)
  - lib/hash/siphash     SipHash-2-4, buffer-based sum/sum24
  - lib/math/random      SplitMix64 (init, next, u32n, u64n)
  - lib/encoding/base64  RFC 4648 std + url-safe encode/decode + sizes
  - lib/encoding/base32  RFC 4648 std + base32hex encode/decode + sizes
This commit is contained in:
Hojun-Cho
2026-05-13 14:58:36 +09:00
parent cbcc0167ae
commit 7a4f60b041
17 changed files with 1302 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files

58
cmd/wcc/check.c
View File

@@ -63,14 +63,17 @@ resolve_typename(Checker *c, Node *n)
Sym *s = scope_lookup(c->cur, nm);
if (s == NULL && nm) {
/* module-qualified: io.stream → strip the last dot prefix
* and look up the leaf if `io` is a `use`-imported name. */
* and look up the leaf if `io` is a `use`-imported name.
* `m->use_alias` covers the self-import case where the
* imported module declares a type with the same name as
* the module itself (e.g. `random.random`). */
const char *dot = strrchr(nm, '.');
if (dot) {
char head[128] = {0};
size_t hl = (size_t)(dot - nm);
if (hl < sizeof head) memcpy(head, nm, hl);
Sym *m = scope_lookup(c->cur, head);
if (m && m->kind == SK_USE)
if (m && (m->kind == SK_USE || m->use_alias))
s = scope_lookup(c->cur, dot + 1);
}
}
@@ -684,16 +687,28 @@ cexpr(Checker *c, Node *n)
* scope, so we lookup `n->str` directly. */
if (n->lhs && n->lhs->kind == N_IDENT) {
Sym *ms = scope_lookup(c->cur, n->lhs->str);
if (ms && ms->kind == SK_USE) {
if (ms && (ms->kind == SK_USE || ms->use_alias)) {
/* Module-qualified ref. `use_alias` covers
* the self-import case where the module's
* type name shadowed the SK_USE; the leaf
* still resolves through the flat scope.
* fs == ms is the `mod.mod` case (the
* imported module's leaf type is named after
* the module itself — both names point at
* the same SK_TYPE sym in the flat scope). */
Sym *fs = scope_lookup(c->cur, n->str);
if (fs)
return n->type = fs->type;
/* Leaf isn't in scope here — treat as an
* external declaration. The codegen will
* still emit CALL/MOVQ by the leaf name; the
* linker fails if the symbol is truly
* missing. */
return n->type = ty_err;
if (ms->kind == SK_USE) {
/* Pure SK_USE with missing leaf:
* external declaration. Codegen
* emits CALL/MOVQ by the leaf name
* and the linker resolves it. */
return n->type = ty_err;
}
/* SK_TYPE with use_alias=1 and no leaf
* found: fall through so the enum / type-
* member paths below get a shot. */
}
/* enum member access: TypeName.MEMBER → fold to
* the member's integer literal value. Type is the
@@ -1590,13 +1605,34 @@ check_file(Checker *c, Node *file)
* walked in the next pass. */
for (Node *d = file->list; d; d = d->next) {
if (d->kind == N_USE) {
scope_define(c->cur, d->str, SK_USE, NULL, d);
Sym *prev = scope_lookup_local(c->cur, d->str);
if (prev != NULL) {
/* Self-import: the driver concatenates the
* imported module's source into the flat
* scope, so its top-level decls (types, fns,
* defs) shadow a same-named SK_USE. Mark
* the colliding sym as also-a-use so dotted
* qualifiers (`mod.x`) still resolve. */
prev->use_alias = 1;
} else {
scope_define(c->cur, d->str, SK_USE, NULL, d);
}
continue;
}
if (d->kind != N_TYPEDECL) continue;
Type *named = type_named(c->a, d->str, NULL);
if (!scope_define(c->cur, d->str, SK_TYPE, named, d))
Sym *prev = scope_lookup_local(c->cur, d->str);
if (prev && prev->kind == SK_USE) {
/* `use mod; ... type mod = ...;` — promote the
* SK_USE to the type symbol but remember it was
* also a module name. */
prev->kind = SK_TYPE;
prev->type = named;
prev->decl = d;
prev->use_alias = 1;
} else if (!scope_define(c->cur, d->str, SK_TYPE, named, d)) {
err(c, d->pos, "duplicate type %s", d->str);
}
d->type = named;
}
for (Node *d = file->list; d; d = d->next) {

6
cmd/wcc/ww.h
View File

@@ -476,6 +476,12 @@ struct Sym {
Node *decl;
int exported;
int is_const; /* const-bound (assignment rejected) */
int use_alias; /* also bound as a `use` module name. Set
* when a `use foo;` directive collides
* with a same-named SK_TYPE/SK_FN/etc.
* Lets resolve_typename treat `foo.x`
* as module-qualified even though the
* primary kind isn't SK_USE. */
Sym *next; /* iteration */
Sym *hashnext; /* bucket chain */
Scope *scope;