023971cae5
AGRA ruling (attempt 4): `` `name `` is THE LITERAL identifier `name`, usable in EVERY position — the backtick only means "treat this token as a plain identifier, never the reserved keyword/type", and is never part of the name's text. - Raw in TYPE position is now VALID (reverses attempt-2 "raw is not a type"): `parseTypeExpr` emits a raw `type_expr`; `TypeResolver.resolveNamed` gains a `skip_builtin` flag (threaded from `te.is_raw` via lower.zig + type_bridge) so a `` `s2 `` reference resolves to a `` `s2 ``-declared type (struct/enum/union/alias), else a normal "unknown type 's2'" error (reportIfUnknownType skips the builtin exemption when raw). Bare `s2` in type position stays the builtin int. - Every declaration-name site is is_raw-exemptible: `is_raw` added to TypeExpr + StructDecl/EnumDecl/UnionDecl/ErrorSetDecl/ProtocolDecl/ForeignClassDecl/UfcsAlias/ NamespaceDecl/ImportDecl/CImportDecl/LibraryDecl; parser threads name_is_raw to every decl parse fn; namespace imports carry it through imports.addNamespace. Typed-const path (`` `s2 : s64 : 5 ``) now threads name_span+is_raw (fixes the 1:1-caret bug). - Check<->exemption made structurally symmetric: checkBindingName/checkDeclName take is_raw as a REQUIRED argument and skip inside the check, so no call site can validate a name without honoring the exemption (the desync cause of prior rounds). - Bare reserved-name declarations of every kind still error (0076 preserved); `#import c` foreign names stay auto-raw + bare-callable. specs.md + readme.md updated to the universal model. issue 0089 RESOLVED banner rewritten. Examples: replace 1139 (raw-not-a-type) with 0154 (raw type reference); add 0155 (typed const + union tag) and 1141 (bare type-decl negatives). Gate: zig build + zig build test + run_examples (426 passed, 0 failed).
43 lines
1.6 KiB
Plaintext
43 lines
1.6 KiB
Plaintext
// Backtick raw identifier in TYPE position (the universal model, issue 0089):
|
|
// `` `name `` is the LITERAL identifier `name` used as a type reference, never
|
|
// the builtin/reserved spelling. A reserved type spelling (`s2`, `u8`, …) can
|
|
// therefore both DECLARE a type (struct / enum / union / error-set / alias) and
|
|
// be REFERENCED as that type via the backtick — while a BARE `s2` in type
|
|
// position remains the signed-int type (see `add` below) and a bare reserved-
|
|
// name declaration still errors (see examples/1141). The backtick is required
|
|
// to declare or reference these names; it is never part of the name's text.
|
|
// Regression (issue 0089 — attempt-4 universal raw identifier).
|
|
#import "modules/std.sx";
|
|
|
|
// Type-introducing decls whose NAME is a reserved spelling.
|
|
`s2 :: struct { x: s64; }
|
|
`s8 :: enum { A; B; }
|
|
`u16 :: union { i: s32; f: f32; }
|
|
`u32 :: error { Bad, Empty }
|
|
RawAlias :: `s2; // alias to a backtick-declared struct
|
|
|
|
// A bare `s2` in type position is still the 2-bit signed int.
|
|
add :: (a: s2, b: s2) -> s2 { return a + b; }
|
|
|
|
main :: () -> s32 {
|
|
// Reference the backtick struct as a type; field access works.
|
|
v : `s2 = ---;
|
|
v.x = 7;
|
|
|
|
// Reference via a normal alias too.
|
|
a : RawAlias = ---;
|
|
a.x = 11;
|
|
|
|
// Backtick enum / union type references.
|
|
e : `s8 = .A;
|
|
u : `u16 = ---;
|
|
u.i = 5;
|
|
|
|
print("struct = {}\n", v.x);
|
|
print("alias = {}\n", a.x);
|
|
print("enum = {}\n", e == .A);
|
|
print("union = {}\n", u.i);
|
|
print("bare = {}\n", add(1, 0)); // bare s2 = the 2-bit int type
|
|
return 0;
|
|
}
|