@sap/cds-compiler 5.1.2 → 5.3.0

package/lib/parsers/CdlGrammar.g4

@@ -0,0 +1,2013 @@
+// Grammar for CDS
+
+parser grammar Cdl;
+options {
+  language = JavaScript;
+  superClass = AstBuildingParser;
+}
+@header{
+  const { XsnSource, XsnArtifact, XsnName } = require( '../compiler/xsn-model' );
+  const AstBuildingParser = require('../parsers/AstBuildingParser');
+}
+
+// Content:
+//  - top-level: USING, NAMESPACE, artifactDefOrExtend (start rule: start)
+//  - main definitions and annotation def
+//  - member definitions
+//  - EXTEND and ANNOTATE
+//  - type expressions
+//  - queries: the main query hierarchy (start rule: queryEOF)
+//  - queries: columns and other clauses
+//  - conditions and expressions (start rule: conditionEOF)
+//  - paths and functions
+//  - annotation assignments
+
+tokens{                         // reserved words
+  ALL, ANY, AS,
+  BY,
+  CASE, CAST,
+  EXISTS,
+  FALSE, FROM,
+  IN,
+  KEY,
+  NOT, NULL,
+  OF, ON,
+  SELECT, SOME,
+  TRUE,
+  WHERE, WITH,
+}
+
+// Top-level: USING, NAMESPACE, artifactDefOrExtend (start rule: start) ---------
+
+start returns[ source = new XsnSource( 'cdl' ) ]
+  :
+    (
+      ( <cond=namespaceRestriction> namespaceDeclaration[ $source ]
+      | usingDeclaration[ $source ]
+      | artifactDefOrExtend[ $source ] <setCondition=namespaceRestriction>
+      )
+      ( ';' | <exitLoop> | <repeatLoop=afterBrace> { this.noAssignmentInSameLine(); } )
+    )*
+    EOF { this.docComment( null ); }
+  ;
+
+artifactsBlock[ art, start = undefined ]
+  :
+    '{'<setCondition=vocabularyRestriction>
+    { $art.artifacts = this.createDict( $start ); $art.extensions = []; }
+    (
+      artifactDefOrExtend[ $art ]
+      ( ';' | <exitLoop> | <repeatLoop=afterBrace> { this.noAssignmentInSameLine(); } )
+    )*
+    '}'<setCondition=afterBrace>
+    { this.finalizeDictOrArray( $art.artifacts ); }
+  ;
+
+artifactDefOrExtend[ outer ] locals[ art = new XsnArtifact() ]
+  :
+    { $art.location = this.startLocation(); }
+    { this.docComment( $art ); } annoAssignStd[ $art ]*
+    (
+      DEFINE?
+      ( serviceDef[ $art, $outer ]
+      | contextDef[ $art, $outer ]
+      | <cond=vocabularyRestriction>annotationDef[ $art, $outer ]
+      | typeDef[ $art, $outer ]
+      | aspectDef[ $art, $outer ]
+      | entityDef[ $art, $outer ]
+      | <hide> viewDef[ $art, $outer ]
+      | eventDef[ $art, $outer ]
+      | actionMainDef[ $art, $outer ]
+      | functionMainDef[ $art, $outer ]
+      )
+    |
+      <cond=extensionRestriction> EXTEND { $art.kind = 'extend'; }
+      ( extendArtifact[ $art, $outer ]
+      | extendService[ $art, $outer ]
+        // Non-streamlined Syntax; we would neither add new clauses to them, nor
+        // add more of them (for further `kind`s):
+      | <hide> extendContext[ $art, $outer ]
+      | <hide> extendType[ $art, $outer ]
+      | <hide> extendEntityOrAspect[ $art, $outer ]
+      | <hide> extendProjection[ $art, $outer ]
+      )
+    |
+      <cond=extensionRestriction> ANNOTATE annotateArtifact[ $art, $outer ]
+    )
+  ;
+
+namespaceDeclaration[ source ]
+@finally{ this.attachLocation( $source.namespace ); }
+  :
+    NAMESPACE name=namePath[ 'Namespace' ]
+    { $source.namespace ??= { kind: 'namespace', name: $name }; }
+    // TODO: XsnArtifact ?
+  ;
+
+usingDeclaration[ source ] locals[ decl = { kind: 'using' } ] // TODO: XsnArtifact ?
+@finally{ this.attachLocation( $decl ); }
+  :
+    USING
+    (
+      FROM String
+       { $source.dependencies.push( this.quotedLiteral() ); }
+    |
+      usingProxy[ $source, $decl ]
+      ( FROM String
+        { $source.dependencies.push( $decl.fileDep = this.quotedLiteral() ); }
+      )?
+    |
+      { $source.usings.push( $decl ); }
+      // We could just create "independent" USING declaration, but if we want
+      // to have some check in the future whether the external artifacts are
+      // really in the FROM source...
+      '{' { $decl.usings = this.createArray(); }
+      ( usingProxy[ $decl, { kind: 'using' } ]
+        ( ',' | <exitLoop> )
+      )+
+      '}'<setCondition=afterBrace>
+      { this.finalizeDictOrArray( $decl.usings ); }
+      ( FROM String
+        { $source.dependencies.push( $decl.fileDep = this.quotedLiteral() ); }
+      )?
+    )
+  ;
+
+usingProxy[ outer, proxy ]
+@finally{ this.attachLocation( $proxy ); }
+  :
+    extern=simplePath[ 'global' ]
+    { $proxy.extern = $extern; $outer.usings.push( $proxy ); }
+    ( AS Id['UsingAlias'] { $proxy.name = this.identAst(); } // TODO: XsnName ?
+    | { this.classifyImplicitName( 'Using' ); }
+    )
+  ;
+
+namePath[ category ] returns[ default name = new XsnName() ]
+@finally{ this.attachLocation( $name ); }
+  :
+    Id[ $category ] { $name.path = [ this.identAst() ]; }
+    (
+      '.' Id_all[ $category ] { $name.path.push( this.identAst() ); }
+    )*
+  ;
+
+simplePath[ category = 'artref' ] returns[ default ref = {} ]
+@finally{ this.attachLocation( $ref ); }
+  :
+    Id[ $category ]
+    { $ref.path = [ this.identAst() ]; }
+    (
+      '.' Id_all[ $category ] { $ref.path.push( this.identAst() ); }
+    )*
+  ;
+
+// Annotation def and main definitions ------------------------------------------
+
+serviceDef[ art, outer ]
+@finally{ this.attachLocation( $art ); }
+  :
+    SERVICE name=namePath[ 'Service' ]
+    { this.addDef( $art, $outer, 'artifacts', 'service', $name ); }
+    { this.docComment( $art ); } annoAssignMid[ $art ]*
+    artifactsBlock[ $art ]?
+  ;
+
+contextDef[ art, outer ]
+@finally{ this.attachLocation( $art ); }
+  :
+    CONTEXT name=namePath[ 'Context' ]
+    { this.addDef( $art, $outer, 'artifacts', 'context', $name ); }
+    { this.docComment( $art ); } annoAssignMid[ $art ]*
+    artifactsBlock[ $art ]?
+  ;
+
+annotationDef[ art, outer ]
+@finally{ this.attachLocation( $art ); }
+  :
+    ANNOTATION name=namePath[ 'AnnoDef' ]
+    { this.addDef( $art, $outer, 'vocabularies', 'annotation', $name ); }
+    { this.docComment( $art ); } annoAssignMid[ $art ]*
+    typeOrIncludesSpec[ $art ]
+  ;
+
+typeDef[ art, outer ]
+@finally{ this.attachLocation( $art ); }
+  :
+    TYPE name=namePath[ 'Type' ]
+    { this.addDef( $art, $outer, 'artifacts', 'type', $name ); }
+    { this.docComment( $art ); } annoAssignMid[ $art ]*
+    typeOrIncludesSpec[ $art ]  // TODO: optional
+  ;
+
+aspectDef[ art, outer ]
+@finally{ this.attachLocation( $art ); }
+  :
+    ( ASPECT
+    | <hide> ABSTRACT { this.warning( 'syntax-deprecated-abstract', this.lb().location ); }
+      ENTITY
+    )
+    name=namePath[ 'Type' ]     // TODO: Type?
+    { this.addDef( $art, $outer, 'artifacts', 'aspect', $name ); }
+    { this.docComment( $art ); } annoAssignMid[ $art ]*
+    (
+      elementsBlock[ $art ]
+      actionsBlock[ $art ]?
+    |
+      ':' aspectColonSpec[ $art ]
+    )?
+  ;
+
+aspectColonSpec[ art ]
+options{ minTokensMatched = 1 }
+  :
+    (
+      incl=simplePath { $art.includes ??= []; $art.includes.push( $incl ); }
+      ( ',' | <exitLoop> )
+    )*
+    (
+      elementsBlock[ $art ]
+      actionsBlock[ $art ]?
+    )?                          // TODO: no rule end after ','
+  ;
+
+entityDef[ art, outer ]
+@finally{ this.attachLocation( $art ); }
+  :
+    ENTITY name=namePath[ 'Entity' ]
+    { this.addDef( $art, $outer, 'artifacts', 'entity', $name ); }
+    { this.docComment( $art ); } annoAssignMid[ $art ]*
+    paramsList[ $art ]?
+    (
+      ( ':' { $art.includes ??= []; }
+        (
+          incl=simplePath { $art.includes.push( $incl ); }
+          ( ',' | <exitLoop> )
+        )+
+      )?
+      elementsBlock[ $art ]
+    |
+      AS
+      (
+        query=queryExpression
+        { $art.query = $query; $art.$syntax = 'entity'; }
+      |
+        query=projectionSpec
+        { $art.query = $query; $art.$syntax = 'projection'; }
+        whereGroupByHaving[ $query ]?
+        orderByLimitOffset[ $query ]?
+      )
+    )
+    actionsBlock[ $art ]?
+  ;
+
+viewDef[ art, outer ]
+@finally{ this.attachLocation( $art ); }
+  :
+    VIEW name=namePath[ 'Entity' ]
+    { this.addDef( $art, $outer, 'artifacts', 'entity', $name ); }
+    { this.docComment( $art ); } annoAssignMid[ $art ]*
+    (
+      paramsList[ $art ]
+    |
+      <hide> WITH PARAMETERS { $art.params = this.createDict(); }
+      paramDef[ $art ]
+      ( ',' paramDef[ $art ] )* // no optional final ',' here
+      { this.finalizeDictOrArray( $art.params ); }
+    )?
+    AS query=queryExpression
+    { $art.query = $query; $art.$syntax = 'view'; }
+  ;
+
+eventDef[ art, outer ]
+@finally{ this.attachLocation( $art ); }
+  :
+    EVENT
+    name=namePath[ 'Event' ]
+    { this.addDef( $art, $outer, 'artifacts', 'event', $name ); }
+    { this.docComment( $art ); } annoAssignMid[ $art ]*
+    (
+      elementsBlock[ $art ]
+    |
+      ':'
+      (
+        elementsBlock[ $art ]
+      |
+        incl=simplePath { $art.type = $incl; }
+        (
+          { $art.includes = [ $art.type ]; delete $art.type; }
+          ( ','
+            ( incl=simplePath { $art.includes.push( $incl ); }
+              ( ',' | <exitLoop> )
+            )*
+          )?
+          elementsBlock[ $art ]
+        |
+          { this.docComment( $art ); } annoAssignStd[ $art ]*
+        )
+      |
+        query=projectionSpec { $art.query = $query; $art.$syntax = 'projection'; }
+      )
+    )
+  ;
+
+actionMainDef[ art, outer ]
+@finally{ this.attachLocation( $art ); }
+  :
+    ACTION name=namePath[ 'Action' ]
+    { this.addDef( $art, $outer, 'artifacts', 'action', $name ); }
+    { this.docComment( $art ); } annoAssignMid[ $art ]*
+    paramsList[ $art ]
+    returnsSpec[ $art ]?
+  ;
+
+functionMainDef[ art, outer ]
+@finally{ this.attachLocation( $art ); }
+  :
+    FUNCTION name=namePath[ 'Action' ]
+    { this.addDef( $art, $outer, 'artifacts', 'function', $name ); }
+    { this.docComment( $art ); } annoAssignMid[ $art ]*
+    paramsList[ $art ]
+    returnsSpec[ $art ]
+  ;
+
+// Member definitions: actions, parameters, elements, enums: --------------------
+
+actionsBlock[ art ]
+  :
+    ACTIONS { $art.actions = this.createDict(); } '{'
+    (
+      boundActionFunctionDef[ $art ]
+      ( ';' | <exitLoop> | <repeatLoop=afterBrace> { this.noAssignmentInSameLine(); } )
+    )*
+    '}'<setCondition=afterBrace>
+    { this.finalizeDictOrArray( $art.actions ); }
+  ;
+
+boundActionFunctionDef[ outer ] locals[ art = new XsnArtifact() ]
+@finally{ this.attachLocation( $art ); }
+  :
+    { this.docComment( $art ); } annoAssignStd[ $art ]*
+    (
+      ACTION Id['BoundAction']
+      { this.addDef( $art, $outer, 'actions', 'action', this.identAst() ); }
+      { this.docComment( $art ); } annoAssignMid[ $art ]*
+      paramsList[ $art ]
+      returnsSpec[ $art ]?
+    |
+      FUNCTION Id['BoundAction']
+      { this.addDef( $art, $outer, 'actions', 'function', this.identAst() ); }
+      { this.docComment( $art ); } annoAssignMid[ $art ]*
+      paramsList[ $art ]
+      returnsSpec[ $art ]
+    )
+  ;
+
+paramsList[ art ]
+  :
+    '(' { $art.params = this.createDict(); }
+    (
+      paramDef[ $art ]
+      ( ',' | <exitLoop> )
+    )*
+    ')' { this.finalizeDictOrArray( $art.params ); }
+  ;
+
+paramDef[ outer ] locals[ art = new XsnArtifact() ]
+@finally{ this.attachLocation( $art ); }
+  :
+    { this.docComment( $art ); } annoAssignStd[ $art ]*
+    Id_all['Param']
+    { this.addDef( $art, $outer, 'params', 'param', this.identAst() ); }
+    { this.docComment( $art ); } annoAssignMid[ $art ]*
+    (
+      elementsBlock[ $art ]
+      nullability[ $art ]?
+    |
+      ':'
+      typeExpression[ $art ]    // was elementType, with NOT? NULL / DEFAULT
+    )
+  ;
+
+returnsSpec[ outer ] locals[ art = new XsnArtifact() ]
+@finally{ this.attachLocation( $art ); }
+  :
+    RETURNS<setCondition=elementRestriction>
+    { $art.kind = 'param'; $outer.returns = $art; }
+    { this.docComment( $art ); } annoAssignStd[ $art ]*
+    typeExpression[ $art ]
+  ;
+
+elementsBlock[ art ]
+  :
+    '{' { $art.elements = this.createDict(); }
+    ( elementDef[ $art ]
+      ( ';'
+      | <exitLoop>
+      | <repeatLoop=afterBrace, restrict=Id> { this.noAssignmentInSameLine(); }
+      )
+    )*
+    '}'<setCondition=afterBrace>
+    { this.finalizeDictOrArray( $art.elements ); }
+  ;
+
+elementDef[ outer, art = undefined ]
+@finally{ this.attachLocation( $art ); }
+  :
+    { $art ??= new XsnArtifact(); }
+    { this.docComment( $art ); } annoAssignStd[ $art ]*
+    ( VIRTUAL { $art.virtual = this.valueWithLocation( true ); } )?
+    ( KEY { $art.key = this.valueWithLocation( true ); } )?
+    ( MASKED { $art.masked = this.valueWithLocation( true ); }
+      { this.message( 'syntax-unsupported-masked', this.lb(), { keyword: 'masked' } ); } )?
+    ( ELEMENT { $art.$syntax = 'element'; } )?
+    Id['Element']
+    { this.addDef( $art, $outer, 'elements', 'element', this.identAst() ); }
+    { this.docComment( $art ); } annoAssignMid[ $art ]*
+    (
+      elementsBlock[ $art ]
+      nullability[ $art ]?
+    |
+      ':'<setCondition=elementRestriction>
+      typeExpression[ $art ]    // was elementType, with NOT? NULL / DEFAULT
+    |
+      // <setCondition=elementRestriction> // TODO TOOL: allow this
+      { this.elementRestriction(); }<always> // workaround
+    )
+    (
+      <cond=calcOrDefaultRestriction> '='
+      // TODO TOOL: add to "expected set" if failing here?  Or have some "do not
+      // consider for rule exit if condition failure on `=`"?
+      expr=expression { $art.value = $expr; }
+      ( STORED { $art.value.stored = this.valueWithLocation( true ); } )?
+      // TODO: why have `stored` as property of the value?
+      { this.docComment( $art ); } // TODO: also restricted
+      ( <cond=elementRestriction> annoAssignStd[ $art ] )*
+    )?
+  ;
+
+enumSymbolsBlock[ art ]
+  :
+    ENUM { $art.enum = this.createDict(); } '{'
+    ( enumSymbolDef[ $art ]
+      ( ';' | <exitLoop> )
+    )*
+    '}'<setCondition=afterBrace>
+    { this.finalizeDictOrArray( $art.enum ); }
+  ;
+
+enumSymbolDef[ outer ] locals[ art = new XsnArtifact() ]
+@finally{ this.attachLocation( $art ); }
+  :
+    { this.docComment( $art ); } annoAssignStd[ $art ]*
+    Id['Enum']
+    { this.addDef( $art, $outer, 'enum', 'enum', this.identAst() ); }
+    { this.docComment( $art ); } annoAssignStd[ $art ]*
+    ( '='
+      (
+        <priority> String
+        { $art.value = this.quotedLiteral(); }
+      |
+        <priority> Number
+        { $art.value = this.numberLiteral(); }
+      |
+        sign='+'/'-' Number
+        { $art.value = this.numberLiteral( $sign ); }
+      |
+        <hide> value=literalValue
+        { $art.value = $value; }
+      )
+      { this.docComment( $art ); } annoAssignStd[ $art ]*
+    )?
+  ;
+
+foreignKeysBlock[ art ]
+  :
+    '{' { $art.foreignKeys = this.createDict(); }
+    ( foreignKeyDef[ $art ]
+      ( ',' | <exitLoop> )
+    )*
+    '}'         // DOES NOT SET afterBrace, because we allow annos after { …fks… }
+    { this.finalizeDictOrArray( $art.foreignKeys ); }
+  ;
+
+foreignKeyDef[ outer ] locals[ art = new XsnArtifact(), name ]
+@finally{ this.attachLocation($art); }
+  :
+    { this.docComment( $art ); } annoAssignStd[ $art ]*
+    ref=simplePath[ 'ref' ] { $art.targetElement = $ref; }
+    ( AS name=Id['Key'] { $name = this.identAst(); }
+    | { this.classifyImplicitName( 'KeyImplicit', $ref ); $name = $ref.path; }
+    )
+    { this.addDef( $art, $outer, 'foreignKeys', 'key', $name ); }
+    // TODO: for a more uniform syntax, we'd allow:
+    // { this.docComment( $art ); } annoAssignMid[ $art ]*
+  ;
+
+mixinElementDef[ outer ] locals[ art = new XsnArtifact() ]
+@finally{ this.attachLocation($art); }
+  :
+    Id['Mixin']
+    { this.addDef( $art, $outer, 'mixin', 'mixin', this.identAst() ); }
+    ':'
+    ( assoc=ASSOCIATION cardinality[ $art ]? TO
+    | assoc=COMPOSITION cardinality[ $art ]? OF
+    )
+    card=ONE/MANY? target=simplePath
+    { this.setAssocAndComposition( $art, $assoc, $card, $target ); }
+    ON expr=condition { $art.on = $expr; }
+  ;
+
+// Annotate and Extend: main definitions ----------------------------------------
+
+annotateArtifact[ art, outer ]
+@finally{ this.attachLocation( $art ); }
+  :
+    name=namePath[ 'Ext' ]
+    ( // direct element annotation:
+      ':' elemName=namePath[ 'ExtElement']
+      { this.addExtension( $art, $outer, 'annotate', $name, $elemName.path ); }
+      WITH?
+      { this.docComment( $art ); } annoAssignStd[ $art ]*
+      annotateElementsBlock[ $art ]?
+    | // definition annotation
+      WITH?
+      // <cond=noRuleExitAfterWith>), or as rule option,
+      // this.noSemicolonHere() had the issues: DocComment, before `}`/EOF
+      { this.addExtension( $art, $outer, 'annotate', $name ); }
+      { this.docComment( $art ); } annoAssignStd[ $art ]*
+      annotateParamsBlock[ $art ]?
+      (
+        annotateReturns[ $art ]
+      |
+        annotateElementsBlock[ $art ]?
+        annotateActionsBlock[ $art ]?
+      )
+    )
+  ;
+
+extendArtifact[ art, outer ]
+@finally{ this.attachLocation( $art ); }
+  :
+    name=namePath[ 'Ext' ]
+    ( // direct element annotation:
+      ':' elemName=namePath[ 'ExtElement']
+      { this.addExtension( $art, $outer, 'extend', $name, $elemName.path ); }
+      WITH?
+      { this.docComment( $art ); } annoAssignStd[ $art ]*
+      (
+        elements=ELEMENTS? extendElementsBlock[ $art, $elements ]
+      |
+        enumSymbolsBlock[ $art ] // ENUM …, just define, no extend
+      |
+        typeNamedArgsList[ $art ]
+      )?
+    |
+      { this.addExtension( $art, $outer, 'extend', $name ); }
+      { this.docComment( $art ); } annoAssignStd[ $art ]*
+      ( extendElementsBlock[ $art ]
+        actionsBlock[ $art ]?
+      )?
+    |
+      WITH
+      { this.addExtension( $art, $outer, 'extend', $name ); }
+      { this.docComment( $art ); } annoAssignStd[ $art ]*
+      (
+        incl=simplePath { $art.includes = [ $incl ]; }
+        ( ',' incl=simplePath { $art.includes.push( $incl ); } )*
+        extendElementsBlock[ $art ]?
+        actionsBlock[ $art ]?
+      |
+        elements=ELEMENTS? extendElementsBlock[ $art, $elements ]
+        actionsBlock[ $art ]?
+      |
+        actionsBlock[ $art ]
+      |
+        enumSymbolsBlock[ $art ] // ENUM …, just define, no extend
+      |
+        typeNamedArgsList[ $art ]
+      |
+        COLUMNS selectItemsList[ $art, this.lb() ]
+      |
+        DEFINITIONS artifactsBlock[ $art, this.lb() ]
+      )?
+    )
+  ;
+
+extendService[ art, outer ]
+@finally{ this.attachLocation( $art ); }
+  :
+    SERVICE { $art.expectedKind = this.valueWithLocation(); }
+    name=namePath[ 'ExtService' ]
+    { $art.name = $name; $outer.extensions.push( $art ); }
+    WITH?
+    // <cond=noRuleExitAfterWith>), or as rule option,
+    // this.noSemicolonHere() had the issues: DocComment, before `}`/EOF
+    { this.docComment( $art ); } annoAssignStd[ $art ]*
+    artifactsBlock[ $art ]?
+  ;
+
+extendContext[ art, outer ]
+@finally{ this.attachLocation( $art ); }
+  :
+    CONTEXT { $art.expectedKind = this.valueWithLocation(); }
+    name=namePath[ 'ExtContext' ]
+    { $art.name = $name; $outer.extensions.push( $art ); }
+    WITH?
+    // <cond=noRuleExitAfterWith>), or as rule option,
+    // this.noSemicolonHere() had the issues: DocComment, before `}`/EOF
+    { this.docComment( $art ); } annoAssignStd[ $art ]*
+    artifactsBlock[ $art ]?
+  ;
+
+extendType[ art, outer ]
+@finally{ this.attachLocation( $art ); }
+  :
+    TYPE { $art.expectedKind = this.valueWithLocation(); }
+    name=namePath[ 'Ext' ]
+    { $art.name = $name; $outer.extensions.push( $art ); }
+    (
+      { this.docComment( $art ); } annoAssignStd[ $art ]*
+      extendElementsBlock[ $art ]?
+    |
+      WITH
+      { this.docComment( $art ); } annoAssignStd[ $art ]*
+      (
+        incl=simplePath { $art.includes = [ $incl ]; }
+        ( ',' incl=simplePath { $art.includes.push( $incl ); } )*
+        extendElementsBlock[ $art ]?
+      |
+        elements=ELEMENTS? extendElementsBlock[ $art, $elements ]
+      |
+        enumSymbolsBlock[ $art ]
+      |
+        typeNamedArgsList[ $art ]
+      )?
+    )
+  ;
+
+extendEntityOrAspect[ art, outer ]
+@finally{ this.attachLocation( $art ); }
+  :
+    ASPECT/ENTITY { $art.expectedKind = this.valueWithLocation(); }
+    name=namePath[ 'Ext' ]
+    { $art.name = $name; $outer.extensions.push( $art ); }
+    (
+      { this.docComment( $art ); } annoAssignStd[ $art ]*
+    |
+      WITH
+      { this.docComment( $art ); } annoAssignStd[ $art ]*
+      (
+        incl=simplePath { $art.includes = [ $incl ]; }
+        ( ',' incl=simplePath { $art.includes.push( $incl ); } )*
+      )?
+    )
+    extendElementsBlock[ $art ]?
+    actionsBlock[ $art ]?
+  ;
+
+extendProjection[ art, outer ]
+@finally{ this.attachLocation( $art ); }
+  :
+    PROJECTION { $art.expectedKind = this.valueWithLocation(); }
+    name=namePath[ 'Ext' ]
+    { $art.name = $name; $outer.extensions.push( $art ); }
+    WITH ?
+    { this.docComment( $art ); } annoAssignStd[ $art ]*
+    selectItemsList[ $art ]?
+    actionsBlock[ $art ]?
+  ;
+
+// Extend and annotate on members: bound actions, parameters, elements ----------
+
+annotateActionsBlock[ art ]
+  :
+    ACTIONS { $art.actions = this.createDict(); } '{'
+    ( annotateBoundAction[ $art ]
+      ( ';' | <exitLoop> | <repeatLoop=afterBrace> { this.noAssignmentInSameLine(); } )
+    )*
+    '}'<setCondition=afterBrace>
+    { this.finalizeExtensionsDict( $art.actions ); }
+  ;
+
+annotateBoundAction[ outer ] locals[ art = new XsnArtifact() ]
+@finally{ this.attachLocation( $art ); }
+  :
+    { this.docComment( $art ); } annoAssignStd[ $art ]*
+    Id['ExtBoundAction']
+    { this.addDef( $art, $outer, 'actions', 'annotate', this.identAst() ); }
+    { this.docComment( $art ); } annoAssignStd[ $art ]*
+    annotateParamsBlock[ $art ]?
+    annotateReturns[ $art ]?
+  ;
+
+annotateParamsBlock[ art ]
+  :
+    '(' { $art.params = this.createDict(); }
+    ( annotateParam[ $art ]
+      ( ',' | <exitLoop> )
+    )*
+    ')'
+    { this.finalizeExtensionsDict( $art.params ); }
+  ;
+
+annotateParam[ outer ] locals[ art = new XsnArtifact() ]
+@finally{ this.attachLocation( $art ); }
+  :
+    { this.docComment( $art ); } annoAssignStd[ $art ]*
+    Id['ExtParam']
+    { this.addDef( $art, $outer, 'params', 'annotate', this.identAst() ); }
+    { this.docComment( $art ); } annoAssignStd[ $art ]*
+    // annotateElementsBlock[ $art ]?  // TODO: why not
+  ;
+
+annotateReturns[ outer ] locals[ art = new XsnArtifact() ]
+@finally{ this.attachLocation( $art ); }
+  :
+    RETURNS { $outer.returns = $art; $art.kind = 'annotate'; } // TODO: tokenIndex necessary?
+    { this.docComment( $art ); } annoAssignStd[ $art ]*
+    annotateElementsBlock[ $art ]?
+  ;
+
+annotateElementsBlock[ art ]
+  :
+    '{' { $art.elements = this.createDict(); }
+    ( annotateElement[ $art ]
+      ( ';'
+      | <exitLoop>
+      | <repeatLoop=afterBrace, restrict=Id> { this.noAssignmentInSameLine(); }
+      )
+    )*
+    '}'<setCondition=afterBrace>
+    { this.finalizeExtensionsDict( $art.elements ); }
+  ;
+
+annotateElement[ outer ] locals[ art = new XsnArtifact() ]
+@finally{ this.attachLocation( $art ); }
+  :
+    { this.docComment( $art ); } annoAssignStd[ $art ]*
+    Id['ExtElement']
+    { this.addDef( $art, $outer, 'elements', 'annotate', this.identAst() ); }
+    { this.docComment( $art ); } annoAssignStd[ $art ]*
+    annotateElementsBlock[ $art ]?
+  ;
+
+extendElementsBlock[ art, start = undefined ]
+  :
+    '{' { $art.elements = this.createDict( $start ); }
+    ( elementDefOrExtend[ $art ]
+      ( ';'
+      | <exitLoop>
+      | <repeatLoop=afterBrace, restrict=Id> { this.noAssignmentInSameLine(); } )
+    )*
+    '}'<setCondition=afterBrace>
+    { this.finalizeExtensionsDict( $art.elements ); }
+  ;
+
+elementDefOrExtend[ outer ] locals[ art = new XsnArtifact() ]
+  :
+    { this.docComment( $art ); } annoAssignStd[ $art ]*
+    (
+      elementDef[ $outer, $art ]
+    |
+      EXTEND
+      ( ELEMENT { $art.expectedKind = this.valueWithLocation(); } )?
+      Id['ExtElement']
+      { this.addDef( $art, $outer, 'elements', 'extend', this.identAst() ); }
+      (
+        { this.docComment( $art ); } annoAssignStd[ $art ]*
+        extendElementsBlock[ $art ]?
+      |
+        WITH
+        { this.docComment( $art ); } annoAssignStd[ $art ]*
+        (
+          elements=ELEMENTS? extendElementsBlock[ art, $elements ]
+        |
+          enumSymbolsBlock[ $art ] // ENUM …, just define, no extend
+        |
+          typeNamedArgsList[ $art ]
+        )?
+      )
+    )
+  ;
+
+// Type expressions -------------------------------------------------------------
+
+// For `type` and `annotation` definitions:
+typeOrIncludesSpec[ art ]
+  :
+    elementsBlock[ $art ]
+    nullability[ $art ]?
+  |
+    ':'
+    (
+      typeExpression[ $art ]
+    |
+      <priority>
+      ref=simplePath { $art.type = $ref; }
+      (
+        // <default> does not work here
+        typeRefOptArgs[ $art ]<atAltStart>
+        ( typeExpression[ $art ]<atAltStart>
+        | { this.docComment( $art ); }
+        )
+      |
+        typeExpression[ $art ]<atAltStart>
+      |
+        { this.docComment( $art ); }
+      |
+        { $art.includes = [ $art.type ]; delete $art.type; }
+        (
+          ','
+          (
+            ref=simplePath { $art.includes.push( $ref ); }
+            ( ',' | <exitLoop> )
+          )*
+        )?
+        elementsBlock[ $art ]
+        nullability[ $art ]?
+      )
+    )
+  ;
+
+// Type expression (after the `:`) and “final” annotation assignment.  Type
+// expressions include `null`/`not null` and `default`, the latter is forbidden in
+// the `returns` type.
+//
+// If used in a definition with additional clauses (currently just `= expr` for
+// elements), these clauses must be guarded with <cond=…>.
+//
+// No annotation assignments are allowed after element and enum blocks, because
+// these would conflict with the optional `;` after those blocks.  To lower the
+// impact with enums, the “final” annotation assignments are actually moved before
+// the keyword `enum` (only allowed if not after `many`/`array of`).
+//
+// This rule is not used when the type expression is restricted: CDL-style cast in
+// `select` items, `cast` function, `mixin` definition.
+
+typeExpression[ art ]
+// TODO: really introduce <exitRule>
+  :
+    elementsBlock[ $art ]
+    nullability[ $art ]?
+  |
+    ( typeRefOptArgs[ $art ] | typeTypeOf[ $art ] )
+    (<altRuleStart>)
+    nullability[ $art ]?
+    // <setCondition=calcOrDefaultRestriction> // TODO TOOL: allow this
+    { this.calcOrDefaultRestriction(); }<always> // workaround
+    (
+      nullabilityAndDefault[ $art ]
+      { this.docComment( $art ); } annoAssignStd[ $art ]*
+    |
+      enumSymbolsBlock[ $art ]
+      nullabilityAndDefault[ $art ]?
+    |
+      { this.docComment( $art ); } annoAssignStd[ $art ]+
+      ( enumSymbolsBlock[ $art ]
+        // <setCondition=calcOrDefaultRestriction> // TODO TOOL: allow this
+        { this.calcOrDefaultRestriction(); }<always> // workaround
+        nullabilityAndDefault[ $art ]?
+      )?
+    |
+      { this.docComment( $art ); }
+    )
+  |
+    LOCALIZED
+    { $art.localized = this.valueWithLocation( true ); }
+    typeRefOptArgs[ $art ]      // TODO: why no TYPE OF ?
+    // <setCondition=calcOrDefaultRestriction> // TODO TOOL: allow this
+    { this.calcOrDefaultRestriction(); }<always> // workaround
+    nullabilityAndDefault[ $art ]?
+    { this.docComment( $art ); } annoAssignStd[ $art ]*
+  |
+    assoc=ASSOCIATION cardinality[ $art ]? TO card=ONE/MANY?
+    target=simplePath { this.setAssocAndComposition( $art, $assoc, $card, $target ); }
+    // final anno assignments allowed also with fkeys (also in ANTLR-based parser)
+    // <prepare=calcOrDefaultRestriction,arg=true> // TODO TOOL: allow this
+    { this.calcOrDefaultRestriction(false,true); }<always> // workaround
+
+    ( ON cond=condition { $art.on = $cond; }
+    | foreignKeysBlock[ $art ]?
+      nullabilityAndDefault[ $art ]?
+      // scalar default - hm..., what about calc expression?
+    )
+    { this.docComment( $art ); } annoAssignStd[ $art ]*
+  |
+    assoc=COMPOSITION cardinality[ $art ]? OF card=ONE/MANY?
+    (
+      target=simplePath { this.setAssocAndComposition( $art, $assoc, $card, $target ); }
+      // final anno assignments allowed also with fkeys (also in ANTLR-based parser) - TODO: really?
+      // <prepare=calcOrDefaultRestriction,arg=true> // TODO TOOL: allow this
+      { this.calcOrDefaultRestriction(false,true); }<always> // workaround
+      ( ON cond=condition { $art.on = $cond; }
+      | foreignKeysBlock[ $art ]?
+        nullabilityAndDefault[ $art ]?
+      )
+      { this.docComment( $art ); } annoAssignStd[ $art ]*
+    |
+      { $target = {}; this.setAssocAndComposition( $art, $assoc, $card, $target ); }
+      elementsBlock[ $target ]
+      { $target.location = $target.elements[Symbol.for('cds.$location')]; }
+    )
+  |
+    ( ARRAY OF { $art.items = { location: this.locationOfPrevTokens( 2 ) }; }
+    | MANY     { $art.items = { location: this.lb().location }; }
+    )
+    (
+      elementsBlock[ $art.items ]
+      nullability[ $art.items ]?
+    |
+      ( typeRefOptArgs[ $art.items ] | typeTypeOf[ $art.items ] )
+      nullability[ $art.items ]?
+      ( enumSymbolsBlock[ $art.items ]
+        nullability[ $art.items ]? // TODO: only with enum
+      |
+        { this.docComment( $art ); } annoAssignStd[ $art ]*
+      )
+    )
+  ;
+
+typeTypeOf[ art ] locals[ location ]
+  :
+    TYPE OF { location = this.locationOfPrevTokens( 2 ); }
+    type=simplePath[ 'ref' ] { $art.type = $type; }
+    (
+      { $type.scope = 'typeOf'; $type.path.unshift( { id: 'type of', location } ); }
+    |
+      ':' { $type.scope = $type.path.length; }
+      // If we have too much time, we could set the category of the simple path
+      // before to 'artref'; but why use TYPE OF before `Art:elem` anyway?
+      Id_all['ref'] { $type.path.push( this.identAst() ); }
+      (
+        '.' Id_all['ref'] { $type.path.push( this.identAst() ); }
+      )*
+    )
+  ;
+
+typeRefOptArgs[ art ] locals[ type = $art.type ]
+  :
+    type=simplePath { $art.type = $type; }
+    (<altRuleStart>)
+    (
+      ':' { $type.scope = $type.path.length; }
+      Id_all['ref'] { $type.path.push( this.identAst() ); }
+      (
+        '.' Id_all['ref'] { $type.path.push( this.identAst() ); }
+      )*
+    |
+      open='('
+      (
+        Number { $art.$typeArgs = this.createArray( $open ); }
+        { $art.$typeArgs.push( this.unsignedIntegerLiteral() ); }
+        (
+          ','
+          ( Number
+            { $art.$typeArgs.push( this.unsignedIntegerLiteral() ); }
+          | tok=VARIABLE/FLOATING
+            { $art.$typeArgs.push( { literal: 'string', val: $tok.keyword, location: $tok.location } ); }
+          | <exitLoop>
+          )
+        )*                      // TODO: really as loop?
+      |
+        { $art.$typeArgs = this.createDict( $open ); }
+        (
+          typeNamedArg[ $art ]
+          ( ',' | <exitLoop> )
+        )+                      // TODO: really as loop?
+      )
+      ')' { this.finalizeDictOrArray( $art.$typeArgs ); }
+    )?
+  ;
+
+typeNamedArgsList[ art ]
+  :
+    '(' { $art.$typeArgs = this.createDict(); }
+    (
+      typeNamedArg[ $art ]
+      ( ',' | <exitLoop> )
+    )*                      // TODO: really as loop?
+    ')' { this.finalizeDictOrArray( $art.$typeArgs ); }
+  ;
+
+typeNamedArg[ art ]
+  :
+    name=Id['typeparamname']
+    ':'
+    ( Number
+      { this.setTypeFacet( $art, $name, this.unsignedIntegerLiteral() ); }
+    | tok=VARIABLE/FLOATING
+      { this.setTypeFacet( $art, $name, { literal: 'string', val: $tok.keyword, location: $tok.location } ); }
+    )
+  ;
+
+cardinality[ art ] locals[ card = {} ]
+@finally{ $art.cardinality = this.attachLocation($card); }
+  :
+    '['
+    (
+      '*' { $card.targetMax = this.valueWithLocation(); }
+      ( ',' targetCardinality[ $card ] )?
+    |
+      Number   { $card.targetMax = this.unsignedIntegerLiteral(); }
+      (
+        ',' targetCardinality[ $card ]
+      |
+        targetCardinality[ $card, true ]<atAltStart>
+      )?
+    |
+      { $card.targetMax = this.valueWithLocation( '*' ); }
+    )                           // TODO: really optional?
+    ']'
+  ;
+
+targetCardinality[ card, atAlt = false ]
+  :
+    // TODO TOOL: the following action should not be executed when called
+    // <atAltStart> → we can then remove param `atAlt`
+    { if (!$atAlt) $card.sourceMax = $card.targetMax; }
+    (
+      '*'      { $card.targetMax = this.valueWithLocation(); }
+    |
+      Number   { $card.targetMax = this.unsignedIntegerLiteral(); }
+      ( <altRuleStart> )        // TODO TOOL: robust error when moved to after '('
+      (
+        '..'     { $card.targetMin = $card.targetMax; }
+        ( '*'    { $card.targetMax = this.valueWithLocation(); }
+        | Number { $card.targetMax = this.unsignedIntegerLiteral(); }
+        )
+      )?
+    )
+  ;
+
+nullabilityAndDefault[ art ]
+  :
+    nullability[ $art ]
+    ( <cond=calcOrDefaultRestriction> DEFAULT expr=expression
+      { $art.default = $expr; }
+    )?
+  |
+    <cond=calcOrDefaultRestriction> DEFAULT expr=expression
+    { $art.default = $expr; }
+    nullability[ $art ]?
+    // TODO TOOL: when `followUnion` does not contain `Id`, `RuleEnd_` does not
+    // need to induce prediction (here for `default`).
+  ;
+
+nullability[ art ]
+  :
+    NULL { this.setNullability( $art, false ); }
+  |
+    NOT NULL { this.setNullability( $art, true, this.locationOfPrevTokens( 2 ) ); }
+  ;
+
+// Queries: projections and SELECTs ---------------------------------------------
+
+queryEOF returns[ query ]
+  :
+    $query=queryExpression ';'? EOF
+  ;
+
+projectionSpec returns[ default query = {} ]
+@finally{ this.attachLocation($query); }
+  :
+    // TODO, currently just with simple ref
+    PROJECTION { $query = { op: this.valueWithLocation( 'SELECT' ) }; }
+    ON
+    // TODO: this <setCondition=afterBrace> is extremely strange... v6 forbid.
+    // Deliberately set this via action.
+    tab=fromRefWithOptAlias { this.afterBrace(); }<always>
+    { $query.from = tab; }
+    selectItemsList[ $query ]?
+    excludingClause[ $query ]?
+  ;
+
+queryExpression returns[ default expr = {} ] locals[ op, quantifier ]
+@finally{ this.attachLocation( $expr ); }
+  :
+    ( '(' queryExpression[ ...$ ] ')' { this.surroundByParens( $expr ); }
+    | $expr=selectQuery
+    )
+    (<altRuleStart>)
+    (
+      // See also `taggedIfQuery`/`queryOps` in AstBuildingParser.js
+      ( ( <prec=4> INTERSECT { $op = this.valueWithLocation(); }
+        | <prec=2> EXCEPT/MINUS { $op = this.valueWithLocation(); }
+        )
+        ( DISTINCT { $quantifier = this.valueWithLocation(); } )?
+      | <prec=2> UNION { $op = this.valueWithLocation(); }
+        ( DISTINCT/ALL { $quantifier = this.valueWithLocation(); } )?
+      )
+      query=queryExpression
+      // with same op/quantifier: make left-assoc binary to nary:
+      { if ($expr.$parens || $op.val !== $expr.op.val || $quantifier?.val !== $expr.quantifier?.val) $expr = { op, args: [$expr], quantifier }; }
+      { $quantifier = undefined; }
+      { $expr.args.push( $query ); this.attachLocation( $expr ); }
+    )*
+    ( <prec=0, postfix>
+      // TODO: the following action is a bit stupid, but compatible to ANTLR-based
+      // parser:
+      { if ($expr.$parens) { this.attachLocation( $expr ); $expr = { op: this.valueWithLocation( '$query', this.la() ), args: [ $expr ] }; } }
+      orderByLimitOffset[ $expr ]
+    )?
+  ;
+
+selectQuery returns[ default query = {} ]
+@finally{ this.attachLocation($query); }
+  :
+    SELECT { $query = { op: this.valueWithLocation( 'SELECT' ) }; }
+    (
+      FROM querySource[ $query ]
+      (
+        MIXIN '{' { $query.mixin = this.createDict(); }
+        (
+          mixinElementDef[ $query ]
+          ( ';' | <exitLoop> )
+        )*
+        '}' { this.finalizeDictOrArray( $query.mixin ); }
+        INTO
+      )?
+      ( ALL/DISTINCT { $query.quantifier = this.valueWithLocation(); } )?
+      // TODO: or directly after SELECT ?
+      selectItemsList[ $query ]?
+      excludingClause[ $query ]?
+    |
+      ( ALL/DISTINCT { $query.quantifier = this.valueWithLocation(); } )?
+      ( '*' { $query.columns = [ this.valueWithLocation() ]; }
+      | selectItemDef[ ($query.columns = []) ]
+      )
+      ( ','
+        ( '*' { $query.columns.push( this.valueWithLocation() ); }
+        | selectItemDef[ $query.columns ]
+        )
+      )*
+      FROM querySource[ $query ]
+    )
+    whereGroupByHaving[ $query ]?
+  ;
+
+querySource[ query ]
+@after { this.attachLocation($query.from); }
+  :
+    tab=tableExpression { $query.from = $tab; }
+    (
+      { const { location } = this.la();
+        $query.from = { op: { val: 'join', location }, join: { val: 'cross', location }, args: [$tab] };
+      }
+      ( ',' tab=tableExpression { $query.from.args.push( $tab ); } )+
+    )?
+  ;
+
+tableExpression returns[ default expr ] // TableOrJoin
+  :
+    ( tableOrQueryParens[ ...$ ]
+      (<altRuleStart> { $expr = this.taggedIfQuery( $expr ); } )
+    | fromRefWithOptAlias[ ...$ ]
+    )
+    (
+      join=CROSS JOIN
+      { if ($expr?.join?.val !== 'cross' || $expr.$parens) $expr = { op: this.valueWithLocation(), join: this.valueWithLocation( undefined, $join ), args: [ $expr ] }; }
+      ( tab=tableOrQueryParens { $expr.args.push( this.taggedIfQuery( $tab ) ); }
+        { this.attachLocation( $expr ); }
+      | tab=fromRefWithOptAlias { $expr.args.push( $tab ); }
+        { this.attachLocation( $expr ); }
+      )
+    |
+      ( ( join=INNER | join=LEFT/RIGHT/FULL OUTER? )
+        card=joinCardinality?
+      | { $join = undefined; }  // TODO TOOL: action is lost
+      )
+      JOIN
+      { $expr = { op: this.valueWithLocation(), join: this.valueWithLocation( $join?.keyword || 'inner', $join ), args: [ $expr ] }; if ($card) $expr.cardinality = $card; $card = undefined; }
+      { $join = undefined; }    // TODO TOOL bug workaround, see above
+      tab=tableExpression
+      { $expr.args.push( $tab ); this.attachLocation( $expr ); }
+      ON cond=condition { $expr.on = $cond; }
+      { this.attachLocation( $expr ); }
+    )*
+  ;
+
+tableOrQueryParens returns[ default expr ]
+  :
+    '('
+    ( <priority> tableOrQueryParens[ ...$ ]
+      ( <prec=-2, postfix> tableExpression[ ...$ ]<atAltStart>
+      | <prec=-1, postfix> queryExpression[ ...$ ]<atAltStart>
+      )?
+    | <prec=-2> tableExpression[ ...$ ]
+    | <prec=-1> queryExpression[ ...$ ]
+    )
+    ')'
+    { this.surroundByParens( $expr ); }
+    ( <prec=-2, postfix=once> AS Id['FromAlias']
+      <setCondition=setPrecInCallingRule>
+      { $expr = this.taggedIfQuery( $expr ); $expr.name = this.identAst(); }
+    | <hide, cond=tableAlias> Id_restricted['FromAlias']
+      <setCondition=setPrecInCallingRule>
+      { $expr = this.taggedIfQuery( $expr ); $expr.name = this.fragileAlias(); }
+    |
+      // <setCondition=setPrecInCallingRule> // TODO TOOL: allow this
+      { this.setPrecInCallingRule(); }<always> // workaround
+    )
+  ;                             // change #10799 for ANTLR-based parser
+
+joinCardinality returns[ sourceMax, targetMax ]
+@finally{ this.attachLocation( $ ); }
+  :
+    (
+      ( EXACT { $.sourceMin = this.valueWithLocation( 1 ); } )?
+      ONE { $sourceMax = this.valueWithLocation( 1 ); }
+    |
+      MANY { $sourceMax = this.valueWithLocation( '*' ); }
+    )
+    TO
+    (
+      ( EXACT { $.targetMin = this.valueWithLocation( 1 ); } )?
+      ONE { $targetMax = this.valueWithLocation( 1 ); }
+    |
+      MANY { $targetMax = this.valueWithLocation( '*' ); }
+    )
+  ;
+
+fromRefWithOptAlias returns[ default expr = { path: [] } ]
+@finally{ this.attachLocation( $expr ); }
+  :
+    fromPath[ $expr, 'artref' ]
+    (
+      ':' { if (!$expr.scope) $expr.scope = $expr.path.length; else {
+        this.warning( 'syntax-invalid-path-separator', this.lb(),
+                      { '#': 'colon', code: ':', newcode: '.' } );
+      } }
+      fromPath[ $expr, 'ref']
+    )?
+    (
+      AS Id['FromAlias'] { $expr.name = this.identAst(); }
+    |
+      <hide, cond=tableAlias>
+      Id_restricted['FromAlias']
+      { $expr.name = this.fragileAlias(); }
+    |
+      <default=fallback>
+      { this.classifyImplicitName( $expr.scope ? 'FromElemImplicit' : 'FromImplicit', $expr ); }
+    )
+  ;
+
+fromPath[ table, category ] locals[ pathItem ]
+@finally{ this.attachLocation( $table.path ); }
+  :
+    Id[ $category ] { $table.path.push( $pathItem = this.identAst() ); }
+    ( fromArgumentsAndFilter[ $pathItem ] { $pathItem = null; } )?
+    (
+      '.' { if (!$pathItem && !$table.scope) {
+        $table.scope = $table.path.length; $category = 'ref';
+        this.warning( 'syntax-invalid-path-separator', this.lb(),
+                      { '#': 'dot', code: '.', newcode: ':' } );
+      } }
+      Id_all[ $category ] { $table.path.push( $pathItem = this.identAst() ); }
+      ( fromArgumentsAndFilter[ $pathItem ] { $pathItem = null; } )?
+    )*
+  ;
+
+fromArgumentsAndFilter[ pathStep ]
+options{ minTokensMatched = 1 }
+  :
+    (
+      '(' { $pathStep.args = this.createDict(); $pathStep.$syntax = ':'; }
+      ( fromNamedArgument[ ...$ ]
+        ( ',' | <exitLoop> )
+      )+
+      ')'
+    )?
+    cardinalityAndFilter[ ...$ ]?
+  ;
+
+fromNamedArgument[ pathStep ]
+  :
+    name=Id['paramname'] ':' expr=expression
+    { this.addDef( $expr, $pathStep, 'args', 0, this.identAst( $name ) ); }
+    // TODO: or add argument directly after having parsed the name? (for CC)
+  ;
+
+cardinalityAndFilter[ pathStep ]
+  :
+    '['
+    ( <cond=beforeColon> Number // TODO: only allow `1`?
+      { $pathStep.cardinality = { targetMax: this.unsignedIntegerLiteral(), location: this.lb().location }; }
+      ':'
+    )?
+    filterClauses[ $pathStep ]
+    // TODO: why not allowing all clauses to be optional? (then inline rule `filterClauses`)
+    ']'
+  ;
+
+filterClauses[ pathStep ]
+options{ minTokensMatched = 1 }
+  :
+    ( WHERE?
+      // compare GROUP/HAVING/ORDER/LIMIT w/o prediction (reserved WHERE anyway):
+      // <restrict=Id>  // TODO TOOL: not yet supported here
+      // BTW, why? not necessary anymore…
+      cond=condition { $pathStep.where = $cond; }
+    )?
+    ( <hide>
+      { this.csnParseOnly('syntax-unexpected-sql-clause', 1, { keyword: 'group by' }); }
+      groupByClause[ $pathStep ]
+    )?
+    ( <hide> HAVING
+      { this.csnParseOnly('syntax-unexpected-sql-clause', -1, { keyword: 'having' }); }
+      cond=condition { $pathStep.having = $cond; }
+    )?
+    ( <hide>
+      { if (this.lk() === 'limit') this.csnParseOnly('syntax-unexpected-sql-clause', 0, { keyword: 'limit' } ); else this.csnParseOnly('syntax-unexpected-sql-clause', 1, { keyword: 'order by' } ); }
+      // I do not care that there is now only one error msg for both ORDER BY … LIMIT …
+      orderByLimitOffset[ $pathStep ]
+    )?
+  ;
+
+excludingClause[ query ]
+  :
+    // syntax is less than ideal - EXCLUDING is only useful for `*` - with
+    // this syntax, people wonder what happens with explicit select items
+    EXCLUDING '{' { $query.excludingDict = this.createDict(); }
+    // TODO: better move '{' to after action, but → diff to ANTLR-based parser
+    (
+      Id_all['ref']             // TODO: different category?
+      { this.addDef( { location: this.lb().location }, $query, 'excludingDict', '', this.identAst() ); }
+      ( ',' | <exitLoop> )
+    )+
+    '}'<setCondition=afterBrace>
+    { this.finalizeDictOrArray( $query.excludingDict ); }
+  ;
+
+selectItemsList[ query, start = undefined ]
+  :
+    '{'<setCondition=notInExpandInline>
+    { $query.columns = this.createArray( $start ); }
+    (
+      ( '*' { $query.columns.push( this.valueWithLocation() ); }
+      | selectItemDef[ $query.columns ]
+      )
+      ( ',' | <exitLoop> )
+    )*
+    '}'<setCondition=afterBrace>
+    { this.finalizeDictOrArray( $query.columns ); }
+  ;
+
+nestedSelectItemsList[ query, clause ]
+  :
+    '{'<setCondition=inExpandInline>
+    { $query[$clause] = this.createArray(); }
+    (
+      ( '*' { $query[$clause].push( this.valueWithLocation() ); }
+      | selectItemDef[ $query[$clause] ]
+      )
+      ( ',' | <exitLoop> )
+    )*
+    '}'<setCondition=afterBrace>
+    { this.finalizeDictOrArray( $query[$clause] ); }
+  ;
+
+selectItemDef[ columns ] locals[ art = new XsnArtifact(), alias ]
+@finally{ this.attachLocation( $art ); }
+  :
+    { $columns.push( $art ); }  // TODO: probably too early
+    { this.docComment( $art ); } annoAssignCol[ $art ]*
+    ( <cond=notInExpandInline> VIRTUAL
+      { $art.virtual = this.valueWithLocation( true ); } )?
+    ( <cond=notInExpandInline> KEY
+      { $art.key = this.valueWithLocation( true ); } )?
+    (
+      expr=expression { $art.value = $expr; }
+      ( as=AS Id['ItemAlias'] { $art.name = this.identAst(); }
+      | Id_restricted['ItemAlias'] { $art.name = this.fragileAlias( true ); }
+      | { $alias = this.classifyImplicitName( 'ItemImplicit', $expr ); }
+      )
+      // TODO: <cond> instead `reportExpandInline` for "expand/inline only w/ ref"
+      (
+        { this.reportExpandInline( $art, false ); }
+        nestedSelectItemsList[ $art, 'expand' ]
+        excludingClause[ $art ]?
+      |
+        '.'
+        { this.reportExpandInline( $art, $as || true ); }
+        { if ($alias) $alias.token.parsedAs = $alias.parsedAs; }
+        (
+          nestedSelectItemsList[ $art, 'inline' ]
+          excludingClause[ $art ]?
+        |
+          '*' { $art.inline = [ this.valueWithLocation() ]; }
+        )
+      )?
+    |
+      nestedSelectItemsList[ $art, 'expand' ]
+      excludingClause[ $art ]?
+      AS Id['ItemAlias'] { $art.name = this.identAst(); }
+    )
+    { this.docComment( $art ); } annoAssignMid[ $art ]*
+    (
+      ':'
+      (
+        ( typeTypeOf[ $art ]
+        | ( LOCALIZED { $art.localized = this.valueWithLocation( true ); } )?
+          typeRefOptArgs[ $art ]
+        )
+      |
+        REDIRECTED TO target=simplePath { $art.target = $target; }
+        ( ON cond=condition { $art.on = $cond; }
+        | foreignKeysBlock[ $art ]
+        )?
+      |
+        // TODO: condition for this
+        ( assoc=ASSOCIATION { this.associationInSelectItem( $art ); }
+          cardinality[ $art ]? TO
+        | assoc=COMPOSITION { this.associationInSelectItem( $art ); }
+          cardinality[ $art ]? OF
+        )
+        // { this.classifyImplicitName( 'ItemAssoc', $art.value ); } TODO: do we need this?
+        card=ONE/MANY? target=simplePath
+        { this.setAssocAndComposition( $art, $assoc, $card, $target ); }
+        ON expr=condition { $art.on = $expr; }
+      )
+      // TODO: no nullability here ?
+      { this.docComment( $art ); } annoAssignStd[ $art ]*
+    )?
+  ;
+
+whereGroupByHaving[ query ]
+options{ minTokensMatched = 1 }
+  :
+    ( WHERE cond=condition { $query.where = $cond; } )?
+    groupByClause[ ...$ ]?
+    ( HAVING cond=condition { $query.having = $cond; } )?
+  ;
+
+groupByClause[ query ]
+  :
+    GROUP BY expr=expression { $query.groupBy = [ $expr ]; }
+    ( ',' expr=expression { $query.groupBy.push( $expr ); } )*
+  ;
+
+orderByLimitOffset[ query ]
+options{ minTokensMatched = 1 }
+  :
+    orderByClause[ ...$ ]?
+    ( LIMIT expr=expression { $query.limit = { rows: $expr }; }
+      ( OFFSET expr=expression { $query.limit.offset = $expr; } )?
+    )?
+  ;
+
+orderByClause[ query ]
+  :
+    ORDER BY expr=orderByExpression { $query.orderBy = [ $expr ]; }
+    ( ',' expr=orderByExpression { $query.orderBy.push( $expr ); } )*
+  ;
+
+orderByExpression returns[ default expr ]
+  :
+    expression[ ...$ ]
+    ( ASC/DESC { $expr.sort = this.valueWithLocation(); } )?
+    ( NULLS FIRST/LAST { $expr.nulls = this.valueWithLocation(); } )?
+  ;
+
+// Conditions and expressions ---------------------------------------------------
+
+conditionEOF returns[ cond ]
+  :
+    $cond=expression EOF
+  ;
+
+condition returns[ default expr ]
+  :
+    expression[ ...$ ]
+  ;
+
+// TODO TOOL: sort rules if a rule with <altRuleStart> uses rule with <altRuleStart>
+// at least issue error if no user-sorted
+valuePath returns[ default expr = { path: [] } ] locals[ pathItem ]
+@finally{ this.attachLocation( $expr ); }
+  :
+    Id['ref'] { $expr.path.push( $pathItem = this.identAst() ); }
+    ( argumentsAndFilter[ $pathItem ] )?
+    (<altRuleStart>)
+    (
+      <cond=isDotForPath> '.'
+      Id_all['ref'] { $expr.path.push( $pathItem = this.identAst() ); }
+      ( argumentsAndFilter[ $pathItem ] { $pathItem = null; } )?
+    )*
+  ;
+
+// TODO: ? params
+expression returns[ default expr ]
+//@finally{ if (!$expr?.$parens) this.attachLocation( $expr ); }
+  :
+    (
+      expressionOrQueryParens[ ...$ ]
+      (<altRuleStart> { $expr = this.taggedIfQuery( $expr ); })
+    |
+      literalValue[ ...$ ]
+    |
+      ':' { this.reportUnexpectedSpace(); }
+      (
+        Id_all['paramref']
+        { $expr = { path: [ this.identAst() ], location: this.startLocation(), scope: 'param' }; }
+        ( valuePath[ ...$ ]<atAltStart>
+          { $expr = this.valuePathAst( $expr ); }
+        | { this.attachLocation( $expr ); }
+        )
+      |
+        <hide> Number           // TODO: as user condition
+        { this.csnParseOnly( 'syntax-unsupported-param', -1, { '#': 'positional', code: ':' + this.lb().text } ); }
+        { $expr = this.attachLocation({ param: this.unsignedIntegerLiteral(), scope: 'param' }); }
+      )
+    |
+      <hide> '?'              // TODO: do as user condition
+      {this.csnParseOnly( 'syntax-unsupported-param', -1, { '#': 'dynamic', code: '?' } );
+      }
+      { $expr = this.attachLocation({ param: this.valueWithLocation(), scope: 'param' }); }
+    |
+      e=valuePath { $expr = this.valuePathAst( $e ); }
+      (
+        OVER { this.pushXprToken( $expr.suffix = [] ); }
+        e=overClause[ $expr.suffix ]
+      )?
+      { this.attachLocation( $expr ); }
+    |
+      newAndValuePath[ ...$ ]
+    |
+      EXISTS { $expr = this.applyOpToken(); }
+      ( open='(' e=queryExpression ')'
+        { $expr.args.push( this.taggedIfQuery( this.surroundByParens( $e, $open ) ) ); }
+        { this.attachLocation( $expr ); }
+      | e=valuePath { $e = this.valuePathAst( $e ); $e.$expected = 'exists'; }
+        // TODO: re-check whether to really set $expected in parser
+        { $expr.args.push( $e ); this.attachLocation( $expr ); }
+      | <hide> '?'              // TODO: do as user condition
+        {this.csnParseOnly( 'syntax-unsupported-param', -1, { '#': 'dynamic', code: '?' } ); }
+        { $expr.args.push( { param: this.valueWithLocation(), scope: 'param' } ); this.attachLocation( $expr ); }
+      )
+    |
+      caseExpression[ ...$ ]
+    |
+      castFunction[ ...$ ]
+    |
+      ( <prec=30, prefix> '+'/'-' { $expr = this.applyOpToken(); }
+      | <prec=8, prefix>  NOT     { $expr = this.applyOpToken(); }
+      )
+      e=expression { $expr = this.signedExpression( $expr, $e ); }
+    )
+    // binary + postfix
+    ( (
+        ( <prec=24> '*'/'/' { $expr = this.applyOpToken( $expr, 'nary' ); }
+        | <prec=22> '+'/'-' { $expr = this.applyOpToken( $expr, 'nary' ); }
+        | <prec=20> '||'    { $expr = this.applyOpToken( $expr, 'nary' ); }
+        | <prec=4> AND      { $expr = this.applyOpToken( $expr, 'nary' ); }
+        | <prec=2> OR       { $expr = this.applyOpToken( $expr, 'nary' ); }
+        | <prec=0> '?'      { $expr = this.applyOpToken( $expr, '?:' ); }
+          e=expression { $expr.args.push( $e ); }
+          ':' { this.pushXprToken( $expr ); }
+          // -> createXprForOp vs createAstForOp
+
+        | <prec=10, assoc=none> '='/'<>'/'>'/'>='/'<'/'<='/'!='
+          { $expr = this.applyOpToken( $expr ); }
+          ( ANY/SOME/ALL { this.pushXprToken( $expr ); } )?
+        )
+        e=expression { $expr.args.push( $e ); }
+
+      | <prec=10, postfix=once> IS { $expr = this.applyOpToken( $expr ); }
+        ( NOT { this.pushXprToken( $expr ); } )?
+        NULL { this.pushXprToken( $expr ); }
+      | ( <cond=isNegatedRelation> NOT { $expr = this.applyOpToken( $expr ); }
+          // TODO: condition, because there might be NOT NULL after DEFAULT expression
+        | <prec=10, postfix=once>
+          { $expr = { op: { val: 'ixpr', location: this.la().location }, args: [ $expr ] }; }
+        )
+        (
+          BETWEEN { this.pushXprToken( $expr ); }
+          e=expression { $expr.args?.push( $e ); }
+          AND { this.pushXprToken( $expr ); }
+          e=expression { $expr.args?.push( $e ); }
+        | IN { this.pushXprToken( $expr ); }
+          e=expression { $expr.args?.push( this.secureParens( $e ) ); }
+        | LIKE { this.pushXprToken( $expr ); }
+          e=expression { $expr.args?.push( $e ); }
+          ( ESCAPE { this.pushXprToken( $expr ); }
+            e=expression { $expr.args?.push( $e ); }
+          )?
+        )
+      )
+      { this.attachLocation( $expr ); }
+    )*
+  ;
+
+expressionOrQueryParens returns[ default expr ]
+  :
+    '('
+    ( <priority> expressionOrQueryParens[ ...$ ]
+      ( <prec=-2, postfix> expression[ ...$ ]<atAltStart>
+        continueExpressionslist[ ...$ ]?
+      | <prec=-2, postfix>
+        continueExpressionslist[ ...$ ]
+      | <prec=-1, postfix> queryExpression[ ...$ ]<atAltStart>
+      )?
+    | <prec=-2> expression[ ...$ ]
+      continueExpressionslist[ ...$ ]?
+    | <prec=-1> queryExpression[ ...$ ]
+    )
+    ')' <setCondition=setPrecInCallingRule>
+    { this.surroundByParens( $expr ); }
+  ;
+
+continueExpressionslist[ expr ]
+@finally{ this.attachLocation( $expr ); }
+  :
+    ',' { $expr = { op: this.valueWithLocation( 'list' ), args: [ $expr ], location: { ... $expr.$parens?.at( -1 ) ?? $expr.location } }; }
+    (
+      e=expression { $expr.args.push( $e ); }
+      ( ',' | <exitLoop> )
+    )+
+    { this.attachLocation( $expr ); }
+  ;
+
+newAndValuePath returns[ default expr ]
+@finally{ this.attachLocation( $expr ); }
+  :
+    NEW { $expr = this.applyOpToken(); }
+    e=valuePath { $e = this.valuePathAst( $e ); }
+    { if ($e.op?.val !== 'ixpr') $expr.args.push( $e ); else $expr.args.push( ...e.args ); }
+  ;
+
+caseExpression returns[ default expr = { op: { val: 'ixpr' }, args: [] } ]
+@finally{ this.attachLocation( $expr ); }
+  :
+    CASE { this.pushXprToken( $expr ); $expr.op.location = $expr.args[0].location; }
+    ( e=expression { $expr.args.push( $e ); } )?
+    (
+      WHEN { this.pushXprToken( $expr ); }
+      e=expression { $expr.args.push( $e ); }
+      THEN { this.pushXprToken( $expr ); }
+      e=expression { $expr.args.push( $e ); }
+    )+
+    (
+      ELSE { this.pushXprToken( $expr ); }
+      e=expression { $expr.args.push( $e ); }
+    )?
+    END { this.pushXprToken( $expr ); }
+  ;
+
+castFunction returns[ default expr = {} ]
+@finally{ this.attachLocation( $expr ); }
+  :
+    CAST { $expr.op = this.valueWithLocation(); }
+    '(' { $expr.args = this.createArray(); }
+    arg=expression { $expr.args?.push( $arg ); }
+    AS typeRefOptArgs[ $expr ]
+    ')' { this.finalizeDictOrArray( $expr.args ); }
+  ;
+
+argumentsAndFilter[ pathStep ]
+// TODO: what about valuePath with EXISTS, after `:` etc (also in ANTLR-based parser)?
+options{ minTokensMatched = 1 }
+  :
+    (
+      open='(' <setCondition=prepareSpecialFunction>
+      { $pathStep.args = this.createArray(); }
+      // action here, default action won't be executed with failed condition (TODO
+      // TOOL? at least msg)
+      (
+        <default=fallback>      // TODO TOOL: allow in loop
+        (
+          expr=funcExpression { $pathStep.args.push( $expr ); }
+          (
+            ','<setCondition=nextFunctionArgument>
+            ( expr=funcExpression { $pathStep.args.push( $expr ); }
+            | <exitLoop>          // <cond>: only before `)`
+            )
+          )*
+          (   // ORDER BY in generic functions, e.g. `first_value(id order by name)`
+            ORDER { $expr = $pathStep.args[$pathStep.args.length - 1] = this.applyOpToken( $expr ); }
+            BY { this.pushXprToken( $expr ); }
+            orderByClauseAsXpr[ $expr.args ]
+            { this.attachLocation( $expr ); }
+          )?
+        )?
+      |
+        // TODO: if we want perfect CC and error recovery, `isNamedArg` would work
+        // like keyword prediction and also do something similar to the (future)
+        // "identifier confirmation prediction" (consider argument `(par ‡ : 42)`
+        <cond=isNamedArg> id=Id_all['paramname']
+        (
+          ':' { $pathStep.args = this.createDict( $open ); $pathStep.$syntax = ':'; }
+          expr=expression { this.addNamedArg( $pathStep, $id, $expr ); }
+          ( ','
+            ( id=Id_all['paramname'] ':'
+              expr=expression { this.addNamedArg( $pathStep, $id, $expr ); }
+            | <exitLoop>
+            )
+          )*
+        |
+          '=>' { $pathStep.args = this.createDict(); }
+          // TODO: potentially special expressions for special functions
+          expr=expression { this.addNamedArg( $pathStep, $id, $expr ); }
+          ( ','
+            ( id=Id_all['paramname'] '=>'
+              expr=expression { this.addNamedArg( $pathStep, $id, $expr ); }
+            | <exitLoop>
+            )
+          )*
+        )
+      )
+      ')'
+    )?
+     // TODO: not with function!
+    cardinalityAndFilter[ ...$ ]?
+  ;
+
+funcExpression returns[ default expr ] locals[ args ]
+@finally{ this.attachLocation( $expr ); }
+  :
+    ( options{ lookahead = lGenericIntroOrExpr; }
+    :
+      $expr=expression
+    |
+      tok=GenericExpr               // keyword as replacement for expression, like '*'
+      { $expr = { val: $tok.keyword ?? $tok.type, location: $tok.location, literal: 'token' }; }
+    |
+      GenericIntro      // keyword as introduction of expression, like DISTINCT
+      { $expr = this.applyOpToken(); $args = $expr.args; }
+      e=expression { $expr.args.push( $e ); }
+    )
+    ( options{ lookahead = lGenericSeparator; }
+    :
+      GenericSeparator
+      { if ($args) this.pushXprToken( $args ); else { $expr= this.applyOpToken( $expr ); $args = $expr.args; } }
+
+      ( options{ lookahead = lGenericExpr; }
+      :
+        e=expression { $args.push( $e ); }
+      |
+        GenericExpr { this.pushXprToken( $args ); }
+      )
+    )*
+  ;
+
+GenericExpr
+  : Id_all | '*' ;
+GenericIntro
+  : Id_all ;
+GenericSeparator
+  : Id_all ;
+
+overClause[ outer ] locals[ over = [] ]
+@finally{ $outer.push( this.surroundByParens( this.ixprAst( $over ) ) ); }
+  :
+    '('
+    ( PARTITION { this.pushXprToken( $over ); } BY { this.pushXprToken( $over ); }
+      expressionsAsXpr[ $over ]
+    )?
+    ( ORDER { this.pushXprToken( $over ); } BY { this.pushXprToken( $over ); }
+      orderByClauseAsXpr[ $over ]
+    )?
+    ( ROWS { this.pushXprToken( $over ); }
+      windowFrameClause[ $over ]
+    )?
+    ')'
+  ;
+
+expressionsAsXpr[ outer ] locals[ args = [] ]
+@finally{ $outer.push( this.ixprAst( $args ) ); }
+  :
+    expr=expression { $args.push( $expr ); }
+    ( ',' { this.pushXprToken( $args ); }
+      expr=expression { $args.push( $expr ); }
+    )*
+  ;
+
+orderByClauseAsXpr[ outer ] locals[ args = [] ]
+@finally{ $outer.push( this.ixprAst( $args ) ); }
+  :
+    orderBySpecAsXpr[ $args ]
+    ( ',' { this.pushXprToken( $args ); }
+      orderBySpecAsXpr[ $args ]
+    )*
+  ;
+
+orderBySpecAsXpr[ args ]
+  :
+    expr=expression { $args.push( $expr ); }
+    ( ASC/DESC { this.pushXprToken( $args ); } )?
+    ( NULLS { this.pushXprToken( $args ); }
+      FIRST/LAST { this.pushXprToken( $args ); }
+    )?
+  ;
+
+windowFrameClause[ outer ] locals[ args = [] ]
+@finally{ $outer.push( this.ixprAst( $args ) ); }
+  :
+    ( UNBOUNDED { this.pushXprToken( $args ); }
+    | Number { $args.push( this.unsignedIntegerLiteral() ); }
+    )
+    PRECEDING { this.pushXprToken( $args ); }
+  |
+    CURRENT { this.pushXprToken( $args ); }
+    ROW { this.pushXprToken( $args ); }
+  |
+    BETWEEN { this.pushXprToken( $args ); }
+    windowFrameBoundSpec[ $args ]
+    AND { this.pushXprToken( $args ); }
+    windowFrameBoundSpec[ $args ]
+  ;
+
+windowFrameBoundSpec[ args ]
+  :
+    ( UNBOUNDED { this.pushXprToken( $args ); }
+    | Number { $args.push( this.unsignedIntegerLiteral() ); }
+    )
+    ( FOLLOWING | PRECEDING ) { this.pushXprToken( $args ); }
+  |
+    CURRENT { this.pushXprToken( $args ); }
+    ROW { this.pushXprToken( $args ); }
+  ;
+
+literalValue returns[ default expr = {} ]
+@finally{ this.attachLocation( $expr ); }
+  :
+   // TODO: remove from this rule (not in enum! `String enum { foo = #bar }`) ?
+    '#' { this.reportUnexpectedSpace(); }
+    Id['enumref']
+    { $expr = { literal: 'enum', sym: this.identAst() } }
+  |
+    NULL
+    { $expr = { literal: 'null', val: null }; }
+  |
+    TRUE/FALSE
+    { $expr = { literal: 'boolean', val: this.lb().keyword === 'true' }; }
+  |
+    Number
+    { $expr = this.numberLiteral(); } // allow float and large number
+  |
+    String
+    { $expr = this.quotedLiteral(); }
+  |
+    QuotedLiteral               // x'12', date'...', time'...', timestamp'...'
+    { $expr = this.quotedLiteral(); }
+  ;
+
+// Annotation assignments -------------------------------------------------------
+
+// We have three versions of the annotation assignment rules:
+//  - "…Std": typically before keyword+name, after a name if no ':' could follow
+//  - "…Col": at the beginning of a column def, which can start with ':' or '#'
+//  - "…Mid": typically after a name if a ':' could follow
+
+annoAssignStd[ art ]
+@finally{ this.docComment( $art ); }
+  :
+    '@'<setCondition=annoInSameLine> { this.reportUnexpectedSpace(); }
+    ( annoAssignParen[ ...$ ]
+    | annoAssignBase[ ...$ ]
+    )
+  ;
+
+annoAssignCol[ art ]
+@finally{ this.docComment( $art ); }
+  :
+    '@' { this.reportUnexpectedSpace(); }
+    ( annoAssignParen[ ...$ ]
+    | annoAssignBase[ ...$ ]
+    )
+  ;
+
+annoAssignMid[ art ]
+@finally{ this.docComment( $art ); }
+  :
+    '@'<setCondition=annoInSameLine> { this.reportUnexpectedSpace(); }
+    ( annoAssignParen[ ...$ ]
+    | name=annoNamePath         // !
+      { this.assignAnnotation( $art, {}, $name ); this.warnIfColonFollows( $name ); }
+    )
+  ;
+
+annoAssignParen[ art ]
+  :
+    '('<setCondition=annoInSameLine>
+    ( annoAssignBase[ $art ]
+      ( ',' | <exitLoop> )
+    )*
+    ')'
+  ;
+
+annoAssignBase[ art ] locals[ value = {} ]
+@finally{ this.assignAnnotation( $art, $value, $name || {} ); }
+  :
+    name=annoNamePath
+    ( <cond=annoInSameLine> ':' value=annoValue )?
+  ;
+
+annoNamePath[ category = 'anno' ] returns[ default name = new XsnName() ]
+@finally{ this.attachLocation( $name ); }
+  :
+    Id_all[ $category ]
+    { $name.path = [ this.identAst() ]; }
+    (
+      '.'
+      ( Id_all[ $category ] { $name.path.push( this.identAst() ); }
+      | at='@'                  // TODO: complain about spaces after?
+        Id_all[ $category ] { $name.path.push( this.identAstWithPrefix( $at ) ); }
+      )
+    )*
+    ( <cond=annoInSameLine> annoPathVariant[ $name ] )?
+  ;
+
+annoPath[ nameOrRef, category = 'annoref' ]
+@finally{ this.attachLocation( $nameOrRef ); }
+  :
+    ( Id_all[ $category ] { $nameOrRef.path = [ this.identAst() ]; }
+    | at='@'                  // TODO: complain about spaces after?
+      Id_all[ $category ] { $nameOrRef.path = [ this.identAstWithPrefix( $at ) ]; }
+    )
+    (
+      '.'
+      ( Id_all[ $category ] { $nameOrRef.path.push( this.identAst() ); }
+      | at='@'                  // TODO: complain about spaces after?
+        Id_all[ $category ] { $nameOrRef.path.push( this.identAstWithPrefix( $at ) ); }
+      )
+    )*
+    annoPathVariant[ $nameOrRef ]?
+  ;
+
+annoPathVariant[ nameOrRef ]
+@finally{ this.attachLocation( $nameOrRef.variant ); }
+  :
+    '#' { this.reportUnexpectedSpace(); }
+    Id_all['variant'] { $nameOrRef.variant = { path: [ this.identAst() ] }; }
+    (
+      '.' Id_all['variant'] { $nameOrRef.variant.path.push( this.identAst() ); }
+    )*
+  ;
+
+annoStructValue returns[ default value = {} ] locals[ name = new XsnName()  ]
+@finally{ $value.name = $name; }
+  :
+    annoPath[ $name, 'name' ] { this.attachLocation( $name ); }
+    ( ':'
+      $value=annoValue
+    |
+      { this.attachLocation( $value ); }
+    )
+  ;
+
+annoValue returns[ default value = {} ]
+@finally{ this.attachLocation( $value ); }
+  :
+    $value=literalValue { this.adjustAnnoNumber( $value ); }
+  |
+    sign='+'/'-' Number
+    { this.adjustAnnoNumber( $value = this.numberLiteral( $sign ) ); }
+  |
+    annoPath[ $value, 'annoref' ]
+  |
+    '{'
+    {
+      if (!this.dynamic_.arrayAnno) $value.$flatten = [];
+      else { $value.struct = Object.create(null); $value.literal = 'struct'; }
+    }
+    (
+      // TODO: complain about empty loop if top-level as before
+      // TOOL TODO → allow `<cond=…> '}'` below where the condition rejects `}`
+      // after `{` if top-level
+      sub=annoStructValue
+      {
+        if ($value.$flatten) $value.$flatten.push( $sub );
+        else this.addDef( $sub, $value, 'struct', null, $sub.name );
+      }
+      ( ',' | <exitLoop> )
+    )*
+    '}'                         // Do NOT use <setCondition=afterBrace> here!
+  |
+    '['<setCondition=ellipsisRestriction>
+    { $value.val = []; $value.literal = 'array' }
+    // no need for createArray() here, $value.location is set above
+    (
+      ( sub=annoValue { $value.val.push( $sub ) }
+      |
+        <cond=ellipsisRestriction> ellipsis='...'
+        ( UP TO upTo=annoValue | { $upTo = undefined; } )
+        { $value.val.push( { literal: 'token', val: '...', location: $ellipsis.location, upTo: $upTo } ); }
+      )
+      ( ',' | <exitLoop> )
+    )*
+    ']'
+  |
+    '(' $value=condition ')' { $value.$tokenTexts = this.ruleTokensText(); }
+    // TODO: (1,2,3) not supported, yet, only ((1,2,3))
+  ;
+
+// Shorten tokens array in this.gr() calls in top-level rules by reducing
+// intersection follow set:
+ignoredRule
+options{ excludeRuleFrom = Parser }
+  :
+    usingDeclaration ';'
+    artifactDefOrExtend ';'
+  ;
+