Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Essentially, this change renames
BasicType
toPrimaryType
and givesBasicType
a new meaning.The entity
BasicType
and the term basic type will be used for the non-recursive rules in the type grammar. The recursive rules areTypeCtor(Type)
and__vector(Type)
. Those would constitute elaborate primary types (with elaborate = non-basic). The non-recursive rules are e.g. fundamental types, identifiers,mixin
types,typeof
types, etc., stuff that doesn’t immediately require parsing aType
again.This is in prospect of the Primary Type Syntax DIP which, if accepted, will make
PrimaryType
truly be the type equivalent toPrimaryExpression
in the expression syntax. Note that any DIP that adds tuples to the grammar based on parentheses, e.g. one that makes(int, int)
a type, will profit from this change because such a type would be an elaborate primary type, and parts of the grammar spec (or forum discussions) can then easily distinguish primary and basic types in places where parsing ambiguity must be avoided.In particular, this change allows the grammar spec to require a non-trivial type construct that is not a qualified type in code. This makes sense in places where the qualifier would be ignored if given, e.g. base class lists and, possibly in the future, the argument of
__vector
.I’m not that deep into the SIMD types, so I left it alone, but as far as I understand, it could be constrained syntactically so that providing an ill-formed vector type fails fast. Essentially, a vector type would probably be
__vector(BasicType TypeSuffixesopt)
where theTypeSuffixes
are optional because ifBasicType
is something other than aFundamentalType
, it could already be a static array.The parser changes required by this change are implemented in this PR.
Changes
Most changes are
BasicType
toPrimaryType
.class.dd
Remove the unnecessary
SuperClassOrInterface
andInterfaces
/Interface
grammar entities, those are allBasicType
now. A base class should not be spelled out in code as e.g.const(Object)
as it’s equivalent toObject
. if amixin
or ´typeof` resolves to a qualified type, the qualifiers are still ignored. This is about parsing only.declaration.dd
Rephrased a paragraph mentioning “basic type” with no actual connection to
BasicType
.expression.dd
Also renames
BasicTypeWithSuffixes
toSuffixedPrimaryType
simd.dd
Because I inlined the
Vector
grammar entity, some rephrasing was needed.template.dd
For
TemplateValueParameter
, I changedBasicType
toType
because this is what the compiler implements and there’s no good reason to change the compiler. This change would also encompass the Primary Type Syntax DIP and (likely) any tuple DIP.type.dd
Rephrased a paragraph mentioning “basic type” with no actual connection to
BasicType
.