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).
36 lines
1.3 KiB
Plaintext
36 lines
1.3 KiB
Plaintext
// Backtick raw-identifier escape: a leading backtick makes the following
|
|
// identifier RAW — its text excludes the backtick and it is never the
|
|
// reserved/builtin keyword, so a reserved type-name spelling (`s2`, `u8`, …)
|
|
// can be used as an ordinary identifier. Exercised in every VALUE position:
|
|
// global, local, param, struct field + member access, function name + call,
|
|
// and a later reference. (A raw identifier in TYPE position references a
|
|
// backtick-declared type instead — see examples/0154.) A *bare* `s2` is still
|
|
// the reserved type name (see examples/1119), so the escape is the only way to
|
|
// spell these as values.
|
|
// Regression (issue 0089).
|
|
#import "modules/std.sx";
|
|
|
|
// Global named with a reserved type spelling.
|
|
`u8 := 100;
|
|
|
|
// Function whose name is a reserved type spelling, with a reserved-name param.
|
|
`s2 :: (`s1: s64) -> s64 { return `s1 * 2; }
|
|
|
|
Point :: struct {
|
|
`s2: f64; // field name is a reserved type spelling
|
|
`u16: s64;
|
|
}
|
|
|
|
main :: () {
|
|
// Local with a reserved type spelling; later reference resolves to it.
|
|
`s64 := 7;
|
|
`s64 = `s64 + 1;
|
|
print("local = {}\n", `s64);
|
|
|
|
print("global = {}\n", `u8);
|
|
print("fn = {}\n", `s2(21)); // calls the `s2 function
|
|
|
|
p := Point.{ `s2 = 2.5, `u16 = 9 };
|
|
print("field = {} {}\n", p.`s2, p.`u16);
|
|
}
|