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

compiler: make package exports self-contained

Browse Source
This commit is contained in:
Hojun-Cho
2026-08-12 01:12:42 +09:00
parent 52f6d6f0d4
commit 9b970eb16a
10 changed files with 965 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
cmd/w6c/cgen.c
View File

@@ -1172,6 +1172,16 @@ ffi_resolve(const char *ident)
return ident;
}
/* Package compilation must not acquire a hidden source dependency on a
* transitive `rt` interface merely so the compiler intrinsic `alloc` learns
* its linker spelling. The WW runtime ABI owns this name in -c mode. Keep
* raw w6c's declaration-driven behavior for compatibility and FFI tests. */
static const char *
alloc_resolve(Cg *c)
{
return c->sep_mode ? "rt_malloc" : ffi_resolve("malloc");
}
static void
ffi_collect(Cg *c, Node *file)
{
@@ -9199,7 +9209,7 @@ cgexpr(Cg *c, Node *n, Local *locals)
char *alloc_ok = mklabel(c, "alloc_ok");
char *alloc_done = mklabel(c, "alloc_done");
ins2(c, A_MOVQ, aimm(sz), areg(D_DI));
ins1(c, A_CALL, asym(ffi_resolve("malloc")));
ins1(c, A_CALL, asym(alloc_resolve(c)));
ins2(c, A_CMPQ, aimm(0), areg(D_AX));
ins1(c, A_JNE, abranch(alloc_ok));
ins2(c, A_MOVQ, aimm(1), areg(D_AX));
@@ -13536,7 +13546,7 @@ cgstmt(Cg *c, Node *n, Local **locals, int *frame)
ins2(c, A_IMULQ, areg(D_BX), areg(D_AX));
}
ins2(c, A_MOVQ, areg(D_AX), areg(D_DI));
ins1(c, A_CALL, asym(ffi_resolve("malloc")));
ins1(c, A_CALL, asym(alloc_resolve(c)));
if (via_tryunw) {
char *ok = mklabel(c, "tryunw_ok");
ins2(c, A_CMPQ, aimm(0), areg(D_AX));

389
cmd/w6c/wwi.c
View File

@@ -15,12 +15,13 @@
* stays dead on the normal `.s` path. It rejects exactly one thing:
* an exported signature naming a non-exported nominal type.
*
* A `.wwi` is ONE package's interface. The M2 gate feeds w6c a driver-
* combined unit (imports concatenated ahead of the target), so the emit
* filters to PRIMARY decls (imported == 0) — in the real per-package
* compile every decl is primary, so the filter is a no-op there. Output
* is a pure function of the exported API: package line, byte-sorted
* imports, byte-sorted decls (no map/hash iteration order).
* A `.wwi` is ONE package's self-contained interface. The primary section
* is followed by compiler-owned `//ww:module <path>` sections for exported
* foreign type/const facts recursively needed by the public surface. The
* package driver therefore only needs to pass a package's DIRECT imports;
* the interface itself carries the selected public type closure. Output is
* a pure function of the exported API: byte-sorted imports, declarations,
* fact owners and fact names (no map/hash iteration order).
*/
#include "gc.h"
#include <stdio.h>
@@ -41,24 +42,78 @@ wwi_primary(Node *n)
* leaf. By the time the producer runs, check_file has finished and
* c->cur == c->top.
*/
static int
wwi_mod_eq(const char *a, const char *b)
{
if (a == NULL || b == NULL) return a == b;
return strcmp(a, b) == 0;
}
/* The import alias map is source-owner-local. Imported `.wwi` sections are
* flat in the parser, so consulting every N_USE without this owner filter
* would let one dependency accidentally resolve another dependency's alias. */
static const char *
wwi_use_path(Checker *c, const char *owner, const char *alias)
{
if (owner && alias) {
const char *dot = strrchr(owner, '.');
const char *leaf = dot ? dot + 1 : owner;
if (strcmp(alias, leaf) == 0)
return owner;
}
for (Node *u = c->file->list; u; u = u->next) {
if (u->kind != N_USE || u->str == NULL
|| strcmp(u->str, alias) != 0)
continue;
int same = owner == NULL ? u->imported == 0
: u->imported != 0 && wwi_mod_eq(u->module, owner);
if (same)
return u->usepath ? u->usepath : u->str;
}
return NULL;
}
static int
wwi_direct_mod_visible(Checker *c, const char *owner, const char *mod)
{
if (mod == NULL || mod[0] == '\0') return 0;
const char *dot = strrchr(mod, '.');
const char *alias = dot ? dot + 1 : mod;
const char *path = wwi_use_path(c, owner, alias);
return path != NULL && strcmp(path, mod) == 0;
}
static Sym *
wwi_typesym(Checker *c, const char *nm)
wwi_typesym(Checker *c, const char *owner, const char *nm)
{
if (nm == NULL) return NULL;
const char *dot = strrchr(nm, '.');
Sym *s = NULL;
if (dot) {
size_t n = (size_t)(dot - nm);
for (Node *u = c->file->list; u; u = u->next) {
if (u->kind != N_USE || !wwi_primary(u) || u->str == NULL
|| strlen(u->str) != n || strncmp(u->str, nm, n) != 0)
continue;
const char *mod = u->usepath ? u->usepath : u->str;
char *alias = malloc(n + 1);
if (alias == NULL) fatal("wwi: out of memory");
memcpy(alias, nm, n);
alias[n] = '\0';
const char *mod = wwi_use_path(c, owner, alias);
if (mod)
s = scope_lookup_in_module(c->cur, mod, dot + 1);
break;
}
free(alias);
} else {
s = scope_lookup_type(c->cur, NULL, nm);
s = scope_lookup_type(c->cur, owner, nm);
if (s == NULL) {
for (Scope *p = c->cur; p; p = p->parent) {
for (Sym *b = p->first; b; b = b->next) {
if (b->kind == SK_TYPE
&& strcmp(b->name, nm) == 0
&& wwi_direct_mod_visible(c, owner, b->mod)) {
s = b;
break;
}
}
if (s != NULL) break;
}
}
}
if (s && s->kind == SK_TYPE)
return s;
@@ -66,14 +121,14 @@ wwi_typesym(Checker *c, const char *nm)
}
static int
wwi_check_type(Checker *c, Pos loc, Node *t)
wwi_check_type(Checker *c, const char *owner, Pos loc, Node *t)
{
int bad = 0;
if (t == NULL)
return 0;
switch (t->kind) {
case N_TNAME: {
Sym *s = wwi_typesym(c, t->str);
Sym *s = wwi_typesym(c, owner, t->str);
/* Sym.exported is vestigial (the checker never sets it); the
* nominal's export status lives on its decl node, parser-set.
* No file-guard twin to wwstage's: cstage resolves `nomem` and
@@ -92,30 +147,30 @@ wwi_check_type(Checker *c, Pos loc, Node *t)
case N_TSLICE:
case N_TBANG:
case N_TCHAN:
bad |= wwi_check_type(c, loc, t->lhs);
bad |= wwi_check_type(c, owner, loc, t->lhs);
break;
case N_TARRAY:
/* element only; the length is a const-expr, not a type. */
bad |= wwi_check_type(c, loc, t->lhs);
bad |= wwi_check_type(c, owner, loc, t->lhs);
break;
case N_TFN:
for (Node *p = t->list; p; p = p->next)
bad |= wwi_check_type(c, loc, p->lhs);
bad |= wwi_check_type(c, loc, t->lhs);
bad |= wwi_check_type(c, owner, loc, p->lhs);
bad |= wwi_check_type(c, owner, loc, t->lhs);
break;
case N_TSTRUCT:
for (Node *f = t->list; f; f = f->next)
bad |= wwi_check_type(c, loc, f->lhs);
bad |= wwi_check_type(c, owner, loc, f->lhs);
break;
case N_TTAGGED:
case N_TTUPLE:
for (Node *e = t->list; e; e = e->next)
bad |= wwi_check_type(c, loc, e);
bad |= wwi_check_type(c, owner, loc, e);
break;
case N_TENUM:
/* the inline enum body is the definition, not a reference;
* recurse only its storage type (members are values). */
bad |= wwi_check_type(c, loc, t->lhs);
bad |= wwi_check_type(c, owner, loc, t->lhs);
break;
default:
/* a non-type node in type position should not occur — leaf. */
@@ -131,18 +186,18 @@ wwi_check_decl(Checker *c, Node *d)
switch (d->kind) {
case N_FNDECL:
for (Node *p = d->list; p; p = p->next)
bad |= wwi_check_type(c, d->pos, p->lhs);
bad |= wwi_check_type(c, d->pos, d->lhs); /* ret */
bad |= wwi_check_type(c, NULL, d->pos, p->lhs);
bad |= wwi_check_type(c, NULL, d->pos, d->lhs); /* ret */
break;
case N_TYPEDECL:
bad |= wwi_check_type(c, d->pos, d->lhs);
bad |= wwi_check_type(c, NULL, d->pos, d->lhs);
break;
case N_DEF:
/* the declared type; the rhs const value is not a type. */
bad |= wwi_check_type(c, d->pos, d->lhs);
bad |= wwi_check_type(c, NULL, d->pos, d->lhs);
break;
case N_LET:
bad |= wwi_check_type(c, d->pos, d->lhs);
bad |= wwi_check_type(c, NULL, d->pos, d->lhs);
break;
default:
break;
@@ -357,6 +412,13 @@ wwi_expr(FILE *of, Node *e)
fputs(tokname(e->op), of);
wwi_expr(of, e->lhs);
break;
case N_CAST:
fputc('(', of);
wwi_expr(of, e->lhs);
fputs(": ", of);
wwi_type(of, e->rhs);
fputc(')', of);
break;
default:
fatal("wwi: unhandled const-expr node kind %d", e->kind);
}
@@ -434,7 +496,7 @@ wwi_decl(FILE *of, Node *d)
* fold of an aggregate def's FIELDS — a no-op, ww never folds
* struct-literal field access, and an aggregate-def field
* demanded in a const-fold context stays a LOUD error (task #71). */
if (d->rhs && (d->rhs->kind == N_STRUCTLIT
if (d->rhs == NULL || (d->rhs->kind == N_STRUCTLIT
|| d->rhs->kind == N_ARRLIT)) {
fputs(";\n", of);
} else {
@@ -462,6 +524,16 @@ wwi_decl(FILE *of, Node *d)
struct declent { Node *d; int idx; };
struct useent { const char *path; int idx; };
struct factent { Node *d; const char *mod; int idx; };
struct factset {
Checker *c;
struct factent *facts;
int nfacts, capfacts;
struct factent *seen;
int nseen, capseen;
int bad;
};
static int
declcmp(const void *a, const void *b)
@@ -481,6 +553,20 @@ usecmp(const void *a, const void *b)
return x->idx - y->idx;
}
static int
factcmp(const void *a, const void *b)
{
const struct factent *x = a, *y = b;
int r = strcmp(x->mod, y->mod);
if (r != 0) return r;
int xr = x->d->kind == N_TYPEDECL ? 0 : 1;
int yr = y->d->kind == N_TYPEDECL ? 0 : 1;
if (xr != yr) return xr - yr;
r = strcmp(x->d->str, y->d->str);
if (r != 0) return r;
return x->idx - y->idx;
}
static int
wwi_is_decl(Node *d)
{
@@ -488,6 +574,214 @@ wwi_is_decl(Node *d)
|| d->kind == N_DEF || d->kind == N_LET;
}
static int
wwi_fact_same(struct factent *f, const char *mod, Node *d)
{
return wwi_mod_eq(f->mod, mod) && f->d->kind == d->kind
&& strcmp(f->d->str, d->str) == 0;
}
static void
wwi_fact_grow(struct factent **v, int *cap, int need)
{
if (*cap >= need) return;
int ncap = *cap ? *cap * 2 : 16;
while (ncap < need) ncap *= 2;
struct factent *nv = realloc(*v, (size_t)ncap * sizeof *nv);
if (nv == NULL) fatal("wwi: out of memory");
*v = nv;
*cap = ncap;
}
static Sym *
wwi_valuesym(Checker *c, const char *owner, const char *name)
{
for (Scope *p = c->top; p; p = p->parent)
for (Sym *s = p->first; s; s = s->next)
if (s->kind == SK_DEF && strcmp(s->name, name) == 0
&& wwi_mod_eq(s->mod, owner))
return s;
for (Scope *p = c->top; p; p = p->parent)
for (Sym *s = p->first; s; s = s->next)
if (s->kind == SK_DEF && strcmp(s->name, name) == 0
&& wwi_direct_mod_visible(c, owner, s->mod))
return s;
return NULL;
}
static void wwi_collect_decl(struct factset*, const char*, Node*);
static void wwi_collect_type(struct factset*, const char*, Node*);
static void
wwi_collect_expr(struct factset *fs, const char *owner, Node *e)
{
if (e == NULL) return;
Sym *s = NULL;
if (e->kind == N_IDENT) {
s = wwi_valuesym(fs->c, owner, e->str);
} else if (e->kind == N_DOT && e->lhs
&& e->lhs->kind == N_IDENT) {
const char *mod = wwi_use_path(fs->c, owner, e->lhs->str);
if (mod) s = wwi_valuesym(fs->c, mod, e->str);
}
if (s && s->decl && s->decl->kind == N_DEF) {
if (!s->decl->export) {
errorf(e->pos, "exported declaration references "
"unexported def '%s'", e->str);
fs->bad = 1;
return;
}
wwi_collect_decl(fs, s->mod, s->decl);
return;
}
if (e->kind == N_BIN) {
wwi_collect_expr(fs, owner, e->lhs);
wwi_collect_expr(fs, owner, e->rhs);
} else if (e->kind == N_UN) {
wwi_collect_expr(fs, owner, e->lhs);
} else if (e->kind == N_CAST) {
wwi_collect_expr(fs, owner, e->lhs);
wwi_collect_type(fs, owner, e->rhs);
}
}
static void
wwi_collect_type(struct factset *fs, const char *owner, Node *t)
{
if (t == NULL) return;
switch (t->kind) {
case N_TNAME: {
Sym *s = wwi_typesym(fs->c, owner, t->str);
if (s && s->decl && s->decl->kind == N_TYPEDECL)
wwi_collect_decl(fs, s->mod, s->decl);
break;
}
case N_TPTR:
case N_TSLICE:
case N_TBANG:
case N_TCHAN:
wwi_collect_type(fs, owner, t->lhs);
break;
case N_TARRAY:
/* Array length is part of the resolved type identity, not a source
* name dependency. Canonicalize it so private constants stay private
* and a consumer never needs an implementation def to size the type. */
if (t->rhs != NULL && t->rhs->kind != N_INTLIT) {
u64 len;
if (!check_eval_const(fs->c, t->rhs, owner, &len)) {
errorf(t->pos, "cannot encode array dimension");
fs->bad = 1;
} else {
Node *e = t->rhs;
e->kind = N_INTLIT;
e->uval = len;
e->tsuffix = NULL;
e->lhs = e->rhs = e->list = NULL;
}
}
wwi_collect_type(fs, owner, t->lhs);
break;
case N_TFN:
for (Node *p = t->list; p; p = p->next)
wwi_collect_type(fs, owner, p->lhs);
wwi_collect_type(fs, owner, t->lhs);
break;
case N_TSTRUCT:
for (Node *f = t->list; f; f = f->next)
wwi_collect_type(fs, owner, f->lhs);
break;
case N_TTAGGED:
case N_TTUPLE:
for (Node *e = t->list; e; e = e->next)
wwi_collect_type(fs, owner, e);
break;
case N_TENUM:
wwi_collect_type(fs, owner, t->lhs);
/* Member identifiers are enum-local prior-sibling references, not
* package defs; the complete member list already carries their facts. */
break;
default:
break;
}
}
static void
wwi_collect_decl(struct factset *fs, const char *owner, Node *d)
{
for (int i = 0; i < fs->nseen; i++)
if (wwi_fact_same(&fs->seen[i], owner, d))
return;
wwi_fact_grow(&fs->seen, &fs->capseen, fs->nseen + 1);
fs->seen[fs->nseen] = (struct factent){d, owner, fs->nseen};
fs->nseen++;
if (owner != NULL) {
if (!d->export) {
errorf(d->pos, "exported declaration references unexported "
"%s '%s'", d->kind == N_TYPEDECL ? "type" : "def",
d->str);
fs->bad = 1;
return;
}
wwi_fact_grow(&fs->facts, &fs->capfacts, fs->nfacts + 1);
fs->facts[fs->nfacts] = (struct factent){d, owner, fs->nfacts};
fs->nfacts++;
}
switch (d->kind) {
case N_FNDECL:
for (Node *p = d->list; p; p = p->next)
wwi_collect_type(fs, owner, p->lhs);
wwi_collect_type(fs, owner, d->lhs);
break;
case N_TYPEDECL:
wwi_collect_type(fs, owner, d->lhs);
break;
case N_DEF:
wwi_collect_type(fs, owner, d->lhs);
wwi_collect_expr(fs, owner, d->rhs);
break;
case N_LET:
wwi_collect_type(fs, owner, d->lhs);
break;
default:
break;
}
}
static int
wwi_use_owned(Node *u, const char *owner)
{
return u->kind == N_USE && u->imported != 0
&& wwi_mod_eq(u->module, owner);
}
static void
wwi_emit_fact_imports(FILE *of, Node *file, const char *owner)
{
int nuse = 0;
for (Node *u = file->list; u; u = u->next)
if (wwi_use_owned(u, owner)) nuse++;
if (nuse == 0) return;
struct useent *us = malloc((size_t)nuse * sizeof *us);
if (us == NULL) fatal("wwi: out of memory");
int k = 0;
for (Node *u = file->list; u; u = u->next) {
if (!wwi_use_owned(u, owner)) continue;
us[k].path = u->usepath ? u->usepath : u->str;
us[k].idx = k;
k++;
}
qsort(us, (size_t)nuse, sizeof *us, usecmp);
const char *previous = NULL;
for (int i = 0; i < nuse; i++) {
if (previous && strcmp(previous, us[i].path) == 0) continue;
fprintf(of, "import %s;\n", us[i].path);
previous = us[i].path;
}
free(us);
}
int
wwi_emit(Checker *c, FILE *of, Node *file)
{
@@ -502,6 +796,22 @@ wwi_emit(Checker *c, FILE *of, Node *file)
if (bad)
return 1;
/* Relocate the exported API's reachable foreign type facts into this
* package's own interface. The driver remains deliberately ignorant of
* the representation and will pass only this artifact for a direct dep. */
struct factset fs = {.c = c};
for (Node *d = file->list; d; d = d->next) {
if (!wwi_primary(d) || !d->export || !wwi_is_decl(d)) continue;
wwi_collect_decl(&fs, NULL, d);
}
if (fs.bad) {
free(fs.facts);
free(fs.seen);
return 1;
}
if (fs.nfacts > 1)
qsort(fs.facts, (size_t)fs.nfacts, sizeof *fs.facts, factcmp);
/* package line: leaf of the first primary decl's module tag. */
const char *pkg = "main";
int found = 0;
@@ -573,5 +883,24 @@ wwi_emit(Checker *c, FILE *of, Node *file)
wwi_decl(of, ds[i].d);
free(ds);
}
/* Compiler-owned public fact closure. A module marker changes semantic
* ownership without making the namespace a source import of the eventual
* consumer; direct visibility continues to come solely from its own N_USE. */
const char *lastmod = NULL;
for (int i = 0; i < fs.nfacts; i++) {
struct factent *f = &fs.facts[i];
if (lastmod == NULL || strcmp(lastmod, f->mod) != 0) {
const char *dot = strrchr(f->mod, '.');
const char *leaf = dot ? dot + 1 : f->mod;
fprintf(of, "//ww:module %s\n", f->mod);
fprintf(of, "package %s;\n", leaf);
wwi_emit_fact_imports(of, file, f->mod);
lastmod = f->mod;
}
wwi_decl(of, f->d);
}
free(fs.facts);
free(fs.seen);
return 0;
}

47
cmd/wcc/check.c
View File

@@ -631,6 +631,16 @@ eval_def_const(Checker *c, Node *n, u64 *out, int depth)
}
}
int
check_eval_const(Checker *c, Node *n, const char *owner, u64 *out)
{
const char *saved = c->cur_mod;
c->cur_mod = owner;
int ok = eval_def_const(c, n, out, 0);
c->cur_mod = saved;
return ok;
}
/* stamp_intlit — rewrite a const-folded def rhs in place to the
* literal it evaluates to, preserving the node's cexpr-resolved type
* so the downstream DATA-row emit width and the invariant checks see
@@ -3083,6 +3093,27 @@ check_module_shadow(Checker *c, const char *name, Pos pos,
kindstr, name, name);
}
/* Self-contained `.wwi` files can carry the same origin-owned type/const
* fact through two direct dependencies (a diamond), or alongside a direct
* import of that origin. In strict package mode those compiler-generated
* declarations describe one canonical package symbol: reuse the first exact
* (module, kind, name) binding so nominal Type pointer identity is preserved.
* Raw w6c mode deliberately keeps the historical duplicate diagnostics. */
static Sym *
same_import_fact(Checker *c, Node *d, const char *mod, Skind kind)
{
if (!c->sep_mode || d == NULL || !d->imported || !d->export
|| mod == NULL || mod[0] == '\0')
return NULL;
if (kind != SK_TYPE && kind != SK_DEF)
return NULL;
Sym *s = scope_lookup_in_module(c->cur, mod, d->str);
if (s == NULL || s->kind != kind || s->decl == NULL || s->decl == d
|| !s->decl->imported || !s->decl->export)
return NULL;
return s;
}
void
check_file(Checker *c, Node *file)
{
@@ -3145,9 +3176,14 @@ check_file(Checker *c, Node *file)
continue;
}
if (d->kind != N_TYPEDECL) continue;
const char *mod = decl_mod(file, d);
Sym *fact = same_import_fact(c, d, mod, SK_TYPE);
if (fact != NULL) {
d->type = fact->type;
continue;
}
Type *named = type_named(c->a, d->str, NULL);
Sym *prev = scope_lookup_local(c->cur, d->str);
const char *mod = decl_mod(file, d);
if (prev && prev->kind == SK_USE) {
/* `use mod; ... type mod = ...;` — promote the
* SK_USE to the type symbol but remember it was
@@ -3175,6 +3211,8 @@ check_file(Checker *c, Node *file)
if (d->kind != N_DEF) continue;
c->cur_mod = decl_mod(file, d);
const char *mod = decl_mod(file, d);
if (same_import_fact(c, d, mod, SK_DEF) != NULL)
continue;
Sym *prev = scope_lookup_local(c->cur, d->str);
if (prev && prev->kind == SK_USE) {
prev->kind = SK_DEF; prev->decl = d;
@@ -3200,9 +3238,14 @@ check_file(Checker *c, Node *file)
break;
case N_DEF: {
Type *t = resolve_type(c, d->lhs);
const char *mod = decl_mod(file, d);
Sym *fact = same_import_fact(c, d, mod, SK_DEF);
if (fact != NULL) {
d->type = fact->type ? fact->type : t;
break;
}
d->type = t;
Sym *prev = scope_lookup_local(c->cur, d->str);
const char *mod = decl_mod(file, d);
if (prev && prev->kind == SK_DEF && prev->decl == d) {
/* #141: the foldable stub bound before type-body
* resolution; fill in its now-resolved type. */

5
cmd/wcc/ww.h
View File

@@ -609,4 +609,9 @@ void check_file(Checker*, Node *file);
* (eval_enum_value's leaf delegation, emit_defs's DATA-row gate). */
int fold_int_literal(Node*, u64*);
/* Re-evaluate a checked integer constant under the declaration owner's
* import scope. The compiler export writer uses this to canonicalize array
* dimensions without serializing source-level constant dependencies. */
int check_eval_const(Checker*, Node*, const char *owner, u64*);
#endif /* WW_H */