@sap/cds-compiler 2.5.2 → 2.11.0

package/lib/language/antlrParser.js

@@ -10,7 +10,7 @@
 
 const antlr4 = require('antlr4');
 
-const { makeMessageFunction, CompileMessage } = require('../base/messages');
+const { CompileMessage } = require('../base/messages');
 const errorStrategy = require('./errorStrategy');
 
 const Parser = require('../gen/languageParser').languageParser;
@@ -112,7 +112,7 @@ const rules = {
   expr: { func: 'conditionEOF', returns: 'cond' }, // yes, condition
 };
 
-function parse( source, filename = '<undefined>.cds', options = {}, rule = 'cdl' ) {
+function parse( source, filename = '<undefined>.cds', options = {}, messageFunctions, rule = 'cdl' ) {
   const lexer = new Lexer( new antlr4.InputStream(source) );
   const tokenStream = new RewriteTypeTokenStream(lexer);
   /** @type {object} */
@@ -121,7 +121,7 @@ function parse( source, filename = '<undefined>.cds', options = {}, rule = 'cdl'
 
   parser.filename = filename;
   parser.options = options;
-  parser.$message = makeMessageFunction( parser, options, 'parse' ); // sets parser.messages
+  parser.$messageFunctions = messageFunctions;
 
   initTokenRewrite( parser, tokenStream );
   // comment the following 2 lines if you want to output the parser errors directly:
@@ -162,6 +162,18 @@ function parse( source, filename = '<undefined>.cds', options = {}, rule = 'cdl'
   if (rulespec.$frontend)
     ast.$frontend = rulespec.$frontend;
 
+  // Warn about unused doc-comments.
+  // Do not warn if docComments are explicitly disabled.
+  if (options.docComment !== false) {
+    for (const token of tokenStream.tokens) {
+      if (token.channel === antlr4.Token.HIDDEN_CHANNEL && token.type === parser.constructor.DocComment && !token.isUsed) {
+        messageFunctions.info('syntax-ignoring-doc-comment', parser.multiLineTokenLocation(token), {},
+          "Ignoring doc-comment as it does not belong to any artifact");
+      }
+    }
+  }
+
+  // TODO: clarify with LSP colleagues: still necessary?
   if (parser.messages) {
     Object.defineProperty( ast, 'messages',
                            { value: parser.messages, configurable: true, writable: true } );

package/lib/language/errorStrategy.js

@@ -245,6 +245,7 @@ function reportIgnoredWith( recognizer, t ) {
 }
 
 function consumeUntil( recognizer, set ) {
+  // TODO: add trace
   if (SEMI == null)
     SEMI = recognizer.literalNames.indexOf( "';'" );
   if (RBRACE == null)

package/lib/language/genericAntlrParser.js

@@ -13,6 +13,14 @@ const locUtils = require('../base/location');
 const { parseDocComment } = require('./docCommentParser');
 const { functionsWithoutParens, specialFunctions } = require('../compiler/builtins');
 
+
+// Push message `msg` with location `loc` to array of errors:
+function _message( parser, severity, id, loc, ...args ) {
+  const msg = parser.$messageFunctions[severity]; // set in antlrParser.js
+  return msg( id,
+              (loc instanceof antlr4.CommonToken) ? parser.tokenLocation(loc) : loc, ...args );
+}
+
 // Class which is to be used as grammar option with
 //   grammar <name> options { superclass = genericAntlrParser; }
 //
@@ -34,13 +42,15 @@ function GenericAntlrParser( ...args ) {
 
 GenericAntlrParser.prototype = Object.assign(
   Object.create( antlr4.Parser.prototype ), {
-    message: function(...args) { return message.call(this, 'message', ...args); },
-    error: function(...args) { return message.call(this, 'error', ...args); },
-    warning: function(...args) { return message.call(this, 'warning', ...args); },
-    info: function(...args) { return message.call(this, 'info', ...args); },
+    message: function(...args) { return _message( this, 'message', ...args ); },
+    error: function(...args) { return _message( this, 'error', ...args ); },
+    warning: function(...args) { return _message( this, 'warning', ...args ); },
+    info: function(...args) { return _message( this, 'info', ...args ); },
     attachLocation,
     startLocation,
     tokenLocation,
+    multiLineTokenLocation,
+    previousTokenAtLocation,
     combinedLocation,
     surroundByParens,
     unaryOpForParens,
@@ -69,6 +79,7 @@ GenericAntlrParser.prototype = Object.assign(
     noAssignmentInSameLine,
     noSemicolonHere,
     setLocalToken,
+    setLocalTokenIfBefore,
     excludeExpected,
     isStraightBefore,
     meltKeywordToIdentifier,
@@ -110,14 +121,6 @@ const quotedLiteralPatterns = {
   },
 };
 
-
-// Push message `msg` with location `loc` to array of errors:
-function message( severity, id, loc, ...args ) {
-  const msg = this.$message[severity];
-  return msg( id,   // function $message is set in antlrParser.js
-              (loc instanceof antlr4.CommonToken) ? this.tokenLocation(loc) : loc, ...args );
-}
-
 // Use the following function for language constructs which we (currently)
 // just being able to parse, in able to run tests from HANA CDS.  As soon as we
 // create ASTs for the language construct and put it into a CSN, a
@@ -183,6 +186,14 @@ function setLocalToken( string, tokenName, notBefore, inSameLine ) {
     ll1.type = this.constructor[tokenName];
 }
 
+function setLocalTokenIfBefore( string, tokenName, before, inSameLine ) {
+  const ll1 = this.getCurrentToken();
+  if (ll1.text.toUpperCase() === string &&
+      (!inSameLine || this._input.LT(-1).line === ll1.line) &&
+      (!before || before && before.test( this._input.LT(2).text )))
+    ll1.type = this.constructor[tokenName];
+}
+
 // // Special function for rule `requiredSemi` before return $ctx
 // function braceForSemi() {
 //   if (RBRACE == null)
@@ -236,9 +247,12 @@ function prepareGenericKeywords( pathItem ) {
   // TODO: If not just at the beginning, we need a stack for $genericKeywords,
   // as we can have nested special functions
   this.$genericKeywords.argFull = Object.keys( spec );
+  // @ts-ignore
   const token = this.getCurrentToken() || { text: '' };
-  if (spec[token.text.toUpperCase()] === 'argFull')
+  if (spec[token.text.toUpperCase()] === 'argFull') {
+    // @ts-ignore
     token.type = this.constructor.GenericArgFull;
+  }
 }
 
 // Attach location matched by current rule to node `art`.  If a location is
@@ -288,7 +302,7 @@ function tokenLocation( token, endToken, val ) {
     file: this.filename,
     line: token.line,
     col: token.column + 1,
-    // we only have single-line tokens
+    // we only have single-line tokens, except for docComments
     endLine: endToken.line,
     endCol: endToken.stop - endToken.start + endToken.column + 2, // after the last char (special for EOF?)
   };
@@ -297,6 +311,51 @@ function tokenLocation( token, endToken, val ) {
   return r;
 }
 
+/**
+ * Return location of `token`.  In contrast to `tokenLocation()`, this function
+ * can handle multiline tokens.
+ */
+function multiLineTokenLocation(token, val) {
+  if (!token)
+    return undefined;
+
+  // Count the number of newlines in the token.
+  // TODO: I want to avoid a substring, that's why I don't use RegEx here
+  const source = token.source[1].data;
+  let newLineCount = 0;
+  let lastNewlineIndex = token.start;
+  for (let i = token.start; i < token.stop; i++) {
+    if (source[i] === 10) { // ASCII code for '\n'
+      newLineCount++;
+      lastNewlineIndex = i;
+    }
+  }
+  if (newLineCount === 0)
+    // endCol calculation below requires at least one newLine.
+    return this.tokenLocation(token, token, val);
+
+  /** @type {CSN.Location} */
+  const r = {
+    file: this.filename,
+    line: token.line,
+    col: token.column + 1,
+    endLine: token.line + newLineCount,
+    endCol: token.stop - lastNewlineIndex + 1, // after the last char (special for EOF?)
+  };
+  if (val !== undefined)
+    return { location: r, val };
+  return r;
+}
+
+function previousTokenAtLocation( location ) {
+  let k = -1;
+  let token = this._input.LT(k);
+  while (token.line > location.line ||
+         token.line === location.line && token.column >= location.col)
+    token = this._input.LT(--k);
+  return (token.line === location.line && token.column + 1 === location.col) && token;
+}
+
 // Create a location with location properties `filename` and `start` from
 // argument `start`, and location property `end` from argument `end`.
 function combinedLocation( start, end ) {
@@ -333,16 +392,20 @@ function unaryOpForParens( query, val ) {
 //  - would influence the prediction, probably even induce adaptivePredict() calls,
 //  - is only slightly "more declarative" in the grammar.
 function docComment( node ) {
-  if (!this.options.docComment)
-    return;
   const token = this._input.getHiddenTokenToLeft( this.constructor.DocComment );
   if (!token)
     return;
+
+  // This token is actually used by / assigned to an artifact.
+  token.isUsed = true;
+
+  if (!this.options.docComment)
+    return;
   if (node.doc) {
     this.warning( 'syntax-duplicate-doc-comment', token, {},
                   'Repeated doc comment - previous doc is replaced' );
   }
-  node.doc = this.tokenLocation( token, token, parseDocComment( token.text ) );
+  node.doc = this.multiLineTokenLocation( token, parseDocComment( token.text ) );
 }
 
 // Classify token (identifier category) for implicit names,
@@ -426,14 +489,18 @@ function valuePathAst( ref ) {
     path.length = 1;
   }
   const { args, id, location } = path[0];
-  if (args) {
-    if (path[0].$syntax !== ':')
-      return { op: { location, val: 'call' }, func: ref, location: ref.location, args };
-  }
-  else if (!path[0].$delimited && functionsWithoutParens.includes( id.toUpperCase() )) {
-    return { op: { location, val: 'call' }, func: ref, location: ref.location };
-  }
-  return ref;
+  if (args
+      ? path[0].$syntax === ':'
+      : path[0].$delimited || !functionsWithoutParens.includes( id.toUpperCase() ))
+    return ref;
+
+  const implicit = this.previousTokenAtLocation( location );
+  if (implicit && implicit.isIdentifier)
+    implicit.isIdentifier = 'func';
+  const op = { location, val: 'call' };
+  return (args)
+    ? { op, func: ref, location: ref.location, args }
+    : { op, func: ref, location: ref.location };
 }
 
 // If a '-' is directly before an unsigned number, consider it part of the number;
@@ -592,7 +659,7 @@ function addDef( parent, env, kind, name, annos, props, location ) {
     // which could be tested in name search (then no undefined-ref error)
     return art;
   }
-  else if (env === 'artifacts') {
+  else if (env === 'artifacts' || env === 'vocabularies') {
     dictAddArray( parent[env], art.name.id, art );
   }
   else if (kind || this.options.parseOnly) {

package/lib/language/language.g4

@@ -20,7 +20,7 @@
 //    allow integers at certain places), one token type for non-quoted and
 //    quoted identifiers.
 //
-//  * Keep the number of keywords as small as possibile.  Thus, built-ins is a
+//  * Keep the number of keywords as small as possible.  Thus, built-ins is a
 //    topic for the semantic analysis, not the grammar.  Examples: no keywords
 //    for built-in types or built-in SQL functions.  This also avoids noise in
 //    the grammar and a huge/slow generated parser.
@@ -43,7 +43,7 @@
 //    is not enough for a decision), write a comment starting with `#ATN:`
 //    which describes the ambiguity.  Additionally, put a comment `/* #ATN n
 //    */` INSIDE an (`@after`) action of a rule if the corresponding function
-//    in '../gen/langageParser.js' contains `n` occurrences of
+//    in '../gen/languageParser.js' contains `n` occurrences of
 //    `adaptivePredict` calls.  This is checked in 'test/testCompiler.js',
 //    which also counts the total number of `adaptivePredict` occurrences.
 //  └─────────────────────────────────────────────────────────────────────────┘
@@ -55,6 +55,10 @@
 //    good idea anyway to avoid calls to `adaptivePredict`, see the rules
 //    starting with `annotationAssignment_`.
 //
+//  * Factoring out a sub rule into a named rule influences the error recovery:
+//    the parser tries to consume all tokens which are neither in the follow
+//    set of loops and named rules.  So be careful.
+//
 //  * Do not use actions in the lexer.  Examples: de-quote string literals not
 //    in the lexer, but in the parser; do not throw errors, but produce error
 //    tokens if necessary.
@@ -106,6 +110,9 @@
 //
 //  * The ANTLR error "missing attribute access on rule reference c in $c" can
 //    be solved with using $ctx.c instead of $c
+//
+//  * If you want to set a property starting with '$' like $syntax, use
+//    obj['$'+'syntax'] as the ANTLR tool would replace $syntax by $ctx.syntax
 
 grammar language;
 options {
@@ -114,6 +121,7 @@ options {
 }
 tokens {
   VIRTUAL,                      // used with setLocalToken()
+  OVER,                         // used with setLocalTokenIfBefore()
   HelperToken1,                 // used with setLocalToken(), does not appear in messages
   HelperToken2,                 // used with setLocalToken(), does not appear in messages
   HideAlternatives,             // hide alternative tokens (no token seq!)
@@ -490,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 ]?
   ;
@@ -818,7 +828,7 @@ annotateArtifact[ outer, loc, annos ] locals[ art, name = {} ]
       )*
       ')'
       (
-        RETURNS '{'
+        RETURNS '{' { $art['$'+'syntax'] = 'returns'; }
         annotateElement[ $art ]*
         '}'
         optionalSemi
@@ -826,7 +836,7 @@ annotateArtifact[ outer, loc, annos ] locals[ art, name = {} ]
         requiredSemi
       )
     |
-      RETURNS '{'
+      RETURNS '{' { $art['$'+'syntax'] = 'returns'; }
       annotateElement[ $art ]*
       '}'
       optionalSemi
@@ -1124,13 +1134,7 @@ bracedSelectItemListDef[ query ]
     '{'
     { if (!$query.columns) $query.columns = []; }  // set it early to avoid "wildcard" errors
     (
-      ( star='*'                // TODO: allow everywhere
-        {
-          $query.columns = [ this.tokenLocation( $star, undefined, '*' ) ];
-        }
-      |
-        selectItemDef[ $query.columns ]
-      )
+      selectItemDef[ $query.columns ]
       ( ',' { if (this.isStraightBefore("}")) break; } // allow ',' before '}'
         selectItemDef[ $query.columns ]
       )*
@@ -1139,8 +1143,11 @@ bracedSelectItemListDef[ query ]
   ;
 
 selectItemDef[ outer ] locals[ annos = [] ]
-@after{ this.attachLocation($art.art); }
+@after{ if ($ctx.art) this.attachLocation($art.art); }
   :
+    star='*'
+    { $outer.push( this.tokenLocation( $star, undefined, '*' ) ); }
+  |
     { this.docComment( $annos ); }
     annotationAssignment_atn[ $annos ]*
     // VIRTUAL is keyword, except if before the following tokens texts:
@@ -1159,6 +1166,8 @@ selectItemDefBody[ outer, annos ] returns[ art = {} ]
   :
     (
       e=expression
+      // we cannot use 'condition' instead, as long as we allow aliases without
+      // AS (using rule 'ident' instead of 'identNoKeyword') -> ambiguities
       {
         $art = this.addItem( $outer, null, null, $annos, { value: $e.expr } );
       }
@@ -1218,11 +1227,7 @@ selectItemInlineList[ art, clause ]
     '{'
     { $art[$clause] = []; }
     (
-      ( star='*'                // TODO: allow everywhere
-        { $art[$clause].push( this.tokenLocation( $star, undefined, '*' ) ); }
-      |
-        selectItemInlineDef[ $art[$clause] ]
-      )
+      selectItemInlineDef[ $art[$clause] ]
       ( ',' { if (this.isStraightBefore("}")) break; } // allow ',' before '}'
         selectItemInlineDef[ $art[$clause] ]
       )*
@@ -1231,8 +1236,11 @@ selectItemInlineList[ art, clause ]
   ;
 
 selectItemInlineDef[ outer ] locals[ annos = [] ]
-@after{ this.attachLocation($art.art); }
+@after{ if ($ctx.art) this.attachLocation($art.art); }
   :
+    star='*'
+    { $outer.push( this.tokenLocation( $star, undefined, '*' ) ); }
+  |
     { this.docComment( $annos ); }
     annotationAssignment_atn[ $annos ]*
     art=selectItemDefBody[ $outer, $annos ]
@@ -1407,6 +1415,8 @@ typeSpecSemi[ art, annos ]      // with 'includes', for type and annotation defs
   |
     ':'
     // #ATN: typeRefOptArgs can start with ARRAY or MANY or ASSOCIATION or TYPE or LOCALIZED
+    // Nevertheless, MANY '{' is handled by local token rewrite:
+    { this.setLocalToken( 'MANY', 'HelperToken1', /^[^\{]/ ); }
     (
       typeStruct[ $art ]
       optionalSemi
@@ -1416,6 +1426,12 @@ typeSpecSemi[ art, annos ]      // with 'includes', for type and annotation defs
       ( typeToMany[ $art ] | typeToOne[ $art ] | simplePath[ $art.target, 'artref' ] )
       typeAssociationCont[ $art ]?
       requiredSemi                       // and if its the ';'...
+    |
+      many=HelperToken1         // rewritten MANY before '{'
+      { $art.items = { location: this.tokenLocation( $many ) };}
+      typeStruct[ $art.items ]
+      nullability[ $art.items ]?
+      optionalSemi
     |
       (
         array=ARRAY of=OF
@@ -1455,6 +1471,7 @@ typeSpecSemi[ art, annos ]      // with 'includes', for type and annotation defs
       annotationAssignment_ll1[ $annos ]*
       requiredSemi
     |
+      // alt lookahead includes MANY '{'
       { $art.type = {}; }
       simplePath[ $art.type, 'artref' ]
       (
@@ -1462,8 +1479,20 @@ typeSpecSemi[ art, annos ]      // with 'includes', for type and annotation defs
         head=Number
         { $art['$'+'typeArgs'] = [ this.numberLiteral( $head ) ]; }
         ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
-          tail=Number
-          { $art['$'+'typeArgs'].push( this.numberLiteral( $tail ) ); }
+          (
+            v=VARIABLE
+            { $art['$'+'typeArgs'].push(
+              { literal: 'string', val: 'variable', location: this.tokenLocation($v) } );
+            }
+          |
+            f=FLOATING
+            { $art['$'+'typeArgs'].push(
+              { literal: 'string', val: 'floating', location: this.tokenLocation($f) } );
+            }
+          |
+            tail=Number
+            { $art['$'+'typeArgs'].push( this.numberLiteral( $tail ) ); }
+          )
         )*
         ')'
         { this.docComment( $annos ); }
@@ -1687,8 +1716,20 @@ typeRefOptArgs[ art ]
       head=Number
       { $art['$'+'typeArgs'] = [ this.numberLiteral( $head ) ]; }
       ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
-        tail=Number
-        { $art['$'+'typeArgs'].push( this.numberLiteral( $tail ) ); }
+        (
+          v=VARIABLE
+          { $art['$'+'typeArgs'].push(
+            { literal: 'string', val: 'variable', location: this.tokenLocation($v) } );
+          }
+        |
+          f=FLOATING
+          { $art['$'+'typeArgs'].push(
+            { literal: 'string', val: 'floating', location: this.tokenLocation($f) } );
+          }
+        |
+          tail=Number
+          { $art['$'+'typeArgs'].push( this.numberLiteral( $tail ) ); }
+        )
       )*
       ')'
     |
@@ -1723,6 +1764,87 @@ orderByClause[ inQuery ] returns [ query ]
     ( ',' obn=orderBySpec  { $query.orderBy.push( $obn.ob ); } )*
   ;
 
+overOrderByClause returns [ expr ]
+  :
+    o=ORDER b=BY { $expr = { op: this.tokenLocation($o, $b, 'orderBy' ) , 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: [] }}
+    e1=expression { $expr.args.push( $e1.expr ); }
+    ( ',' en=expression { $expr.args.push( $en.expr ); } )*
+  ;
+
+windowFrameClause returns [ wf ]
+  :
+    r=ROWS { $wf = { op: this.tokenLocation($r, null, 'rows' ) , args: [] }}
+    wfe=windowFrameExtentSpec { $wf.args.push( $wfe.wfe ); }
+  ;
+
+windowFrameExtentSpec returns[ wfe ]
+  :
+    { $wfe = {} }
+    windowFrameStartSpec [ $wfe ]
+  |
+    b=BETWEEN
+    { $wfe = { op: this.tokenLocation( $b, null, 'frameBetween' ), 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.tokenLocation($u, $f, 'unboundedFollowing' ), 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 = {} }
+    windowFrameStartSpec [ $wfb ]
+  ;
+
+windowFrameStartSpec [ wf ]
+  :
+    u=UNBOUNDED p=PRECEDING
+    {
+      $wf.op = this.tokenLocation($u, $p, 'unboundedPreceding' );
+      $wf.args = [];
+    }
+  |
+    n=Number p=PRECEDING
+    {
+      $wf.op = this.tokenLocation($p, null, 'preceding' );
+      $wf.args = [ this.numberLiteral( $n ) ];
+    }
+  | 
+    c=CURRENT r=ROW
+    {
+      $wf.op = this.tokenLocation($c, $r, 'currentRow' );
+      $wf.args = [];
+    }
+  ;
+
+overClause returns [ over ]
+@after { this.attachLocation($over); }
+  :
+    o=OVER { $over = { op: this.tokenLocation( $o, null, 'over' ) , args: []  } }
+    '('
+      ( pb=partitionByClause { $over.args.push( $pb.expr ); } )?
+      ( ob=overOrderByClause { $over.args.push( $ob.expr ); } )?
+      ( wf=windowFrameClause { $over.args.push( $wf.wf ); } )?
+    ')'
+  ;
+
 limitClause[ inQuery ] returns [ query ]
   :
     limkw=LIMIT { $query = this.unaryOpForParens( $inQuery, '$'+'query' ); }
@@ -1781,13 +1903,7 @@ queryPrimary returns[ query = {} ]
       { $query.quantifier = this.tokenLocation( $ad, undefined, $ad.text.toLowerCase() ); }
       )?
       { $query.columns = []; }  // set it early to avoid "wildcard" errors
-      ( star='*'
-        {
-          $query.columns = [ this.tokenLocation( $star, undefined, '*' ) ];
-        }
-      |
-        selectItemDef[ $query.columns ]
-      )
+      selectItemDef[ $query.columns ]
       ( ',' { if (this.isStraightBefore("}")) break; } // allow ',' before '}'
         selectItemDef[ $query.columns ]
       )*
@@ -1891,6 +2007,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
@@ -1945,7 +2063,7 @@ fromPath[ qp, idkind ]
 condition returns [ cond ] locals [ args = [], orl = [] ]
 @after{
   $cond = ($args.length == 1)
-    ? $args[0]
+    ? this.attachLocation( $args[0] )
     : this.attachLocation({ op: $orl[0], args: $args });
 }
   :
@@ -2106,6 +2224,10 @@ expressionTerm returns [ expr ] locals [ op, args = [] ]
         this.notSupportedYet( $ne ); }
     |
       vp=valuePath[ 'ref', null ] { $expr = this.valuePathAst( $vp.qp ); }
+      { this.setLocalTokenIfBefore( 'OVER', 'OVER', /^\($/i ); }
+      (
+        over=overClause { $expr.suffix = [ $over.over ] }
+      )?
     |
       ':'
       ( vp=valuePath[ 'paramref', this.startLocation() ]
@@ -2306,7 +2428,7 @@ optionalCardinality[ pathStep ]
     // completion just produces `:`after having inserted a Number - TODO.
     { if (this._input.LT(2).text !== ':') return $ctx; }
     ( trgMax=Number ':'
-      { if ($pathStep) $pathStep.cardinality = { targetMax: this.numberLiteral( $trgMax ) } }
+      { if ($pathStep) $pathStep.cardinality = { targetMax: this.numberLiteral( $trgMax ), location: this.startLocation() }; }
     )
   ;
 
@@ -2541,6 +2663,7 @@ ident[ category ] returns[ id ]
   | COMPOSITION
   | CONTEXT
   | CROSS
+  | CURRENT
   | DAY
   | DEFAULT
   | DEFINE
@@ -2557,6 +2680,8 @@ ident[ category ] returns[ id ]
   | EXCLUDING
   | EXTEND
   | FIRST
+  | FLOATING
+  | FOLLOWING
   | FULL
   | FUNCTION
   | GROUP
@@ -2587,10 +2712,14 @@ ident[ category ] returns[ id ]
   | ORDER
   | OUTER
   | PARAMETERS
+  | PARTITION
+  | PRECEDING
   | PROJECTION
   | REDIRECTED
   | RETURNS
   | RIGHT
+  | ROW
+  | ROWS
   | SECOND
   | SERVICE
   | THEN
@@ -2599,6 +2728,8 @@ ident[ category ] returns[ id ]
   | TO
   | TYPE
   | USING
+  | UNBOUNDED
+  | VARIABLE
   | VIEW
   | YEAR
   ;
@@ -2699,6 +2830,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] ;
@@ -2715,6 +2847,8 @@ EXCEPT : [eE][xX][cC][eE][pP][tT] ;
 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] ;
@@ -2744,11 +2878,16 @@ ONE : [oO][nN][eE] ;
 OR : [oO][rR] ;
 ORDER : [oO][rR][dD][eE][rR] ;
 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] ;
@@ -2756,7 +2895,9 @@ 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] ;
 USING : [uU][sS][iI][nN][gG] ;
+VARIABLE : [vV][aA][rR][iI][aA][bB][lL][eE] ;
 VIEW : [vV][iI][eE][wW] ;
 // VIRTUAL: [vV][iI][rR][tT][uU][aA][lL] ; see tokens {}
 YEAR : [yY][eE][aA][rR] ;