@sap/cds-compiler 5.3.0 → 5.4.0

package/lib/parsers/CdlGrammar.g4

@@ -44,22 +44,22 @@ start returns[ source = new XsnSource( 'cdl' ) ]
     (
       ( <cond=namespaceRestriction> namespaceDeclaration[ $source ]
       | usingDeclaration[ $source ]
-      | artifactDefOrExtend[ $source ] <setCondition=namespaceRestriction>
+      | artifactDefOrExtend[ $source ] <prepare=namespaceRestriction>
       )
-      ( ';' | <exitLoop> | <repeatLoop=afterBrace> { this.noAssignmentInSameLine(); } )
+      ( ';' | <exitLoop> | <repeatLoop, cond=afterBrace> { this.noAssignmentInSameLine(); } )
     )*
     EOF { this.docComment( null ); }
   ;
 
 artifactsBlock[ art, start = undefined ]
   :
-    '{'<setCondition=vocabularyRestriction>
+    '{'<prepare=vocabularyRestriction>
     { $art.artifacts = this.createDict( $start ); $art.extensions = []; }
     (
       artifactDefOrExtend[ $art ]
-      ( ';' | <exitLoop> | <repeatLoop=afterBrace> { this.noAssignmentInSameLine(); } )
+      ( ';' | <exitLoop> | <repeatLoop, cond=afterBrace> { this.noAssignmentInSameLine(); } )
     )*
-    '}'<setCondition=afterBrace>
+    '}'<prepare=afterBrace>
     { this.finalizeDictOrArray( $art.artifacts ); }
   ;
 
@@ -125,7 +125,7 @@ usingDeclaration[ source ] locals[ decl = { kind: 'using' } ] // TODO: XsnArtifa
       ( usingProxy[ $decl, { kind: 'using' } ]
         ( ',' | <exitLoop> )
       )+
-      '}'<setCondition=afterBrace>
+      '}'<prepare=afterBrace>
       { this.finalizeDictOrArray( $decl.usings ); }
       ( FROM String
         { $source.dependencies.push( $decl.fileDep = this.quotedLiteral() ); }
@@ -186,7 +186,8 @@ annotationDef[ art, outer ]
 @finally{ this.attachLocation( $art ); }
   :
     ANNOTATION name=namePath[ 'AnnoDef' ]
-    { this.addDef( $art, $outer, 'vocabularies', 'annotation', $name ); }
+    // make it also work with ignored <cond=vocabularyRestriction>:
+    { this.addDef( $art, $outer, ($outer.kind === 'source' ? 'vocabularies' : 'artifacts'), 'annotation', $name ); }
     { this.docComment( $art ); } annoAssignMid[ $art ]*
     typeOrIncludesSpec[ $art ]
   ;
@@ -338,9 +339,9 @@ actionsBlock[ art ]
     ACTIONS { $art.actions = this.createDict(); } '{'
     (
       boundActionFunctionDef[ $art ]
-      ( ';' | <exitLoop> | <repeatLoop=afterBrace> { this.noAssignmentInSameLine(); } )
+      ( ';' | <exitLoop> | <repeatLoop, cond=afterBrace> { this.noAssignmentInSameLine(); } )
     )*
-    '}'<setCondition=afterBrace>
+    '}'<prepare=afterBrace>
     { this.finalizeDictOrArray( $art.actions ); }
   ;
 
@@ -390,9 +391,9 @@ paramDef[ outer ] locals[ art = new XsnArtifact() ]
   ;
 
 returnsSpec[ outer ] locals[ art = new XsnArtifact() ]
-@finally{ this.attachLocation( $art ); }
+@finally{ this.attachLocation( $art ); if ($ret) art.location.tokenIndex = $ret.location.tokenIndex; }
   :
-    RETURNS<setCondition=elementRestriction>
+    ret=RETURNS <prepare=elementRestriction, arg=default>
     { $art.kind = 'param'; $outer.returns = $art; }
     { this.docComment( $art ); } annoAssignStd[ $art ]*
     typeExpression[ $art ]
@@ -404,10 +405,10 @@ elementsBlock[ art ]
     ( elementDef[ $art ]
       ( ';'
       | <exitLoop>
-      | <repeatLoop=afterBrace, restrict=Id> { this.noAssignmentInSameLine(); }
+      | <repeatLoop, cond=afterBrace, restrict=Id> { this.noAssignmentInSameLine(); }
       )
     )*
-    '}'<setCondition=afterBrace>
+    '}'<prepare=afterBrace>
     { this.finalizeDictOrArray( $art.elements ); }
   ;
 
@@ -421,29 +422,27 @@ elementDef[ outer, art = undefined ]
     ( MASKED { $art.masked = this.valueWithLocation( true ); }
       { this.message( 'syntax-unsupported-masked', this.lb(), { keyword: 'masked' } ); } )?
     ( ELEMENT { $art.$syntax = 'element'; } )?
-    Id['Element']
+    Id['Element'] <prepare=elementRestriction, arg=elem>
     { 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
-    )
+      ':' typeExpression[ $art ] // was elementType, with NOT? NULL / DEFAULT
+    )?
     (
-      <cond=calcOrDefaultRestriction> '='
+      <cond=elementRestriction, arg=calc> '='
       // 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 ] )*
-    )?
+      { if (this.elementRestriction( true, 'anno' )) this.docComment( $art ); }
+      ( <cond=elementRestriction, arg=anno> annoAssignStd[ $art ] )*
+    |
+      { this.docComment( $art, 'type' ); } // delayed from type expression
+    )
   ;
 
 enumSymbolsBlock[ art ]
@@ -452,7 +451,7 @@ enumSymbolsBlock[ art ]
     ( enumSymbolDef[ $art ]
       ( ';' | <exitLoop> )
     )*
-    '}'<setCondition=afterBrace>
+    '}'<prepare=afterBrace>
     { this.finalizeDictOrArray( $art.enum ); }
   ;
 
@@ -521,17 +520,17 @@ mixinElementDef[ outer ] locals[ art = new XsnArtifact() ]
 // Annotate and Extend: main definitions ----------------------------------------
 
 annotateArtifact[ art, outer ]
-@finally{ this.attachLocation( $art ); }
+@finally{ this.checkWith( $keyword ); this.attachLocation( $art ); }
   :
     name=namePath[ 'Ext' ]
     ( // direct element annotation:
       ':' elemName=namePath[ 'ExtElement']
       { this.addExtension( $art, $outer, 'annotate', $name, $elemName.path ); }
-      WITH?
+      keyword=WITH?
       { this.docComment( $art ); } annoAssignStd[ $art ]*
       annotateElementsBlock[ $art ]?
     | // definition annotation
-      WITH?
+      keyword=WITH?
       // <cond=noRuleExitAfterWith>), or as rule option,
       // this.noSemicolonHere() had the issues: DocComment, before `}`/EOF
       { this.addExtension( $art, $outer, 'annotate', $name ); }
@@ -547,13 +546,13 @@ annotateArtifact[ art, outer ]
   ;
 
 extendArtifact[ art, outer ]
-@finally{ this.attachLocation( $art ); }
+@finally{ this.checkWith( $keyword ); this.attachLocation( $art ); }
   :
     name=namePath[ 'Ext' ]
     ( // direct element annotation:
       ':' elemName=namePath[ 'ExtElement']
       { this.addExtension( $art, $outer, 'extend', $name, $elemName.path ); }
-      WITH?
+      keyword=WITH?
       { this.docComment( $art ); } annoAssignStd[ $art ]*
       (
         elements=ELEMENTS? extendElementsBlock[ $art, $elements ]
@@ -569,7 +568,7 @@ extendArtifact[ art, outer ]
         actionsBlock[ $art ]?
       )?
     |
-      WITH
+      keyword=WITH
       { this.addExtension( $art, $outer, 'extend', $name ); }
       { this.docComment( $art ); } annoAssignStd[ $art ]*
       (
@@ -595,12 +594,12 @@ extendArtifact[ art, outer ]
   ;
 
 extendService[ art, outer ]
-@finally{ this.attachLocation( $art ); }
+@finally{ this.checkWith( $keyword ); this.attachLocation( $art ); }
   :
     SERVICE { $art.expectedKind = this.valueWithLocation(); }
     name=namePath[ 'ExtService' ]
     { $art.name = $name; $outer.extensions.push( $art ); }
-    WITH?
+    keyword=WITH?
     // <cond=noRuleExitAfterWith>), or as rule option,
     // this.noSemicolonHere() had the issues: DocComment, before `}`/EOF
     { this.docComment( $art ); } annoAssignStd[ $art ]*
@@ -608,12 +607,12 @@ extendService[ art, outer ]
   ;
 
 extendContext[ art, outer ]
-@finally{ this.attachLocation( $art ); }
+@finally{ this.checkWith( $keyword ); this.attachLocation( $art ); }
   :
     CONTEXT { $art.expectedKind = this.valueWithLocation(); }
     name=namePath[ 'ExtContext' ]
     { $art.name = $name; $outer.extensions.push( $art ); }
-    WITH?
+    keyword=WITH?
     // <cond=noRuleExitAfterWith>), or as rule option,
     // this.noSemicolonHere() had the issues: DocComment, before `}`/EOF
     { this.docComment( $art ); } annoAssignStd[ $art ]*
@@ -621,7 +620,7 @@ extendContext[ art, outer ]
   ;
 
 extendType[ art, outer ]
-@finally{ this.attachLocation( $art ); }
+@finally{ this.checkWith( $keyword ); this.attachLocation( $art ); }
   :
     TYPE { $art.expectedKind = this.valueWithLocation(); }
     name=namePath[ 'Ext' ]
@@ -630,7 +629,7 @@ extendType[ art, outer ]
       { this.docComment( $art ); } annoAssignStd[ $art ]*
       extendElementsBlock[ $art ]?
     |
-      WITH
+      keyword=WITH
       { this.docComment( $art ); } annoAssignStd[ $art ]*
       (
         incl=simplePath { $art.includes = [ $incl ]; }
@@ -647,7 +646,7 @@ extendType[ art, outer ]
   ;
 
 extendEntityOrAspect[ art, outer ]
-@finally{ this.attachLocation( $art ); }
+@finally{ this.checkWith( $keyword ); this.attachLocation( $art ); }
   :
     ASPECT/ENTITY { $art.expectedKind = this.valueWithLocation(); }
     name=namePath[ 'Ext' ]
@@ -655,7 +654,7 @@ extendEntityOrAspect[ art, outer ]
     (
       { this.docComment( $art ); } annoAssignStd[ $art ]*
     |
-      WITH
+      keyword=WITH
       { this.docComment( $art ); } annoAssignStd[ $art ]*
       (
         incl=simplePath { $art.includes = [ $incl ]; }
@@ -667,12 +666,12 @@ extendEntityOrAspect[ art, outer ]
   ;
 
 extendProjection[ art, outer ]
-@finally{ this.attachLocation( $art ); }
+@finally{ this.checkWith( $keyword ); this.attachLocation( $art ); }
   :
     PROJECTION { $art.expectedKind = this.valueWithLocation(); }
     name=namePath[ 'Ext' ]
     { $art.name = $name; $outer.extensions.push( $art ); }
-    WITH ?
+    keyword=WITH ?
     { this.docComment( $art ); } annoAssignStd[ $art ]*
     selectItemsList[ $art ]?
     actionsBlock[ $art ]?
@@ -684,9 +683,9 @@ annotateActionsBlock[ art ]
   :
     ACTIONS { $art.actions = this.createDict(); } '{'
     ( annotateBoundAction[ $art ]
-      ( ';' | <exitLoop> | <repeatLoop=afterBrace> { this.noAssignmentInSameLine(); } )
+      ( ';' | <exitLoop> | <repeatLoop, cond=afterBrace> { this.noAssignmentInSameLine(); } )
     )*
-    '}'<setCondition=afterBrace>
+    '}'<prepare=afterBrace>
     { this.finalizeExtensionsDict( $art.actions ); }
   ;
 
@@ -722,9 +721,9 @@ annotateParam[ outer ] locals[ art = new XsnArtifact() ]
   ;
 
 annotateReturns[ outer ] locals[ art = new XsnArtifact() ]
-@finally{ this.attachLocation( $art ); }
+@finally{ this.attachLocation( $art ); if ($ret) art.location.tokenIndex = $ret.location.tokenIndex; }
   :
-    RETURNS { $outer.returns = $art; $art.kind = 'annotate'; } // TODO: tokenIndex necessary?
+    ret=RETURNS { $outer.returns = $art; $art.kind = 'annotate'; }
     { this.docComment( $art ); } annoAssignStd[ $art ]*
     annotateElementsBlock[ $art ]?
   ;
@@ -735,10 +734,10 @@ annotateElementsBlock[ art ]
     ( annotateElement[ $art ]
       ( ';'
       | <exitLoop>
-      | <repeatLoop=afterBrace, restrict=Id> { this.noAssignmentInSameLine(); }
+      | <repeatLoop, cond=afterBrace, restrict=Id> { this.noAssignmentInSameLine(); }
       )
     )*
-    '}'<setCondition=afterBrace>
+    '}'<prepare=afterBrace>
     { this.finalizeExtensionsDict( $art.elements ); }
   ;
 
@@ -758,13 +757,14 @@ extendElementsBlock[ art, start = undefined ]
     ( elementDefOrExtend[ $art ]
       ( ';'
       | <exitLoop>
-      | <repeatLoop=afterBrace, restrict=Id> { this.noAssignmentInSameLine(); } )
+      | <repeatLoop, cond=afterBrace, restrict=Id> { this.noAssignmentInSameLine(); } )
     )*
-    '}'<setCondition=afterBrace>
+    '}'<prepare=afterBrace>
     { this.finalizeExtensionsDict( $art.elements ); }
   ;
 
 elementDefOrExtend[ outer ] locals[ art = new XsnArtifact() ]
+@finally{ this.checkWith( $keyword ); this.attachLocation( $art ); }
   :
     { this.docComment( $art ); } annoAssignStd[ $art ]*
     (
@@ -778,7 +778,7 @@ elementDefOrExtend[ outer ] locals[ art = new XsnArtifact() ]
         { this.docComment( $art ); } annoAssignStd[ $art ]*
         extendElementsBlock[ $art ]?
       |
-        WITH
+        keyword=WITH
         { this.docComment( $art ); } annoAssignStd[ $art ]*
         (
           elements=ELEMENTS? extendElementsBlock[ art, $elements ]
@@ -848,71 +848,84 @@ typeOrIncludesSpec[ art ]
 typeExpression[ art ]
 // TODO: really introduce <exitRule>
   :
-    elementsBlock[ $art ]
+    elementsBlock[ $art ] <prepare=elementRestriction, arg=calc>
     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 ]*
+      // TODO TOOL: with <exitRule>, we could move the following to the end
+      (
+        { this.elementRestriction( false, 'calc' ); }
+        // <prepare=elementRestriction, arg=calc>
+        { this.docComment( $art ); } annoAssignStd[ $art ]+
+      |
+        // We could still have the calc expression after this → delay
+        { this.docComment( $art, 'elem' ); }
+      )
     |
-      enumSymbolsBlock[ $art ]
-      nullabilityAndDefault[ $art ]?
+      { this.docComment( $art, 'elem' ); }
     |
-      { this.docComment( $art ); } annoAssignStd[ $art ]+
-      ( enumSymbolsBlock[ $art ]
-        // <setCondition=calcOrDefaultRestriction> // TODO TOOL: allow this
-        { this.calcOrDefaultRestriction(); }<always> // workaround
+      { this.docComment( $art ); } annoAssignStd[ $art ]+ // +!
+      ( enumSymbolsBlock[ $art ] <prepare=elementRestriction, arg=anno>
+        // TODO TOOL: written?
         nullabilityAndDefault[ $art ]?
       )?
     |
       { this.docComment( $art ); }
+      enumSymbolsBlock[ $art ] <prepare=elementRestriction, arg=anno>
+      nullabilityAndDefault[ $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 ]*
+    // TODO TOOL: with <exitRule>, we could move the following to the end
+    (
+      { this.elementRestriction( false, 'calc' ); }
+      // <prepare=elementRestriction, arg=calc>
+      { this.docComment( $art ); } annoAssignStd[ $art ]+
+    |
+      { this.docComment( $art, 'elem' ); }
+    )
   |
-    assoc=ASSOCIATION cardinality[ $art ]? TO card=ONE/MANY?
+    assoc=ASSOCIATION <prepare=elementRestriction, arg=calc>
+    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?
+      // scalar default ? - hm..., what about calc expression?
     )
+    // final anno assignments allowed also with fkeys (no auto-`;` after them):
+    // (the "TODO TOOL" code for doc/annos would also be fine)
     { this.docComment( $art ); } annoAssignStd[ $art ]*
   |
-    assoc=COMPOSITION cardinality[ $art ]? OF card=ONE/MANY?
+    assoc=COMPOSITION <prepare=elementRestriction, arg=calc>
+    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 ]?
       )
+      // final anno assignments allowed also with fkeys (no auto-`;` after them):
+      // (the "TODO TOOL" code for doc/annos would also be fine)
       { this.docComment( $art ); } annoAssignStd[ $art ]*
     |
-      { $target = {}; this.setAssocAndComposition( $art, $assoc, $card, $target ); }
+      { $target = { location: this.startLocation( this.la() ) };
+        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 }; }
+    ( ARRAY <prepare=elementRestriction, arg=calc>
+      OF  { $art.items = { location: this.locationOfPrevTokens( 2 ) }; }
+    | MANY <prepare=elementRestriction, arg=calc>
+      { $art.items = { location: this.lb().location }; }
     )
     (
       elementsBlock[ $art.items ]
@@ -921,9 +934,14 @@ typeExpression[ art ]
       ( typeRefOptArgs[ $art.items ] | typeTypeOf[ $art.items ] )
       nullability[ $art.items ]?
       ( enumSymbolsBlock[ $art.items ]
-        nullability[ $art.items ]? // TODO: only with enum
+        nullability[ $art.items ]?
       |
-        { this.docComment( $art ); } annoAssignStd[ $art ]*
+        // TODO TOOL: with <exitRule>, we could move the following to the end
+        { this.elementRestriction( false, 'calc' ); }
+        // <prepare=elementRestriction, arg=calc>
+        { this.docComment( $art ); } annoAssignStd[ $art ]+
+      |
+        { this.docComment( $art, 'elem' ); }
       )
     )
   ;
@@ -969,6 +987,7 @@ typeRefOptArgs[ art ] locals[ type = $art.type ]
           | <exitLoop>
           )
         )*                      // TODO: really as loop?
+        { this.checkTypeArgs( $art ); } // might reset $art.$typeArgs
       |
         { $art.$typeArgs = this.createDict( $open ); }
         (
@@ -976,7 +995,7 @@ typeRefOptArgs[ art ] locals[ type = $art.type ]
           ( ',' | <exitLoop> )
         )+                      // TODO: really as loop?
       )
-      ')' { this.finalizeDictOrArray( $art.$typeArgs ); }
+      ')' { if ($art.$typeArgs) this.finalizeDictOrArray( $art.$typeArgs ); }
     )?
   ;
 
@@ -1043,11 +1062,11 @@ targetCardinality[ card, atAlt = false ]
 nullabilityAndDefault[ art ]
   :
     nullability[ $art ]
-    ( <cond=calcOrDefaultRestriction> DEFAULT expr=expression
+    ( <cond=elementRestriction, arg=default> DEFAULT expr=expression
       { $art.default = $expr; }
     )?
   |
-    <cond=calcOrDefaultRestriction> DEFAULT expr=expression
+    <cond=elementRestriction, arg=default> DEFAULT expr=expression
     { $art.default = $expr; }
     nullability[ $art ]?
     // TODO TOOL: when `followUnion` does not contain `Id`, `RuleEnd_` does not
@@ -1074,9 +1093,10 @@ projectionSpec returns[ default 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>
+    tab=fromRefWithOptAlias
+    // TODO: this <prepare=afterBrace> is extremely strange... v6 forbid.
+    // Deliberately set this via action (→ interpreter will not accept this)
+    { this.afterBrace(); }<always>
     { $query.from = tab; }
     selectItemsList[ $query ]?
     excludingClause[ $query ]?
@@ -1158,7 +1178,7 @@ querySource[ query ]
     )?
   ;
 
-tableExpression returns[ default expr ] // TableOrJoin
+tableExpression returns[ default expr = {} ] // TableOrJoin
   :
     ( tableOrQueryParens[ ...$ ]
       (<altRuleStart> { $expr = this.taggedIfQuery( $expr ); } )
@@ -1174,12 +1194,11 @@ tableExpression returns[ default expr ] // TableOrJoin
       )
     |
       ( ( join=INNER | join=LEFT/RIGHT/FULL OUTER? )
-        card=joinCardinality?
-      | { $join = undefined; }  // TODO TOOL: action is lost
+        card=joinCardinality? JOIN
+      | JOIN { $join = undefined; }
       )
-      JOIN
+      // TODO TOOL: allow zero-alt in choice in outer alt → JOIN can be moved outside
       { $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; }
@@ -1189,26 +1208,22 @@ tableExpression returns[ default expr ] // TableOrJoin
 
 tableOrQueryParens returns[ default expr ]
   :
-    '('
+    '(' <prepare=queryOnLeft>
     ( <priority> tableOrQueryParens[ ...$ ]
-      ( <prec=-2, postfix> tableExpression[ ...$ ]<atAltStart>
-      | <prec=-1, postfix> queryExpression[ ...$ ]<atAltStart>
+      ( tableExpression[ ...$ ]<atAltStart, prepare=queryOnLeft, arg=table>
+      | <cond=queryOnLeft> queryExpression[ ...$ ]<atAltStart>
       )?
-    | <prec=-2> tableExpression[ ...$ ]
-    | <prec=-1> queryExpression[ ...$ ]
+    | tableExpression[ ...$ ] <prepare=queryOnLeft, arg=table>
+    | queryExpression[ ...$ ]
     )
     ')'
     { this.surroundByParens( $expr ); }
-    ( <prec=-2, postfix=once> AS Id['FromAlias']
-      <setCondition=setPrecInCallingRule>
+    ( <cond=queryOnLeft, arg=table> AS Id['FromAlias']
       { $expr = this.taggedIfQuery( $expr ); $expr.name = this.identAst(); }
-    | <hide, cond=tableAlias> Id_restricted['FromAlias']
-      <setCondition=setPrecInCallingRule>
+    | <cond=queryOnLeft, arg=tableWithoutAs> Id_restricted['FromAlias']
+      // TODO TOOL: shouldn't we have generated `default: this.giR()`?
       { $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 ]
@@ -1229,9 +1244,10 @@ joinCardinality returns[ sourceMax, targetMax ]
     )
   ;
 
-fromRefWithOptAlias returns[ default expr = { path: [] } ]
+fromRefWithOptAlias returns[ default expr = {} ]
 @finally{ this.attachLocation( $expr ); }
   :
+    { $expr.path = []; }
     fromPath[ $expr, 'artref' ]
     (
       ':' { if (!$expr.scope) $expr.scope = $expr.path.length; else {
@@ -1243,7 +1259,8 @@ fromRefWithOptAlias returns[ default expr = { path: [] } ]
     (
       AS Id['FromAlias'] { $expr.name = this.identAst(); }
     |
-      <hide, cond=tableAlias>
+      <cond=tableWithoutAs>
+      // TODO: probably not necessary, TOOL already uses `default: this.giR()`
       Id_restricted['FromAlias']
       { $expr.name = this.fragileAlias(); }
     |
@@ -1335,13 +1352,13 @@ excludingClause[ query ]
       { this.addDef( { location: this.lb().location }, $query, 'excludingDict', '', this.identAst() ); }
       ( ',' | <exitLoop> )
     )+
-    '}'<setCondition=afterBrace>
+    '}'<prepare=afterBrace>
     { this.finalizeDictOrArray( $query.excludingDict ); }
   ;
 
 selectItemsList[ query, start = undefined ]
   :
-    '{'<setCondition=notInExpandInline>
+    '{'<prepare=inSelectItem, arg=top>
     { $query.columns = this.createArray( $start ); }
     (
       ( '*' { $query.columns.push( this.valueWithLocation() ); }
@@ -1349,13 +1366,13 @@ selectItemsList[ query, start = undefined ]
       )
       ( ',' | <exitLoop> )
     )*
-    '}'<setCondition=afterBrace>
+    '}'<prepare=afterBrace>
     { this.finalizeDictOrArray( $query.columns ); }
   ;
 
 nestedSelectItemsList[ query, clause ]
   :
-    '{'<setCondition=inExpandInline>
+    '{'<prepare=inSelectItem, arg=nested>
     { $query[$clause] = this.createArray(); }
     (
       ( '*' { $query[$clause].push( this.valueWithLocation() ); }
@@ -1363,7 +1380,7 @@ nestedSelectItemsList[ query, clause ]
       )
       ( ',' | <exitLoop> )
     )*
-    '}'<setCondition=afterBrace>
+    '}'<prepare=afterBrace>
     { this.finalizeDictOrArray( $query[$clause] ); }
   ;
 
@@ -1372,9 +1389,9 @@ selectItemDef[ columns ] locals[ art = new XsnArtifact(), alias ]
   :
     { $columns.push( $art ); }  // TODO: probably too early
     { this.docComment( $art ); } annoAssignCol[ $art ]*
-    ( <cond=notInExpandInline> VIRTUAL
+    ( <cond=modifierRestriction> VIRTUAL
       { $art.virtual = this.valueWithLocation( true ); } )?
-    ( <cond=notInExpandInline> KEY
+    ( <cond=modifierRestriction> KEY
       { $art.key = this.valueWithLocation( true ); } )?
     (
       expr=expression { $art.value = $expr; }
@@ -1389,6 +1406,7 @@ selectItemDef[ columns ] locals[ art = new XsnArtifact(), alias ]
         excludingClause[ $art ]?
       |
         '.'
+        { this.reportUnexpectedSpace( this.lb(), this.la().location, true ); } // TODO: no ERR
         { this.reportExpandInline( $art, $as || true ); }
         { if ($alias) $alias.token.parsedAs = $alias.parsedAs; }
         (
@@ -1423,7 +1441,6 @@ selectItemDef[ columns ] locals[ art = new XsnArtifact(), alias ]
         | 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; }
@@ -1497,7 +1514,7 @@ valuePath returns[ default expr = { path: [] } ] locals[ pathItem ]
   ;
 
 // TODO: ? params
-expression returns[ default expr ]
+expression returns[ default expr = {} ]
 //@finally{ if (!$expr?.$parens) this.attachLocation( $expr ); }
   :
     (
@@ -1576,7 +1593,7 @@ expression returns[ default expr ]
       | <prec=10, postfix=once> IS { $expr = this.applyOpToken( $expr ); }
         ( NOT { this.pushXprToken( $expr ); } )?
         NULL { this.pushXprToken( $expr ); }
-      | ( <cond=isNegatedRelation> NOT { $expr = this.applyOpToken( $expr ); }
+      | ( <arg=10, 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 ] }; }
@@ -1601,19 +1618,18 @@ expression returns[ default expr ]
 
 expressionOrQueryParens returns[ default expr ]
   :
-    '('
+    '(' <prepare=queryOnLeft>
     ( <priority> expressionOrQueryParens[ ...$ ]
-      ( <prec=-2, postfix> expression[ ...$ ]<atAltStart>
+      ( expression[ ...$ ]<atAltStart, prepare=queryOnLeft, arg=expr>
         continueExpressionslist[ ...$ ]?
-      | <prec=-2, postfix>
-        continueExpressionslist[ ...$ ]
-      | <prec=-1, postfix> queryExpression[ ...$ ]<atAltStart>
+      | continueExpressionslist[ ...$ ] <prepare=queryOnLeft, arg=expr>
+      | <cond=queryOnLeft> queryExpression[ ...$ ]<atAltStart>
       )?
-    | <prec=-2> expression[ ...$ ]
+    | expression[ ...$ ] <prepare=queryOnLeft, arg=expr>
       continueExpressionslist[ ...$ ]?
-    | <prec=-1> queryExpression[ ...$ ]
+    | queryExpression[ ...$ ]
     )
-    ')' <setCondition=setPrecInCallingRule>
+    ')'
     { this.surroundByParens( $expr ); }
   ;
 
@@ -1636,10 +1652,10 @@ newAndValuePath returns[ default expr ]
     { if ($e.op?.val !== 'ixpr') $expr.args.push( $e ); else $expr.args.push( ...e.args ); }
   ;
 
-caseExpression returns[ default expr = { op: { val: 'ixpr' }, args: [] } ]
+caseExpression returns[ default expr ]
 @finally{ this.attachLocation( $expr ); }
   :
-    CASE { this.pushXprToken( $expr ); $expr.op.location = $expr.args[0].location; }
+    CASE { $expr.op = { val: 'ixpr', location: this.lb().location }; $expr.args = []; this.pushXprToken( $expr ); }
     ( e=expression { $expr.args.push( $e ); } )?
     (
       WHEN { this.pushXprToken( $expr ); }
@@ -1654,7 +1670,7 @@ caseExpression returns[ default expr = { op: { val: 'ixpr' }, args: [] } ]
     END { this.pushXprToken( $expr ); }
   ;
 
-castFunction returns[ default expr = {} ]
+castFunction returns[ default expr ]
 @finally{ this.attachLocation( $expr ); }
   :
     CAST { $expr.op = this.valueWithLocation(); }
@@ -1669,7 +1685,7 @@ argumentsAndFilter[ pathStep ]
 options{ minTokensMatched = 1 }
   :
     (
-      open='(' <setCondition=prepareSpecialFunction>
+      open='(' <prepare=prepareSpecialFunction>
       { $pathStep.args = this.createArray(); }
       // action here, default action won't be executed with failed condition (TODO
       // TOOL? at least msg)
@@ -1678,7 +1694,7 @@ options{ minTokensMatched = 1 }
         (
           expr=funcExpression { $pathStep.args.push( $expr ); }
           (
-            ','<setCondition=nextFunctionArgument>
+            ','<prepare=nextFunctionArgument>
             ( expr=funcExpression { $pathStep.args.push( $expr ); }
             | <exitLoop>          // <cond>: only before `)`
             )
@@ -1750,12 +1766,14 @@ funcExpression returns[ default expr ] locals[ args ]
     )*
   ;
 
+// TODO: check Id_all - necessary if generic token is a reserved word?
 GenericExpr
   : Id_all | '*' ;
 GenericIntro
   : Id_all ;
 GenericSeparator
-  : Id_all ;
+  : Id_restricted ;             // otherwise expression ops use keyword prediction
+// TODO TOOL: use `<restrict=Id> GenericSeparator` instead and back to Id_all or Id
 
 overClause[ outer ] locals[ over = [] ]
 @finally{ $outer.push( this.surroundByParens( this.ixprAst( $over ) ) ); }
@@ -1862,7 +1880,7 @@ literalValue returns[ default expr = {} ]
 annoAssignStd[ art ]
 @finally{ this.docComment( $art ); }
   :
-    '@'<setCondition=annoInSameLine> { this.reportUnexpectedSpace(); }
+    '@'<prepare=annoInSameLine> { this.reportUnexpectedSpace(); }
     ( annoAssignParen[ ...$ ]
     | annoAssignBase[ ...$ ]
     )
@@ -1880,7 +1898,7 @@ annoAssignCol[ art ]
 annoAssignMid[ art ]
 @finally{ this.docComment( $art ); }
   :
-    '@'<setCondition=annoInSameLine> { this.reportUnexpectedSpace(); }
+    '@'<prepare=annoInSameLine> { this.reportUnexpectedSpace(); }
     ( annoAssignParen[ ...$ ]
     | name=annoNamePath         // !
       { this.assignAnnotation( $art, {}, $name ); this.warnIfColonFollows( $name ); }
@@ -1889,7 +1907,7 @@ annoAssignMid[ art ]
 
 annoAssignParen[ art ]
   :
-    '('<setCondition=annoInSameLine>
+    '('<prepare=annoInSameLine>
     ( annoAssignBase[ $art ]
       ( ',' | <exitLoop> )
     )*
@@ -1982,15 +2000,17 @@ annoValue returns[ default value = {} ]
       }
       ( ',' | <exitLoop> )
     )*
-    '}'                         // Do NOT use <setCondition=afterBrace> here!
+    // ( <cond=TODO> '}' )         // TODO TOOL - workaround:
+    { this.ec( 'arrayAnno', 'orNotEmpty' ); } '}'
+    // Do NOT use <prepare=afterBrace> here!
   |
-    '['<setCondition=ellipsisRestriction>
+    '['<prepare=arrayAnno>
     { $value.val = []; $value.literal = 'array' }
     // no need for createArray() here, $value.location is set above
     (
       ( sub=annoValue { $value.val.push( $sub ) }
       |
-        <cond=ellipsisRestriction> ellipsis='...'
+        <cond=arrayAnno, arg=ellipsis> ellipsis='...'
         ( UP TO upTo=annoValue | { $upTo = undefined; } )
         { $value.val.push( { literal: 'token', val: '...', location: $ellipsis.location, upTo: $upTo } ); }
       )