@sap/cds-compiler 2.10.4 → 2.12.0

package/lib/language/language.g4

@@ -490,7 +490,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']
     ( ':'
@@ -498,6 +498,8 @@ projectionSpec returns[ query ] locals[ src ]
       fromPath[ $src, 'ref']
     )?
     ( AS aliasName=ident['FromAlias'] { $src.name = $aliasName.id } )?
+    // ANTLR errors are better if we use ( A )? instead of ( A | ):
+    { if (!$src.name) this.classifyImplicitName( $src.scope ? 'FromAlias' : 'Without' ); }
     bracedSelectItemListDef[ $query ]?
     excludingClause[ $query ]?
   ;
@@ -981,6 +983,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() ) );
@@ -1076,7 +1079,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 ]*
@@ -1144,7 +1147,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 ]*
@@ -1154,8 +1157,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 );
     }
   ;
 
@@ -1188,7 +1191,7 @@ selectItemDefBody[ outer, annos ] returns[ art = {} ]
           excludingClause[ $art ]?
         |
           star='*'
-          { $art.inline = [ this.tokenLocation( $star, undefined, '*' ) ]; }
+          { $art.inline = [ this.valueWithTokenLocation( '*', $star ) ]; }
         )
       )?
     |
@@ -1237,7 +1240,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 ]*
@@ -1298,15 +1301,17 @@ entityParameterDef[ outer ] locals[ art, annos = [] ]
     annotationAssignment_fix[ $annos ]*
     typeSpec[ $art ]
     ( DEFAULT expr=expression { $art.default = $expr.expr; } )?
+    { 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 ]
@@ -1463,7 +1468,7 @@ typeSpecSemi[ art, annos ]      // with 'includes', for type and annotation defs
       { 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 ]
       { this.docComment( $annos ); }
       annotationAssignment_ll1[ $annos ]*
@@ -1499,7 +1504,8 @@ typeSpecSemi[ art, annos ]      // with 'includes', for type and annotation defs
             { $art.enum = Object.create(null); }
             enumSymbolDef[ $art ]*
           '}'
-          optionalSemi | requiredSemi
+          optionalSemi
+        | requiredSemi
         )
       |
         ':' // with element, e.g. `type T : E:elem enum { ... }`
@@ -1511,7 +1517,8 @@ typeSpecSemi[ art, annos ]      // with 'includes', for type and annotation defs
             { $art.enum = Object.create(null); }
             enumSymbolDef[ $art ]*
           '}'
-          optionalSemi | requiredSemi
+          optionalSemi
+        | requiredSemi
         )
       |
         { this.docComment( $annos ); }
@@ -1520,7 +1527,8 @@ typeSpecSemi[ art, annos ]      // with 'includes', for type and annotation defs
             { $art.enum = Object.create(null); }
             enumSymbolDef[ $art ]*
           '}'
-          optionalSemi | requiredSemi
+          optionalSemi
+        | requiredSemi
         )
       |
         // TODO: complain if used in anno def?
@@ -1764,25 +1772,82 @@ orderByClause[ inQuery ] returns [ query ]
 
 overOrderByClause returns [ expr ]
   :
-    o=ORDER b=BY { $expr = { op: this.tokenLocation($o, $b, 'orderBy' ) , args: [] }}
+    o=ORDER b=BY { $expr = { op: this.valueWithTokenLocation( 'orderBy', $o, $b ) , args: [] }}
     ob1=orderBySpec { $expr.args.push( $ob1.ob ); }
     ( ',' obn=orderBySpec { $expr.args.push( $obn.ob ); } )*
   ;
 
 partitionByClause returns [ 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 ]
+  :
+    r=ROWS { $wf = { op: this.valueWithTokenLocation( 'rows', $r ) , args: [] }}
+    wfe=windowFrameExtentSpec { $wf.args.push( $wfe.wfe ); }
+  ;
+
+windowFrameExtentSpec returns[ wfe ]
+  :
+    { $wfe = {} }
+    windowFrameStartSpec [ $wfe ]
+  |
+    b=BETWEEN
+    { $wfe = { op: this.valueWithTokenLocation( 'frameBetween', $b ), args: [] } }
+    wfb1=windowFrameBoundSpec { $wfe.args.push( $wfb1.wfb ); }
+    AND
+    wfb2=windowFrameBoundSpec { $wfe.args.push( $wfb2.wfb ); }
+  ;
+
+windowFrameBoundSpec returns [ wfb ]
+@after{ /* #ATN 1 */ }
+  :
+    // #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.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.valueWithTokenLocation( 'following', $n, $f ), args: [ this.numberLiteral( $n ) ]} }
+  |
+    { $wfb = {} }
+    windowFrameStartSpec [ $wfb ]
+  ;
+
+windowFrameStartSpec [ wf ]
+  :
+    u=UNBOUNDED p=PRECEDING
+    {
+      $wf.op = this.valueWithTokenLocation( 'unboundedPreceding', $u, $p );
+      $wf.args = [];
+    }
+  |
+    n=Number p=PRECEDING
+    {
+      $wf.op = this.valueWithTokenLocation( 'preceding', $p );
+      $wf.args = [ this.numberLiteral( $n ) ];
+    }
+  | 
+    c=CURRENT r=ROW
+    {
+      $wf.op = this.valueWithTokenLocation( 'currentRow', $c, $r );
+      $wf.args = [];
+    }
+  ;
+
 overClause returns [ 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 ); } )?
+      ( wf=windowFrameClause { $over.args.push( $wf.wf ); } )?
     ')'
   ;
 
@@ -1799,11 +1864,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 ); }
     )?
   ;
 
@@ -1826,7 +1891,7 @@ 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 ]
       (
@@ -1835,13 +1900,13 @@ queryPrimary returns[ query = {} ]
         '}' 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 ]
@@ -1895,8 +1960,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; }
@@ -1948,6 +2013,8 @@ tableTerm returns [ table ]
       // if we would use rule `ident`, we would either had to make all JOIN
       // kinds reserved or introduce ATN
     )?
+    // ANTLR errors are better if we use ( A | B )? instead of ( A | B | ):
+    { if (!$table.name) this.classifyImplicitName( $table.scope ? 'FromAlias' : 'Without' ); }
   |
     open='('
     // #ATN: The following alternative is not LL1, because both can start with
@@ -2001,24 +2068,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 ]
@@ -2027,38 +2094,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 ]
@@ -2074,14 +2141,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 ); } )?
   ;
 
@@ -2093,7 +2160,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 ) };
       }
     )*
@@ -2107,7 +2174,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 ) };
       }
     )*
@@ -2121,7 +2188,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 ) };
       }
     )*
@@ -2141,7 +2208,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
@@ -2159,7 +2226,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 ); }
@@ -2178,7 +2245,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 );
       }
     |
@@ -2196,7 +2263,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 );
         }
@@ -2236,7 +2303,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 )
       };
@@ -2306,15 +2373,15 @@ pathArguments[ pathStep, considerSpecial ]
         funcExpression[ $pathStep, $considerSpecial ]
       )*
     |
-      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 = []; }
     )
@@ -2388,7 +2455,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() }; }
@@ -2408,30 +2475,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; }
   |
@@ -2602,6 +2682,7 @@ ident[ category ] returns[ id ]
   | COMPOSITION
   | CONTEXT
   | CROSS
+  | CURRENT
   | DAY
   | DEFAULT
   | DEFINE
@@ -2619,6 +2700,7 @@ ident[ category ] returns[ id ]
   | EXTEND
   | FIRST
   | FLOATING
+  | FOLLOWING
   | FULL
   | FUNCTION
   | GROUP
@@ -2650,18 +2732,23 @@ ident[ category ] returns[ id ]
   | OUTER
   | PARAMETERS
   | PARTITION
+  | PRECEDING
   | PROJECTION
   | REDIRECTED
   | RETURNS
   | RIGHT
+  | ROW
+  | ROWS
   | SECOND
   | SERVICE
   | THEN
   | TRAILING
   | UNION
+  | UP
   | TO
   | TYPE
   | USING
+  | UNBOUNDED
   | VARIABLE
   | VIEW
   | YEAR
@@ -2682,9 +2769,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
@@ -2693,10 +2811,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
@@ -2763,6 +2886,7 @@ BOTH : [bB][oO][tT][hH] ;
 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] ;
+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] ;
@@ -2780,6 +2904,7 @@ EXCLUDING : [eE][xX][cC][lL][uU][dD][iI][nN][gG] ;
 EXTEND : [eE][xX][tT][eE][nN][dD] ;
 FIRST : [fF][iI][rR][sS][tT] ;
 FLOATING : [fF][lL][oO][aA][tT][iI][nN][gG] ;
+FOLLOWING : [fF][oO][lL][lL][oO][wW][iI][nN][gG] ;
 FULL : [fF][uU][lL][lL] ;
 FUNCTION : [fF][uU][nN][cC][tT][iI][oO][nN] ;
 GROUP : [gG][rR][oO][uU][pP] ;
@@ -2812,10 +2937,13 @@ OUTER : [oO][uU][tT][eE][rR] ;
 // OVER : [oO][vV][eE][rR] ;
 PARAMETERS : [pP][aA][rR][aA][mM][eE][tT][eE][rR][sS] ;
 PARTITION: [pP][aA][rR][tT][iI][tT][iI][oO][nN] ;
+PRECEDING: [pP][rR][eE][cC][eE][dD][iI][nN][gG] ;
 PROJECTION : [pP][rR][oO][jJ][eE][cC][tT][iI][oO][nN] ;
 REDIRECTED : [rR][eE][dD][iI][rR][eE][cC][tT][eE][dD] ;
 RETURNS : [rR][eE][tT][uU][rR][nN][sS] ;
 RIGHT : [rR][iI][gG][hH][tT] ;
+ROW : [rR][oO][wW] ;
+ROWS : [rR][oO][wW][sS] ;
 SECOND : [sS][eE][cC][oO][nN][dD] ;
 SERVICE : [sS][eE][rR][vV][iI][cC][eE] ;
 THEN : [tT][hH][eE][nN] ;
@@ -2823,6 +2951,8 @@ TRAILING : [tT][rR][aA][iI][lL][iI][nN][gG] ;
 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] ;