Meaningful identifiers and other multi-token keywords
Quirin Schroll
qs.il.paperinik at gmail.com
Tue Sep 24 20:37:36 UTC 2024
D’s has 4 places in the grammar where meaningful identifiers are
used instead of keywords:
- Pragmas
- Traits
- Linkages
- Scope guards
For pragmas and traits, this is total non-issue as they have
special and dedicated keywords. For linkages and scope guards,
there will be rough edges if we make `(Type)` be a well-formed
`BasicType`. The reason is that `extern(C)` could mean `extern`
plus the basic type `(C)`, where `C` denotes e.g. a dummy class;
or `scope (exit) x = 10;` with the intention not to assign `x`,
but to declare `x` as a `scope` variable of type `exit`. In
general, you could ask: Why would one write such code? and you’d
be correct.
The issue is with the argument to `extern` and `linkage` being
identifiers. For linkage, it’s implementation defined which ones
are supported, and they’re not just identifiers (e.g. `C++` and
`Objective-C`), however, with scope guards, there are only
`exit`, `success`, and `failure`.
I want to suggest moving the parsing of scope guards and linkages
to the lexer, i.e., if the lexer sees `scope`, `(`, any one of
the identifiers `exit`, `success`, or `failure`, and `)`, that is
a scope guard and is treated as a single token.
The same with `extern(C)` – it will never be seen as anything but
a linkage. It’s a multi-token keyword.
Possibly, we can handle other cases alike, e.g. `static assert`,
`static foreach`, and `auto ref`. By all accounts, their meaning
isn’t derived from composing the semantics of the parts.
What do you think?
More information about the Digitalmars-d
mailing list