@sap/cds-compiler 2.11.2 → 2.13.6

package/lib/language/language.g4

@@ -393,7 +393,7 @@ artifactDef[ outer, defOnly = false ] locals[ annos = [] ] // cannot use `parent
       | extendProjection[ $outer, this.startLocation(), $annos ]
       | extendType[ $outer, this.startLocation(), $annos ]
       | extendAspect[ $outer, this.startLocation(), $annos ]
-        // TODO: what about extendAction
+      // Streamlined Syntax
       | extendArtifact[ $outer, this.startLocation(), $annos ]
       )
     |
@@ -418,7 +418,9 @@ contextDef[ outer, loc, annos, defOnly = false ] locals[ art, name = {} ]
       this.docComment( $annos ); }
     annotationAssignment_fix[ $annos ]*
     (
-      '{' artifactDef[ $art, defOnly, true ]* '}'
+      '{' { $art.artifacts = this.createDict(); }
+      artifactDef[ $art, defOnly ]*
+      '}' { this.setDictEndLocation( $art.artifacts ); }
       optionalSemi
     |
       requiredSemi
@@ -436,9 +438,9 @@ extendContext[ outer, loc, annos ] locals[ art, name = {} ]
     { this.docComment( $annos ); }
     annotationAssignment_ll1[ $annos ]*
     (
-      '{'
-      artifactDef[ $art, $service ? 'SERVICE' : 'CONTEXT', true ]*
-      '}'
+      '{' { $art.artifacts = this.createDict(); }
+      artifactDef[ $art, $service ? 'SERVICE' : 'CONTEXT' ]*
+      '}' { this.setDictEndLocation( $art.artifacts ); }
       optionalSemi
     |
       requiredSemi
@@ -461,23 +463,35 @@ entityDef[ outer, loc, annos ] locals[ art, name = {} ]
         )*
       )?
       '{'
-      { $art.elements = Object.create(null); } // better for include and annotate
+      { $art.elements = this.createDict(); } // better for include and annotate
       elementDef[ $art ]*
-      '}'
+      '}' { this.setDictEndLocation( $art.elements ); }
       // TODO: action definitions in a specific section?
-      ( ACTIONS '{' actionFunctionDef[ $art ]* '}' )?
+      (
+        ACTIONS '{' { $art.actions = this.createDict(); }
+        actionFunctionDef[ $art ]*
+        '}' { this.setDictEndLocation( $art.actions ); }
+      )?
       optionalSemi
     |
       AS
       ( qe=queryExpression
         { $art.query = $qe.query; $art['$'+'syntax'] = 'entity' }
-        ( ACTIONS '{' actionFunctionDef[ $art ]* '}' optionalSemi
+        (
+          ACTIONS '{' { $art.actions = this.createDict(); }
+          actionFunctionDef[ $art ]*
+          '}' { this.setDictEndLocation( $art.actions ); }
+          optionalSemi
         | requiredSemi
         )
       | qp=projectionSpec
         { $art.query = $qp.query; $art['$'+'syntax'] = 'projection'; }
         projectionClauses[ $qp.query ]
-        ( ACTIONS '{' actionFunctionDef[ $art ]* '}' )?
+        (
+          ACTIONS '{' { $art.actions = this.createDict(); }
+          actionFunctionDef[ $art ]*
+          '}' { this.setDictEndLocation( $art.actions ); }
+        )?
         optionalSemi            // TODO: not fully correct without columns or excluding
       )
     )
@@ -490,7 +504,7 @@ projectionSpec returns[ query ] locals[ src ]
     // now a simplified `tableTerm`:
     {
       $src = { path: [], scope: 0 };
-      $query = { op: this.tokenLocation( $proj, undefined, 'SELECT' ), from: $src, location: this.startLocation() };
+      $query = { op: this.valueWithTokenLocation( 'SELECT', $proj ), from: $src, location: this.startLocation() };
     }
     fromPath[ $src, 'artref']
     ( ':'
@@ -522,12 +536,12 @@ excludingClause[ query ]
   :
     // syntax is less than ideal - EXCLUDING is only useful for `*` - with
     // this syntax, people wonder what happens with explicit select items
-    EXCLUDING '{'
+    EXCLUDING '{' { $query.excludingDict = this.createDict(); }
     projectionExclusion[ $query ]
     ( ',' { if (this.isStraightBefore("}")) break; } // allow ',' before '}'
       projectionExclusion[ $query ]
     )*
-    '}'
+    '}' { this.setDictEndLocation( $query.excludingDict ); }
   ;
 
 projectionExclusion[ outer ] locals[ art ]
@@ -562,13 +576,19 @@ extendEntity[ outer, loc, annos ] locals[ art, name = {} ]
 
 extendForEntity[ art ]
   :
-    '{'
+    '{' { $art.elements = this.createDict(); }
     elementDefOrExtend[ $art ]*
-    '}'
-    ( ACTIONS '{' actionFunctionDef[ $art ]* '}' )?
+    '}' { this.setDictEndLocation( $art.elements ); }
+    (
+      ACTIONS '{' { $art.actions = this.createDict(); }
+      actionFunctionDef[ $art ]*
+      '}' { this.setDictEndLocation( $art.actions ); }
+    )?
     optionalSemi
   |
-    ACTIONS '{' actionFunctionDef[ $art ]* '}'
+    ACTIONS '{' { $art.actions = this.createDict(); }
+    actionFunctionDef[ $art ]*
+    '}' { this.setDictEndLocation( $art.actions ); }
     optionalSemi
   |
     requiredSemi
@@ -594,10 +614,16 @@ extendProjection[ outer, loc, annos ] locals[ art, name = {} ]
         )*
       )?
       '}'
-      ( ACTIONS '{' actionFunctionDef[ $art ]* '}' )?
+      (
+        ACTIONS '{' { $art.actions = this.createDict(); }
+        actionFunctionDef[ $art ]*
+        '}' { this.setDictEndLocation( $art.actions ); }
+      )?
       optionalSemi
     |
-      ACTIONS '{' actionFunctionDef[ $art ]* '}'
+      ACTIONS '{' { $art.actions = this.createDict(); }
+      actionFunctionDef[ $art ]*
+      '}' { this.setDictEndLocation( $art.actions ); }
       optionalSemi
     |
       requiredSemi
@@ -702,12 +728,15 @@ aspectDef[ outer, loc, annos ] locals[ art, name = {} ]
         )*
       )?
     )?
-    '{'
-    { $art.elements = Object.create(null); } // better for include and annotate
+    '{' { $art.elements = this.createDict(); }
     ( elementDef[ $art ]* )
-    '}'
+    '}' { this.setDictEndLocation( $art.elements ); }
     // TODO: action definitions in a specific section?
-    ( ACTIONS '{' actionFunctionDef[ $art ]* '}' )?
+    (
+      ACTIONS '{' { $art.actions = this.createDict(); }
+      actionFunctionDef[ $art ]*
+      '}' { this.setDictEndLocation( $art.actions ); }
+    )?
     optionalSemi
   ;
 
@@ -758,13 +787,82 @@ annotationDef[ outer, loc, annos ] locals[ art, name = {} ]
     typeSpecSemi[ $art, $annos ] // also 'includes'...
   ;
 
-extendArtifact[ outer, loc, annos ] locals[ art, name = {} ]
-@after { this.attachLocation($art); }
+extendArtifact[ outer, loc, annos ] locals[ art, name = {}, elemName = {} ]
+@after{ /* #ATN 1 */ this.attachLocation($art); }
   :
     simplePath[ $name, 'Extend' ]
-    { $art = this.addItem( $outer, 'extensions', 'extend', $annos,
-                           { name: $name }, $loc );  }
-    extendWithOptElements[ $art, $annos ]
+    (
+      { $art = this.addItem( $outer, 'extensions', 'extend', $annos, { name: $name }, $loc );  }
+    |
+      ':'
+      simplePath[ $elemName, 'ref']
+      {{
+        const def = this.addItem( $outer, 'extensions', 'extend', null, { name: $name }, $loc );
+        $art = this.artifactForElementAnnotateOrExtend( 'extend', def, $elemName.path, $annos, $loc );
+      }}
+    )
+    (
+      { this.docComment( $annos ); }
+      annotationAssignment_ll1[ $annos ]*
+      (
+        '{' { $art.elements = this.createDict(); }
+        elementDefOrExtend[ $art ]*
+        '}' { this.setDictEndLocation( $art.elements ); }
+        optionalSemi
+      |
+        requiredSemi
+      )
+    |
+      WITH { this.noSemicolonHere(); this.docComment( $annos ); }
+      annotationAssignment_ll1[ $annos ]*
+      // #ATN: DEFINITIONS, COLUMNS, ACTIONS etc are not reserved and could be identifiers (ref).
+      (
+        includeRef[ $art ]
+        requiredSemi
+      |
+        '{' { $art.elements = this.createDict(); }
+        elementDefOrExtend[ $art ]*
+        '}' { this.setDictEndLocation( $art.elements ); }
+        optionalSemi
+      |
+        requiredSemi
+      |
+        { this.disallowElementExtension( $elemName, $outer, 'definitions' ); }
+        DEFINITIONS
+        '{' { $art.artifacts = this.createDict(); }
+        artifactDef[ $art, true ]*
+        '}' { this.setDictEndLocation( $art.artifacts ); }
+        optionalSemi
+      |
+        { this.disallowElementExtension( $elemName, $outer, 'columns' ); }
+        COLUMNS
+        '{' { $art.columns = []; }
+        (
+          selectItemDef[ $art.columns ]
+          ( ',' { if (this.isStraightBefore("}")) break; } // allow ',' before '}'
+            selectItemDef[ $art.columns ]
+          )*
+        )?
+        '}'
+        optionalSemi
+      |
+        { this.disallowElementExtension( $elemName, $outer, 'actions' ); }
+        ACTIONS '{' { $art.actions = this.createDict(); }
+        actionFunctionDef[ $art ]*
+        '}' { this.setDictEndLocation( $art.actions ); }
+        optionalSemi
+      |
+        ELEMENTS '{' { $art.elements = this.createDict(); }
+        elementDefOrExtend[ $art ]*
+        '}' { this.setDictEndLocation( $art.elements ); }
+        optionalSemi
+      |
+        ENUM '{' { $art.enum = this.createDict(); }
+        enumSymbolDef[ $art ]*
+        '}' { this.setDictEndLocation( $art.enum ); }
+        optionalSemi
+      )
+    )
   ;
 
 extendWithOptElements[ art, annos ]
@@ -775,9 +873,9 @@ extendWithOptElements[ art, annos ]
       includeRef[ $art ]
       requiredSemi
     |
-      '{'
+      '{' { $art.elements = this.createDict(); }
       elementDefOrExtend[ $art ]*
-      '}'
+      '}' { this.setDictEndLocation( $art.elements ); }
       optionalSemi
     |
       requiredSemi
@@ -786,59 +884,71 @@ extendWithOptElements[ art, annos ]
     { this.docComment( $annos ); }
     annotationAssignment_ll1[ $annos ]*
     (
-      '{'
+      '{' { $art.elements = this.createDict(); }
       elementDefOrExtend[ $art ]*
-      '}'
+      '}' { this.setDictEndLocation( $art.elements ); }
       optionalSemi
     |
       requiredSemi
     )
   ;
 
-annotateArtifact[ outer, loc, annos ] locals[ art, name = {} ]
+annotateArtifact[ outer, loc, annos ] locals[ art, name = {}, elemName = {} ]
 @after { this.attachLocation($art); }
   :
     simplePath[ $name, 'Annotate' ]
-    { $art = this.addItem( $outer, 'extensions', 'annotate', $annos, { name: $name }, $loc ); }
+    (
+      { $art = this.addItem( $outer, 'extensions', 'annotate', $annos, { name: $name }, $loc ); }
+    |
+      ':'
+      simplePath[ $elemName, 'ref']
+      {{
+        const def = this.addItem( $outer, 'extensions', 'annotate', null, { name: $name }, $loc );
+        $art = this.artifactForElementAnnotateOrExtend( 'annotate', def, $elemName.path, $annos, $loc );
+      }}
+    )
+
     ( WITH { this.noSemicolonHere(); } )?
     { this.docComment( $annos ); }
     annotationAssignment_ll1[ $annos ]*
     (
-      '{'
+      '{' { $art.elements = this.createDict(); }
       annotateElement[ $art ]*
-      '}'
+      '}' { this.setDictEndLocation( $art.elements ); }
       (
         ACTIONS
-        '{'
+        '{' { $art.actions = this.createDict(); }
         annotateAction[ $art ]*
-        '}'
+        '}' { this.setDictEndLocation( $art.actions ); }
       )?
       optionalSemi
     |
       ACTIONS
-      '{'
+      '{' { $art.actions = this.createDict(); }
       annotateAction[ $art ]*
-      '}'
+      '}' { this.setDictEndLocation( $art.actions ); }
       optionalSemi
     |
-      '('
+      '(' { $art.params = this.createDict(); }
       annotateParam[ $art ]
       ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
         annotateParam[ $art ]
       )*
-      ')'
+      ')' { this.setDictEndLocation( $art.params ); }
       (
-        RETURNS '{' { $art['$'+'syntax'] = 'returns'; }
+        RETURNS { $art['$'+'syntax'] = 'returns'; }
+        '{' { $art.elements = this.createDict(); }
         annotateElement[ $art ]*
-        '}'
+        '}' { this.setDictEndLocation( $art.elements ); }
         optionalSemi
       |
         requiredSemi
       )
     |
-      RETURNS '{' { $art['$'+'syntax'] = 'returns'; }
+      RETURNS { $art['$'+'syntax'] = 'returns'; }
+      '{' { $art.elements = this.createDict(); }
       annotateElement[ $art ]*
-      '}'
+      '}' { this.setDictEndLocation( $art.elements ); }
       optionalSemi
 
     |
@@ -856,9 +966,9 @@ annotateElement[ outer ] locals[ art, annos = [] ]
       this.docComment( $annos ); }
     annotationAssignment_ll1[ $annos ]*
     (
-      '{'
+      '{' { $art.elements = this.createDict(); }
       annotateElement[ $art ]*
-      '}'
+      '}' { this.setDictEndLocation( $art.elements ); }
       optionalSemi
     |
       requiredSemi
@@ -875,17 +985,17 @@ annotateAction [ outer ] locals [ art, annos = [] ]
       this.docComment( $annos ); }
     annotationAssignment_ll1[ $annos ]*
     (
-      '('
+      '(' { $art.params = this.createDict(); }
       annotateParam[ $art ]
       ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
         annotateParam[ $art ]
       )*
-      ')'
+      ')' { this.setDictEndLocation( $art.params ); }
     )?
     (
-      RETURNS '{'
+      RETURNS '{' { $art.elements = this.createDict(); }
       annotateElement[ $art ]*
-      '}'
+      '}' { this.setDictEndLocation( $art.elements ); }
       optionalSemi
     |
       requiredSemi
@@ -929,6 +1039,12 @@ enumSymbolDef[ outer ] locals[ art, annos = [] ]
     requiredSemi
   ;
 
+defaultValue[ art ] locals[ elem, elements = {} ]
+  :
+  // TODO: We may support structured default values here.
+  DEFAULT expr=expression { $art.default = $expr.expr; }
+  ;
+
 elementDefOrExtend[ outer ] locals[ annos = [] ]
 @after { /* #ATN 1 */ if ($ctx.art) this.attachLocation($art.art); }
 // tool complains if I test for ($art)
@@ -983,6 +1099,7 @@ mixinElementDef[ outer ] locals[ art ]
 
 misplacedAnnotations[ annos, messageId ]
   :
+    // No docComment() here
     annotationAssignment_ll1[ $annos ]+
     { if ($messageId)           // issue specified in central registry
         this.message( messageId, this.tokenLocation( $ctx.start, this.getCurrentToken() ) );
@@ -994,7 +1111,7 @@ elementDefInner[ outer, loc, annos, allowEq ] returns[ art ]
   :
     // TODO: it would be excellent to remove ELEMENT...
     // or have a special ident rule without the ELEMENT
-    // Reason: it would be good for error recover to start a major block without LL1 ambiguity
+    // Reason: it would be good for error recovery to start a major block without LL1 ambiguity
     // VIRTUAL is keyword, except if before the following tokens texts:
     { this.setLocalToken( 'VIRTUAL', 'VIRTUAL', /^[:{@=}]$/ ); }
     virtual=VIRTUAL? key=KEY?
@@ -1046,7 +1163,7 @@ elementDefInner[ outer, loc, annos, allowEq ] returns[ art ]
         )
       |
         (
-          array=ARRAY of=OF 
+          array=ARRAY of=OF
           { $art.items = { location: this.tokenLocation( $array, $of ) }; }
         | many=MANY
           { $art.items = { location: this.tokenLocation( $many ) };}
@@ -1064,10 +1181,9 @@ elementDefInner[ outer, loc, annos, allowEq ] returns[ art ]
           { this.docComment( $annos ); }
           annotationAssignment_ll1[ $annos ]*
           (
-              ENUM '{'
-              { $art.items.enum = Object.create(null); }
-              enumSymbolDef[ $art.items ]*
-            '}'
+            ENUM '{' { $art.items.enum = this.createDict(); }
+            enumSymbolDef[ $art.items ]*
+            '}' { this.setDictEndLocation( $art.items.enum ); }
             misplacedAnnotations[ $annos, 'syntax-anno-after-enum' ]?
           )?
         )
@@ -1078,7 +1194,7 @@ elementDefInner[ outer, loc, annos, allowEq ] returns[ art ]
         annotationAssignment_ll1[ $annos ]*
         requiredSemi                     // also req after foreign key spec
       |
-        l=LOCALIZED { $art.localized = this.tokenLocation( $l, undefined, true ); }
+        l=LOCALIZED { $art.localized = this.valueWithTokenLocation( true, $l ); }
         typeRefOptArgs[ $art ]
         { this.docComment( $annos ); }
         annotationAssignment_ll1[ $annos ]*
@@ -1091,13 +1207,14 @@ elementDefInner[ outer, loc, annos, allowEq ] returns[ art ]
         typeRefOptArgs[ $art ]
         { this.docComment( $annos ); }
         annotationAssignment_ll1[ $annos ]*
-        ( ENUM '{'
-            { $art.enum = Object.create(null); }
-            enumSymbolDef[ $art ]*
-          '}'
+        (
+          ENUM '{' { $art.enum = this.createDict(); }
+          enumSymbolDef[ $art ]*
+          '}' { this.setDictEndLocation( $art.enum ); }
           elementProperties[ $art ]?
           misplacedAnnotations[ $annos, 'syntax-anno-after-enum' ]?
-        | elementProperties[ $art ]
+        |
+          elementProperties[ $art ]
           { this.docComment( $annos ); }
           annotationAssignment_ll1[ $annos ]*
         )?
@@ -1146,7 +1263,7 @@ selectItemDef[ outer ] locals[ annos = [] ]
 @after{ if ($ctx.art) this.attachLocation($art.art); }
   :
     star='*'
-    { $outer.push( this.tokenLocation( $star, undefined, '*' ) ); }
+    { $outer.push( this.valueWithTokenLocation( '*', $star ) ); }
   |
     { this.docComment( $annos ); }
     annotationAssignment_atn[ $annos ]*
@@ -1156,8 +1273,8 @@ selectItemDef[ outer ] locals[ annos = [] ]
     key=KEY?
     art=selectItemDefBody[ $outer, $annos ]
     {
-      if ($virtual) $art.art.virtual = this.tokenLocation( $virtual, undefined, true );
-      if ($key) $art.art.key = this.tokenLocation( $key, undefined, true );
+      if ($virtual) $art.art.virtual = this.valueWithTokenLocation( true, $virtual );
+      if ($key) $art.art.key = this.valueWithTokenLocation( true, $key );
     }
   ;
 
@@ -1190,7 +1307,7 @@ selectItemDefBody[ outer, annos ] returns[ art = {} ]
           excludingClause[ $art ]?
         |
           star='*'
-          { $art.inline = [ this.tokenLocation( $star, undefined, '*' ) ]; }
+          { $art.inline = [ this.valueWithTokenLocation( '*', $star ) ]; }
         )
       )?
     |
@@ -1239,7 +1356,7 @@ selectItemInlineDef[ outer ] locals[ annos = [] ]
 @after{ if ($ctx.art) this.attachLocation($art.art); }
   :
     star='*'
-    { $outer.push( this.tokenLocation( $star, undefined, '*' ) ); }
+    { $outer.push( this.valueWithTokenLocation( '*', $star ) ); }
   |
     { this.docComment( $annos ); }
     annotationAssignment_atn[ $annos ]*
@@ -1248,7 +1365,7 @@ selectItemInlineDef[ outer ] locals[ annos = [] ]
 
 parameterListDef[ art ]
   :
-    '('
+    '(' { $art.params = this.createDict(); }
     // also empty param list (we might do some hacking later to allow reserved words)
     // see annotationAssignment_paren
     (
@@ -1257,7 +1374,7 @@ parameterListDef[ art ]
         parameterDef[ $art ]
       )*
     )?
-    ')'
+    ')' { this.setDictEndLocation( $art.params ); }
   ;
 
 parameterDef[ outer ] locals[ art, annos = [] ]
@@ -1270,14 +1387,14 @@ parameterDef[ outer ] locals[ art, annos = [] ]
       this.docComment( $annos ); }
     annotationAssignment_fix[ $annos ]*
     typeSpec[ $art ]
-    ( DEFAULT expr=expression { $art.default = $expr.expr; } )?
+    defaultValue[ $art ]?
     { this.docComment( $annos ); }
     annotationAssignment_ll1[ $annos ]*
   ;
 
 entityParameters[ art ]
   :
-    '('
+    '(' { $art.params = this.createDict(); }
     // also empty param list (we might do some hacking later to allow reserved words)
     // see annotationAssignment_paren
     (
@@ -1286,7 +1403,7 @@ entityParameters[ art ]
         entityParameterDef[ $art ]
       )*
     )?
-    ')'
+    ')' { this.setDictEndLocation( $art.params ); }
   ;
 
 entityParameterDef[ outer ] locals[ art, annos = [] ]
@@ -1299,31 +1416,27 @@ entityParameterDef[ outer ] locals[ art, annos = [] ]
       this.docComment( $annos ); }
     annotationAssignment_fix[ $annos ]*
     typeSpec[ $art ]
-    ( DEFAULT expr=expression { $art.default = $expr.expr; } )?
+    defaultValue[ $art ]?
+    { this.docComment( $annos ); }
+    annotationAssignment_ll1[ $annos ]*
   ;
 
 nullability[ art ]
   :
     not=NOT n1=NULL
-    { $art.notNull = this.tokenLocation($not,$n1,true); }
+    { $art.notNull = this.valueWithTokenLocation( true, $not, $n1 ); }
   |
     n2=NULL
-    { $art.notNull = this.tokenLocation($n2,undefined,false); }
+    { $art.notNull = this.valueWithTokenLocation( false, $n2 ); }
   ;
 
 elementProperties[ elem ]
   :
-    nullability[$elem]
-    (
-      DEFAULT expr=expression
-      { $elem.default = $expr.expr; }
-    )?
+    nullability[ $elem ]
+    defaultValue[ $elem ]?
   |
-    (
-      DEFAULT expr=expression
-      { $elem.default = $expr.expr; }
-    )
-    nullability[$elem]?
+    defaultValue[ $elem ]
+    nullability[ $elem ]?
   |
     eq='='
     { this.notSupportedYet( 'Calculated fields are not supported yet', $eq ); }
@@ -1374,10 +1487,10 @@ typeSpec[ art ]                 // for params
       // TODO: no LOCALIZED ?
     | typeRefOptArgs[ $art ]
       nullability[ $art ]?
-      ( ENUM '{'
-          { $art.enum = Object.create(null); }
-          enumSymbolDef[ $art ]*
-        '}'
+      (
+        ENUM '{' { $art.enum = this.createDict(); }
+        enumSymbolDef[ $art ]*
+        '}' { this.setDictEndLocation( $art.enum ); }
       )?
     )
   ;
@@ -1387,7 +1500,7 @@ returnTypeSpec[ art, annos ]
   :
     ret=RETURNS { $art.returns = { location: this.tokenLocation( $ret ), kind: 'param' }; }
     // #ATN: typeSimple can start with ARRAY or TYPE
-    ( typeStruct[ $art.returns ] 
+    ( typeStruct[ $art.returns ]
       nullability[ $art.returns ]?
     | typeArray[ $art.returns ] // nullability is set in typeArray
     | typeTypeOf[ $art.returns ]
@@ -1395,11 +1508,12 @@ returnTypeSpec[ art, annos ]
       // TODO: no LOCALIZED ?
     | typeRefOptArgs[ $art.returns ]
       nullability[ $art.returns ]?
-      ( ENUM '{'
-          { $art.returns.enum = Object.create(null); }
-          enumSymbolDef[ $art.returns ]*
-        '}'
-      | misplacedAnnotations[ $annos, 'syntax-anno-after-params' ]
+      (
+        ENUM '{' { $art.returns.enum = this.createDict(); }
+        enumSymbolDef[ $art.returns ]*
+        '}' { this.setDictEndLocation( $art.returns.enum ); }
+      |
+        misplacedAnnotations[ $annos, 'syntax-anno-after-params' ]
       )?
     )
 
@@ -1440,7 +1554,7 @@ typeSpecSemi[ art, annos ]      // with 'includes', for type and annotation defs
         { $art.items = { location: this.tokenLocation( $many ) };}
       )
       // #ATN: typeRefOptArgs can start with TYPE
-      ( typeStruct[ $art.items ] 
+      ( typeStruct[ $art.items ]
         nullability[ $art.items ]?
         optionalSemi
       | typeTypeOf[ $art.items ]
@@ -1452,21 +1566,24 @@ typeSpecSemi[ art, annos ]      // with 'includes', for type and annotation defs
         nullability[ $art.items ]?
         { this.docComment( $annos ); }
         annotationAssignment_ll1[ $annos ]*
-        ( ENUM '{'
-            { $art.items.enum = Object.create(null); }
-            enumSymbolDef[ $art.items ]*
-          '}'
-          optionalSemi 
-        | requiredSemi
+        (
+          ENUM '{' { $art.items.enum = this.createDict(); }
+          enumSymbolDef[ $art.items ]*
+          '}' { this.setDictEndLocation( $art.items.enum ); }
+          optionalSemi
+        |
+          requiredSemi
         )
       )
     |
       typeTypeOf[ $art ]
+      defaultValue[ $art ]?
       { this.docComment( $annos ); }
       annotationAssignment_ll1[ $annos ]* requiredSemi
     |
-      l=LOCALIZED { $art.localized = this.tokenLocation( $l, undefined, true ); }
+      l=LOCALIZED { $art.localized = this.valueWithTokenLocation( true, $l ); }
       typeRefOptArgs[ $art ]
+      defaultValue[ $art ]?
       { this.docComment( $annos ); }
       annotationAssignment_ll1[ $annos ]*
       requiredSemi
@@ -1497,11 +1614,19 @@ typeSpecSemi[ art, annos ]      // with 'includes', for type and annotation defs
         ')'
         { this.docComment( $annos ); }
         annotationAssignment_ll1[ $annos ]*
-        ( ENUM '{'
-            { $art.enum = Object.create(null); }
-            enumSymbolDef[ $art ]*
-          '}'
-          optionalSemi | requiredSemi
+        (
+          ENUM '{' { $art.enum = this.createDict(); }
+          enumSymbolDef[ $art ]*
+          '}' { this.setDictEndLocation( $art.enum ); }
+          (
+            optionalSemi
+          |
+            defaultValue[ $art ]
+            requiredSemi
+          )
+        |
+          defaultValue[ $art ]?
+          requiredSemi
         )
       |
         ':' // with element, e.g. `type T : E:elem enum { ... }`
@@ -1509,20 +1634,36 @@ typeSpecSemi[ art, annos ]      // with 'includes', for type and annotation defs
         simplePath[ $art.type, 'ref']
         { this.docComment( $annos ); }
         annotationAssignment_ll1[ $annos ]*
-        ( ENUM '{'
-            { $art.enum = Object.create(null); }
-            enumSymbolDef[ $art ]*
-          '}'
-          optionalSemi | requiredSemi
+        (
+          ENUM '{' { $art.enum = this.createDict(); }
+          enumSymbolDef[ $art ]*
+          '}' { this.setDictEndLocation( $art.enum ); }
+          (
+            optionalSemi
+          |
+            defaultValue[ $art ]
+            requiredSemi
+          )
+        |
+          defaultValue[ $art ]?
+          requiredSemi
         )
       |
         { this.docComment( $annos ); }
         annotationAssignment_ll1[ $annos ]*
-        ( ENUM '{'
-            { $art.enum = Object.create(null); }
-            enumSymbolDef[ $art ]*
-          '}'
-          optionalSemi | requiredSemi
+        (
+          ENUM '{' { $art.enum = this.createDict(); }
+          enumSymbolDef[ $art ]*
+          '}' { this.setDictEndLocation( $art.enum ); }
+          (
+            optionalSemi
+          |
+            defaultValue[ $art ]
+            requiredSemi
+          )
+        |
+          defaultValue[ $art ]?
+          requiredSemi
         )
       |
         // TODO: complain if used in anno def?
@@ -1539,15 +1680,17 @@ typeSpecSemi[ art, annos ]      // with 'includes', for type and annotation defs
 typeStruct[ art, attachLoc = false ]
 @after { if ($attachLoc) this.attachLocation($art); }
   :
-    { $art.elements = Object.create(null); } // we allow empty structures
-    '{' elementDef[ $art ]* '}'
+    '{' { $art.elements = this.createDict(); }
+    elementDef[ $art ]*
+    '}' { this.setDictEndLocation( $art.elements ); }
   ;
 
 typeCompoStruct[ art ]
 @after { this.attachLocation($art); }
   :
-    { $art.elements = Object.create(null); } // we allow empty structures
-    COMPOSITIONofBRACE elementDef[ $art ]* '}'
+    COMPOSITIONofBRACE { $art.elements = this.createDict(); }
+    elementDef[ $art ]*
+    '}' { this.setDictEndLocation( $art.elements ); }
   ;
 
 typeArray[ art ]
@@ -1566,10 +1709,10 @@ typeArray[ art ]
       nullability[ $art.items ]?
     | typeRefOptArgs[ $art.items ]
       nullability[ $art.items ]?
-      ( ENUM '{'
-          { $art.items.enum = Object.create(null); }
-          enumSymbolDef[ $art.items ]*
-        '}'
+      (
+        ENUM '{' { $art.items.enum = this.createDict(); }
+        enumSymbolDef[ $art.items ]*
+        '}' { this.setDictEndLocation( $art.items.enum ); }
       )?
     )
   ;
@@ -1597,7 +1740,7 @@ typeAssociationBase[ art, handleTypeCompo ] // including Composition
 typeAssociationCont[ art ]
   :
     (
-      '{'
+      '{' { $art.foreignKeys = this.createDict(); }
       { this.addDef( $art, 'foreignKeys' ); }
       (
         foreignKey[ $art ]
@@ -1605,7 +1748,7 @@ typeAssociationCont[ art ]
           foreignKey[ $art ]
         )*
       )?
-      '}'
+      '}' { this.setDictEndLocation( $art.foreignKeys ); }
     |
       ON cond=condition
       { $art.on=$cond.cond; }
@@ -1616,7 +1759,7 @@ typeAssociationElementCont[ art, annos ] // including Composition
 // optional NULL / NOT NULL for managed association only
   :
     (
-      '{'
+      '{' { $art.foreignKeys = this.createDict(); }
       { this.addDef( $art, 'foreignKeys' ); }
       (
         foreignKey[ $art ]
@@ -1624,7 +1767,7 @@ typeAssociationElementCont[ art, annos ] // including Composition
           foreignKey[ $art ]
         )*
       )?
-      '}'
+      '}' { this.setDictEndLocation( $art.foreignKeys ); }
       nullability[ $art ]?
     |
       ON cond=condition
@@ -1764,33 +1907,47 @@ orderByClause[ inQuery ] returns [ query ]
     ( ',' obn=orderBySpec  { $query.orderBy.push( $obn.ob ); } )*
   ;
 
+// Generic function ORDER BY clause, e.g. `first_value(id order by name)`
+// lhsExpr is the left expression of the ORDER BY clause.
+functionOrderByClause[ lhsExpr ] returns [ expr ]
+@after { this.attachLocation( $expr ); }
+  :
+    o=ORDER b=BY { $expr = { op: this.valueWithTokenLocation( 'orderBy', $o, $b ) , args: [ $lhsExpr ] }}
+    ob1=orderBySpec { $expr.args.push( $ob1.ob ); }
+    ( ',' obn=orderBySpec { $expr.args.push( $obn.ob ); } )*
+  ;
+
 overOrderByClause returns [ expr ]
+@after { this.attachLocation( $expr ); }
   :
-    o=ORDER b=BY { $expr = { op: this.tokenLocation($o, $b, 'orderBy' ) , args: [] }}
+    o=ORDER b=BY { $expr = { op: this.valueWithTokenLocation( 'overOrderBy', $o, $b ) , args: [] }}
     ob1=orderBySpec { $expr.args.push( $ob1.ob ); }
     ( ',' obn=orderBySpec { $expr.args.push( $obn.ob ); } )*
   ;
 
 partitionByClause returns [ expr ]
+@after { this.attachLocation( $expr ); }
   :
-    p=PARTITION b=BY { $expr = { op: this.tokenLocation($p, $b, 'partitionBy' ) , args: [] }}
+    p=PARTITION b=BY { $expr = { op: this.valueWithTokenLocation( 'partitionBy', $p, $b ) , args: [] }}
     e1=expression { $expr.args.push( $e1.expr ); }
     ( ',' en=expression { $expr.args.push( $en.expr ); } )*
   ;
 
 windowFrameClause returns [ wf ]
+@after { this.attachLocation( $wf ); }
   :
-    r=ROWS { $wf = { op: this.tokenLocation($r, null, 'rows' ) , args: [] }}
+    r=ROWS { $wf = { op: this.valueWithTokenLocation( 'rows', $r ) , args: [] }}
     wfe=windowFrameExtentSpec { $wf.args.push( $wfe.wfe ); }
   ;
 
 windowFrameExtentSpec returns[ wfe ]
+@after { this.attachLocation( $wfe ); }
   :
     { $wfe = {} }
     windowFrameStartSpec [ $wfe ]
   |
     b=BETWEEN
-    { $wfe = { op: this.tokenLocation( $b, null, 'frameBetween' ), args: [] } }
+    { $wfe = { op: this.valueWithTokenLocation( 'frameBetween', $b ), args: [] } }
     wfb1=windowFrameBoundSpec { $wfe.args.push( $wfb1.wfb ); }
     AND
     wfb2=windowFrameBoundSpec { $wfe.args.push( $wfb2.wfb ); }
@@ -1802,42 +1959,43 @@ windowFrameBoundSpec returns [ wfb ]
     // #ATN:  Not ll1 because `UNBOUNDED` could also be part of the windowFrameStartSpec
     //        `UNBOUNDED` would then be immediately followed by `PRECEDING`
     u=UNBOUNDED f=FOLLOWING
-    { $wfb = { op: this.tokenLocation($u, $f, 'unboundedFollowing' ), args: []} }
+    { $wfb = { op: this.valueWithTokenLocation( 'unboundedFollowing', $u, $f ), args: []} }
   |
     // #ATN:  Not ll1 because `Number` could also be part of the windowFrameStartSpec
     //        `Number` would then be immediately followed by `PRECEDING`
     n=Number f=FOLLOWING
-    { $wfb = { op: this.tokenLocation($n, $f, 'following' ), args: [ this.numberLiteral( $n ) ]} }
+    { $wfb = { op: this.valueWithTokenLocation( 'following', $n, $f ), args: [ this.numberLiteral( $n ) ]} }
   |
     { $wfb = {} }
     windowFrameStartSpec [ $wfb ]
   ;
 
 windowFrameStartSpec [ wf ]
+@after { this.attachLocation( $wf ); }
   :
     u=UNBOUNDED p=PRECEDING
     {
-      $wf.op = this.tokenLocation($u, $p, 'unboundedPreceding' );
+      $wf.op = this.valueWithTokenLocation( 'unboundedPreceding', $u, $p );
       $wf.args = [];
     }
   |
     n=Number p=PRECEDING
     {
-      $wf.op = this.tokenLocation($p, null, 'preceding' );
+      $wf.op = this.valueWithTokenLocation( 'preceding', $p );
       $wf.args = [ this.numberLiteral( $n ) ];
     }
-  | 
+  |
     c=CURRENT r=ROW
     {
-      $wf.op = this.tokenLocation($c, $r, 'currentRow' );
+      $wf.op = this.valueWithTokenLocation( 'currentRow', $c, $r );
       $wf.args = [];
     }
   ;
 
 overClause returns [ over ]
-@after { this.attachLocation($over); }
+@after { this.attachLocation( $over ); }
   :
-    o=OVER { $over = { op: this.tokenLocation( $o, null, 'over' ) , args: []  } }
+    o=OVER { $over = { op: this.valueWithTokenLocation( 'over', $o ) , args: []  } }
     '('
       ( pb=partitionByClause { $over.args.push( $pb.expr ); } )?
       ( ob=overOrderByClause { $over.args.push( $ob.expr ); } )?
@@ -1858,11 +2016,11 @@ limitClause[ inQuery ] returns [ query ]
 orderBySpec returns[ ob ]
   :
     e=expression { $ob = $e.expr; }
-    ( asc=ASC   { $ob.sort = this.tokenLocation( $asc, undefined, 'asc' ); }
-    | desc=DESC { $ob.sort = this.tokenLocation( $desc, undefined, 'desc' ); }
+    ( asc=ASC   { $ob.sort = this.valueWithTokenLocation( 'asc', $asc ); }
+    | desc=DESC { $ob.sort = this.valueWithTokenLocation( 'desc', $desc ); }
     )?
     ( nb=NULLS ne=( FIRST | LAST )
-      { $ob.nulls = this.tokenLocation( $nb, $ne, $ne.text.toLowerCase() ); }
+      { $ob.nulls = this.valueWithTokenLocation( $ne.text.toLowerCase(), $nb, $ne ); }
     )?
   ;
 
@@ -1885,22 +2043,23 @@ queryPrimary returns[ query = {} ]
     { $query = this.surroundByParens( $qe.query, $open, $close ); }
   |
     select=SELECT
-    { $query = { op: this.tokenLocation( $select, undefined, 'SELECT' ), location: this.startLocation() }; }
+    { $query = { op: this.valueWithTokenLocation( 'SELECT', $select ), location: this.startLocation() }; }
     (
       FROM querySource[ $query ]
       (
-        mixin=MIXIN '{'
+        mixin=MIXIN '{' { $query.mixin = this.createDict(); }
         mixinElementDef[ $query ]*
-        '}' INTO
+        '}' { this.setDictEndLocation( $query.mixin ); }
+        INTO
       )?
       ( ad=( ALL | DISTINCT )     // TODO: or directly after SELECT ?
-      { $query.quantifier = this.tokenLocation( $ad, undefined, $ad.text.toLowerCase() ); }
+      { $query.quantifier = this.valueWithTokenLocation( $ad.text.toLowerCase(), $ad ); }
       )?
       bracedSelectItemListDef[ $query ]?
       excludingClause[ $query ]?
     |
       ( ad=( ALL | DISTINCT )     // TODO: or directly after SELECT ?
-      { $query.quantifier = this.tokenLocation( $ad, undefined, $ad.text.toLowerCase() ); }
+      { $query.quantifier = this.valueWithTokenLocation( $ad.text.toLowerCase(), $ad ); }
       )?
       { $query.columns = []; }  // set it early to avoid "wildcard" errors
       selectItemDef[ $query.columns ]
@@ -1954,8 +2113,8 @@ joinOp[ left ] returns[ table ] locals [ join ]
     | t1=RIGHT t2=OUTER? c=joinCardinality? op=JOIN { $join = 'right' }
     | t1=FULL t2=OUTER? c=joinCardinality? op=JOIN { $join = 'full' }
     )
-    { $table = { op: this.tokenLocation( $op, undefined, 'join' ),
-                 join: this.tokenLocation( $t1 || $op, $t2, $join ),
+    { $table = { op: this.valueWithTokenLocation( 'join', $op ),
+                 join: this.valueWithTokenLocation( $join, $t1 || $op, $t2 ),
                  args: ($left ? [$left] : []),
                  location: $left && $left.location };
       if ($ctx.c) $table.cardinality = $c.joinCard; }
@@ -2062,24 +2221,24 @@ fromPath[ qp, idkind ]
 
 condition returns [ cond ] locals [ args = [], orl = [] ]
 @after{
-  $cond = ($args.length == 1)
+  $cond = ($args.length === 1)
     ? this.attachLocation( $args[0] )
     : this.attachLocation({ op: $orl[0], args: $args });
 }
   :
     c1=conditionAnd { $args.push($c1.cond); }
-    ( or=OR c2=conditionAnd { $args.push($c2.cond); $orl.push(this.tokenLocation( $or, undefined, 'or' ))} )*
+    ( or=OR c2=conditionAnd { $args.push($c2.cond); $orl.push(this.valueWithTokenLocation( 'or', $or ))} )*
   ;
 
 conditionAnd returns [ cond ] locals [ args = [], andl = [] ]
 @after{
-  $cond = ($args.length == 1)
+  $cond = ($args.length === 1)
     ? $args[0]
     : this.attachLocation({ op: $andl[0], args: $args });
 }
   :
     c1=conditionTerm { $args.push($c1.cond); }
-    ( and=AND c2=conditionTerm { $args.push($c2.cond); $andl.push(this.tokenLocation( $and, undefined, 'and' )) } )*
+    ( and=AND c2=conditionTerm { $args.push($c2.cond); $andl.push(this.valueWithTokenLocation( 'and', $and )) } )*
   ;
 
 conditionTerm returns [ cond ]
@@ -2088,38 +2247,38 @@ conditionTerm returns [ cond ]
 }
   :
     nt=NOT ct=conditionTerm
-    { $cond = { op: this.tokenLocation( $nt, undefined, 'not' ), args: [ $ct.cond ] }; }
+    { $cond = { op: this.valueWithTokenLocation( 'not', $nt ), args: [ $ct.cond ] }; }
   |
     ex=EXISTS
     (
       open='(' qe=queryExpression close=')'
-      { $cond = { op: this.tokenLocation( $ex, undefined, 'exists' ),
+      { $cond = { op: this.valueWithTokenLocation( 'exists', $ex ),
                   args: [ this.surroundByParens( $qe.query, $open, $close, true ) ] }; }
     |
       qm=( HideAlternatives | '?' )
-      { $cond = { op: this.tokenLocation( $ex, undefined, 'exists' ), args: [
-          { param: this.tokenLocation( $qm, undefined, '?' ), scope: 'param' }
+      { $cond = { op: this.valueWithTokenLocation( 'exists', $ex ), args: [
+          { param: this.valueWithTokenLocation( '?', $qm ), scope: 'param' }
         ] };
         this.csnParseOnly( 'Dynamic parameter "?" is not supported', $qm );
       }
     |
       ep=valuePath[ 'ref' ]
       { $ep.qp['$'+'expected'] = 'exists';
-        $cond = { op: this.tokenLocation( $ex, undefined, 'exists' ), args: [ $ep.qp ] };
+        $cond = { op: this.valueWithTokenLocation( 'exists', $ex ), args: [ $ep.qp ] };
       }
     )
   |
     expr=expression             // see @after
     (
       rel=( '=' | '<>' | '>'  | '>=' | '<' | '<=' | '!=' )
-      { $cond = { op: this.tokenLocation( $rel, undefined, $rel.text), args: [ $expr.expr ] }; }
+      { $cond = { op: this.valueWithTokenLocation( $rel.text, $rel ), args: [ $expr.expr ] }; }
       ( asa=( ANY | SOME | ALL )
-        { $cond.quantifier = this.tokenLocation($asa, undefined, $asa.text.toLowerCase()); }
+        { $cond.quantifier = this.valueWithTokenLocation( $asa.text.toLowerCase(), $asa ); }
       )?
       e2=expression { $cond.args.push($e2.expr); }
     |
       IS ( inn=NOT NULL | innu=NULL )
-      { $cond = { op: $inn ? this.tokenLocation( $inn, undefined, 'isNotNull' ) : this.tokenLocation( $innu, undefined, 'isNull' ), args: [ $expr.expr ] }; }
+      { $cond = { op: $inn ? this.valueWithTokenLocation( 'isNotNull', $inn ) : this.valueWithTokenLocation( 'isNull', $innu ), args: [ $expr.expr ] }; }
     |
       { $cond = { args: [ $expr.expr ] }; }
       NOT predicate[ $cond, true ]
@@ -2135,14 +2294,14 @@ predicate[ cond, negated ]
 //    NOT (a BETWEEN b AND c)
   :
     ino=IN e1=expression        // including ExpressionList
-    { $cond.op = this.tokenLocation( $ino, undefined, (negated) ? 'notIn' : 'in'); $cond.args.push( $e1.expr ); }
+    { $cond.op = this.valueWithTokenLocation( (negated) ? 'notIn' : 'in', $ino ); $cond.args.push( $e1.expr ); }
   |
     bw=BETWEEN e2=expression
-    { $cond.op = this.tokenLocation( $bw, undefined, (negated) ? 'notBetween' : 'between' ); $cond.args.push( $e2.expr ); }
+    { $cond.op = this.valueWithTokenLocation( (negated) ? 'notBetween' : 'between', $bw ); $cond.args.push( $e2.expr ); }
     AND e3=expression { $cond.args.push( $e3.expr ); }
   |
     lk=LIKE e4=expression
-    { $cond.op = this.tokenLocation( $lk, undefined, (negated) ? 'notLike' : 'like' ); $cond.args.push( $e4.expr ); }
+    { $cond.op = this.valueWithTokenLocation( (negated) ? 'notLike' : 'like', $lk ); $cond.args.push( $e4.expr ); }
     ( ESCAPE e5=expression { $cond.args.push( $e5.expr ); } )?
   ;
 
@@ -2154,7 +2313,7 @@ expression returns [ expr ]
       or='||' e2=expressionSum
       {
         $expr = {
-          op: this.tokenLocation( $or, undefined, '||' ), args: [$expr, $e2.expr],
+          op: this.valueWithTokenLocation( '||', $or ), args: [$expr, $e2.expr],
           location: this.combinedLocation( $expr, $e2.expr ) };
       }
     )*
@@ -2168,7 +2327,7 @@ expressionSum returns [ expr ]
       op=( '+' | '-' ) e2=expressionFactor
       {
         $expr = {
-          op: this.tokenLocation($op, undefined, $op.text), args: [$expr, $e2.expr],
+          op: this.valueWithTokenLocation( $op.text, $op ), args: [$expr, $e2.expr],
           location: this.combinedLocation( $expr, $e2.expr ) };
       }
     )*
@@ -2182,7 +2341,7 @@ expressionFactor returns [ expr ]
       op=( '*' | '/' ) e2=expressionTerm
       {
         $expr = {
-          op: this.tokenLocation($op, undefined, $op.text), args: [$expr, $e2.expr],
+          op: this.valueWithTokenLocation( $op.text, $op ), args: [$expr, $e2.expr],
           location: this.combinedLocation( $expr, $e2.expr ) };
       }
     )*
@@ -2202,7 +2361,7 @@ expressionTerm returns [ expr ] locals [ op, args = [] ]
       { $expr = $sf.ret; }
     |
       ca=CASE
-      { $expr = { op : this.tokenLocation( $ca, undefined, 'case' ), args: [] }; }
+      { $expr = { op : this.valueWithTokenLocation( 'case', $ca ), args: [] }; }
       (
         e2=expression { $expr.args.push($e2.expr); }
         ( ow=WHEN ew=expression THEN e3=expression
@@ -2220,7 +2379,7 @@ expressionTerm returns [ expr ] locals [ op, args = [] ]
     |
       ne=NEW nqp=valuePath[ 'ref', null] // token rewrite for NEW
       // please note: there will be no compiler-supported code completion after NEW
-      { $expr = { op: this.tokenLocation( $ne, undefined, 'new' ), args: [] };
+      { $expr = { op: this.valueWithTokenLocation( 'new', $ne ), args: [] };
         this.notSupportedYet( $ne ); }
     |
       vp=valuePath[ 'ref', null ] { $expr = this.valuePathAst( $vp.qp ); }
@@ -2239,7 +2398,7 @@ expressionTerm returns [ expr ] locals [ op, args = [] ]
       )
     |
       qm=( HideAlternatives | '?' )
-      { $expr = { param: this.tokenLocation( $qm, undefined, '?' ), scope: 'param' };
+      { $expr = { param: this.valueWithTokenLocation( '?', $qm ), scope: 'param' };
         this.csnParseOnly( 'Dynamic parameter "?" is not supported', $qm );
       }
     |
@@ -2257,7 +2416,7 @@ expressionTerm returns [ expr ] locals [ op, args = [] ]
         close=')'
         {
           if ($expr.length > 1)
-            $expr = { op: this.tokenLocation( $open, undefined, ',' ), args: $expr };
+            $expr = { op: this.valueWithTokenLocation( ',', $open ), args: $expr };
           else if ($expr[0]) // can be `null` if condition failed to parse
             $expr = this.surroundByParens( $expr[0], $open, $close );
         }
@@ -2297,7 +2456,7 @@ specialFunction returns [ ret = { } ] locals[ art = {} ]
     ca=CAST open='('
     {
       $ret = {
-        op: this.tokenLocation( $ca, undefined, 'cast' ),
+        op: this.valueWithTokenLocation( 'cast', $ca ),
         args: [ ],
         location: this.tokenLocation( $ca )
       };
@@ -2345,6 +2504,7 @@ fromArguments[ pathStep ]
 pathArguments[ pathStep, considerSpecial ]
 @after{ /* #ATN 1 */ }
   :
+    { this.excludeExpected([ 'ORDER' ]); }
     paren='('
     { this.prepareGenericKeywords( $considerSpecial ); }
     // ATN, LL2: Identifier can start both named arguments and the positional.
@@ -2366,16 +2526,23 @@ pathArguments[ pathStep, considerSpecial ]
       ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
         funcExpression[ $pathStep, $considerSpecial ]
       )*
+      // Note: We can't move this into funcExpression, or we would increase the ATN count because of `,` amiguity.
+      ( ob=functionOrderByClause[ $pathStep.args[$pathStep.args.length - 1] ]
+        {
+          // Remove the last entry which was copied to $ob.expr and push $ob.expr.
+          $pathStep.args[$pathStep.args.length - 1] = $ob.expr;
+        }
+      )?
     |
-      a=ALL { $pathStep.quantifier = this.tokenLocation( $a, undefined, 'all' ); }
+      a=ALL { $pathStep.quantifier = this.valueWithTokenLocation( 'all', $a ); }
       e1=expression { $pathStep.args = [ $e1.expr ]; }
     |
-      d=DISTINCT { $pathStep.quantifier = this.tokenLocation( $d, undefined, 'distinct' ); }
+      d=DISTINCT { $pathStep.quantifier = this.valueWithTokenLocation( 'distinct', $d ); }
       e1=expression { $pathStep.args = [ $e1.expr ]; }
       ( ',' e2=expression { $pathStep.args.push( $e2.expr ); } )*
     |
       star='*'
-      { $pathStep.args = [ { location: this.tokenLocation($star), val: '*', literal: 'token' } ]; }
+      { $pathStep.args = [ { location: this.tokenLocation( $star ), val: '*', literal: 'token' } ]; }
     |
       { $pathStep.args = []; }
     )
@@ -2449,7 +2616,7 @@ optionalWhereForFilter
 
 // Simple paths and values ---------------------------------------------------
 
-annoValueBase returns[ val ] locals [ hasEllipsis=0 ]
+annoValueBase returns[ val ] locals [ seenEllipsis = false ]
 @after { this.attachLocation($val); }
   :
     { $val = { literal: 'struct', location: this.startLocation() }; }
@@ -2469,30 +2636,43 @@ annoValueBase returns[ val ] locals [ hasEllipsis=0 ]
     '['
     (
       (
-          head=arrayValue  { $val.val.push( $head.val ); }
-        |
-          e='...'
-          { 
-            $val.val.push( { literal: 'token', val: '...', location: this.tokenLocation($e) } );
-            $hasEllipsis++;
-          }
+        head=arrayValue  { $val.val.push( $head.val ); }
+      |
+        e='...' ( UP TO upTo=arrayValue )?
+        {{
+          const item = { literal: 'token', val: '...', location: this.tokenLocation($e) };
+          $val.val.push( item );
+          if ($ctx.upTo) item.upTo = $upTo.val;
+          $seenEllipsis = !$ctx.upTo || 'upTo';
+        }}
       )
       (
         ',' { if (this.isStraightBefore(']')) break; } // allow ',' before ']'
         (
-            tail=arrayValue { $val.val.push( $tail.val ); }
-          |
-            e='...'
-            { 
-              $val.val.push( { literal: 'token', val: '...', location: this.tokenLocation($e) } );
-              if(++$hasEllipsis > 1)
-                this.error( 'syntax-unexpected-ellipsis', $e, { code: '...' },
-                            'Expected no more than one $(CODE)' );
-            }
+          tail=arrayValue { $val.val.push( $tail.val ); }
+        |
+          { $ctx.upTo = null; } // is not reset
+          e='...' ( UP TO upTo=arrayValue )?
+          {{
+            const item = { literal: 'token', val: '...', location: this.tokenLocation($e) };
+            if ($ctx.upTo) item.upTo = $upTo.val;
+            $val.val.push( item );
+            if ($seenEllipsis === true) // TODO: adapt msg to UP TO
+              this.error( 'syntax-unexpected-ellipsis', $e, { code: '...' },
+                          'Expected no more than one $(CODE)' );
+            else
+              $seenEllipsis = !$ctx.upTo || 'upTo';
+          }}
         )
       )*
     )?
-    ']'
+    cb=']'
+    {
+      if ($seenEllipsis === 'upTo')
+        this.error( 'syntax-expecting-ellipsis', $cb, // at closing bracket
+                    { code: '... up to', newcode: '...' },
+                   'Expecting an array item $(NEWCODE) after an item with $(CODE)' );
+    }
   |
     v1=literalValue { $val = $v1.val; }
   |
@@ -2660,6 +2840,7 @@ ident[ category ] returns[ id ]
   | ASSOCIATION
   | BETWEEN
   | BOTH
+  | COLUMNS
   | COMPOSITION
   | CONTEXT
   | CROSS
@@ -2667,8 +2848,10 @@ ident[ category ] returns[ id ]
   | DAY
   | DEFAULT
   | DEFINE
+  | DEFINITIONS
   | DESC
   | ELEMENT
+  | ELEMENTS
   | ELSE
   | END
   | ENTITY
@@ -2725,6 +2908,7 @@ ident[ category ] returns[ id ]
   | THEN
   | TRAILING
   | UNION
+  | UP
   | TO
   | TYPE
   | USING
@@ -2749,9 +2933,40 @@ LineComment : '//' ~[\r\n\u2028\u2029]* -> channel(HIDDEN);
 
 // Values --------------------------------------------------------------------
 
-String
+// for syntactic code-completion: Combine all three string styles
+// Note: Use rule `string` instead as that also parses escape sequences!
+String : SingleLineString
+       | MultiLineString
+       | MutlLineStringBlock;
+
+fragment SingleLineString
   :
-    ( '\'' ~[\u0027\n\r\u2028\u2029]* '\'' )+ // \u0027 = '\''
+      // \u0027 = '\''
+      // \u2028 = LS (Line Separator)
+      // \u2029 = PS (Paragraph Separator)
+      ( '\'' ~[\u0027\n\r\u2028\u2029]* '\'' )+ //
+  ;
+
+fragment MultiLineString
+  :
+    ('`' ( MultiLineStringContentChar | EscapeSequence )* '`' )
+  ;
+
+fragment MutlLineStringBlock
+  :
+    ('```' ( MultiLineStringContentChar | EscapeSequence )*  '```')
+  ;
+
+fragment EscapeSequence
+  :
+   // we could list each escape sequence explicitly, but we already
+   // decode them in genericAntlrParser.js, so no need to do work twice.
+   '\\' .
+  ;
+
+fragment MultiLineStringContentChar
+  :
+   (~[\u0060\\]) // \u0060 = '`'
   ;
 
 QuotedLiteral
@@ -2760,10 +2975,15 @@ QuotedLiteral
     ( '\'' ~[\u0027\n\r\u2028\u2029]* '\'' )+ // \u0027 = '\''
   ;
 
+// This literal improves error messages for unterminated literals.
 UnterminatedLiteral
   :
     ( [xX] | [dD][aA][tT][eE] | [tT][iI][mM][eE] ( [sS][tT][aA][mM][pP] )? )?
     '\'' ~[\u0027\n\r\u2028\u2029]* // \u0027 = '\''
+    |
+    ('`' ( MultiLineStringContentChar | EscapeSequence )* )
+    |
+    ('```' ( MultiLineStringContentChar | EscapeSequence )* )
   ;
 
 UnterminatedDelimitedIdentifier
@@ -2827,6 +3047,7 @@ ASPECT : [aA][sS][pP][eE][cC][tT] ;
 ASSOCIATION : [aA][sS][sS][oO][cC][iI][aA][tT][iI][oO][nN] ;
 BETWEEN : [bB][eE][tT][wW][eE][eE][nN] ;
 BOTH : [bB][oO][tT][hH] ;
+COLUMNS : [cC][oO][lL][uU][mM][nN][sS];
 COMPOSITION : [cC][oO][mM][pP][oO][sS][iI][tT][iI][oO][nN] ;
 CONTEXT : [cC][oO][nN][tT][eE][xX][tT] ;
 CROSS : [cC][rR][oO][sS][sS] ;
@@ -2834,8 +3055,10 @@ CURRENT : [cC][uU][rR][rR][eE][nN][tT] ;
 DAY : [dD][aA][yY] ;
 DEFAULT : [dD][eE][fF][aA][uU][lL][tT] ;
 DEFINE : [dD][eE][fF][iI][nN][eE] ;
+DEFINITIONS : [dD][eE][fF][iI][nN][iI][tT][iI][oO][nN][sS] ;
 DESC : [dD][eE][sS][cC] ;
 ELEMENT : [eE][lL][eE][mM][eE][nN][tT] ;
+ELEMENTS : [eE][lL][eE][mM][eE][nN][tT][sS] ;
 ELSE : [eE][lL][sS][eE] ;
 END : [eE][nN][dD] ;
 ENTITY : [eE][nN][tT][iI][tT][yY] ;
@@ -2896,6 +3119,7 @@ TO : [tT][oO] ;                 // or make reserved? (is in SQL-92)
 TYPE : [tT][yY][pP][eE] ;
 UNION : [uU][nN][iI][oO][nN] ;
 UNBOUNDED : [uU][nN][bB][oO][uU][nN][dD][eE][dD] ;
+UP : [uU][pP] ;
 USING : [uU][sS][iI][nN][gG] ;
 VARIABLE : [vV][aA][rR][iI][aA][bB][lL][eE] ;
 VIEW : [vV][iI][eE][wW] ;