@sap/cds-compiler 3.9.4 → 4.0.0

package/lib/language/language.g4

@@ -723,7 +723,7 @@ elementType[ art ]     // TODO: split this monster rule
 
 elementProperties[ elem ]
   :
-    defaultAndNullablity[ $elem ]
+    defaultAndNullability[ $elem ]
   |
     '=' e=expression
     stored=STORED?
@@ -733,7 +733,7 @@ elementProperties[ elem ]
     }
   ;
 
-defaultAndNullablity[ elem ]
+defaultAndNullability[ elem ]
   :
     defaultValue[ $elem ]
     nullability[ $elem ]?       // placement accoring to SQL spec
@@ -763,7 +763,8 @@ extendArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
       extendWithOptElementsNoWith[ art ]
     |
       { this.addExtension( $art, $outer, 'extend', $name ); }
-      WITH { this.noSemicolonHere(); this.docComment( $art ); }
+      WITH { this.noSemicolonHere(); }
+      { this.docComment( $art ); }
       annotationAssignment_ll1[ $art ]*
       // #ATN: ELEMENTS, ENUM, DEFINITIONS, COLUMNS, ACTIONS are not reserved and
       // could be includeRef
@@ -1033,57 +1034,59 @@ annotateArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
 @after { this.attachLocation( $art ); }
   :
     simplePath[ $name, 'Annotate' ]
-    ( ':' simplePath[ $elemName, 'Element'] )? // TODO: do like for extendArtifact !
-    { this.addExtension( $art, $outer, 'annotate', $name, $elemName.path ); }
-    ( WITH { this.noSemicolonHere(); } )?
-    { this.docComment( $art ); }
-    annotationAssignment_ll1[ $art ]*
-    (
-      '{' { $art.elements = this.createDict(); }
-      annotateElement[ $art ]*
-      '}' { this.finalizeDictOrArray( $art.elements ); }
-      { this.checkExtensionDict( $art.elements ); }
+    ( // Element annotation
+      ':' simplePath[ $elemName, 'Element']
+      { this.addExtension( $art, $outer, 'annotate', $name, $elemName.path ); }
+      ( WITH { this.noSemicolonHere(); } )?
+      { this.docComment( $art ); }
+      annotationAssignment_ll1[ $art ]*
       (
-        ACTIONS { $art.actions = this.createDict(); } '{'
-        annotateAction[ $art ]*
-        '}' { this.finalizeDictOrArray( $art.actions ); }
-      { this.checkExtensionDict( $art.actions ); }
-      )?
-      optionalSemi
-    |
-      ACTIONS { $art.actions = this.createDict(); } '{'
-      annotateAction[ $art ]*
-      '}' { this.finalizeDictOrArray( $art.actions ); }
-      { this.checkExtensionDict( $art.actions ); }
-      optionalSemi
-    |
-      '(' { $art.params = this.createDict(); }
-      annotateParam[ $art ]
-      ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
-        annotateParam[ $art ]
-      )*
-      ')' { this.finalizeDictOrArray( $art.params ); }
-      { this.checkExtensionDict( $art.params ); }
+        '{' { $art.elements = this.createDict(); }
+        annotateElement[ $art ]*
+        '}' { this.finalizeDictOrArray( $art.elements ); }
+        { this.checkExtensionDict( $art.elements ); }
+        optionalSemi
+      | requiredSemi
+      )
+    | // Definition annotation
+      { this.addExtension( $art, $outer, 'annotate', $name ); }
+      ( WITH { this.noSemicolonHere(); } )?
+      { this.docComment( $art ); }
+      annotationAssignment_ll1[ $art ]*
       (
-        // TODO: set proper $art.returns
-        RETURNS { $art.elements = this.createDict(); } { $art['$'+'syntax'] = 'returns'; } '{'
+        '{' { $art.elements = this.createDict(); }
         annotateElement[ $art ]*
         '}' { this.finalizeDictOrArray( $art.elements ); }
-      { this.checkExtensionDict( $art.elements ); }
+        { this.checkExtensionDict( $art.elements ); }
+        (
+          ACTIONS { $art.actions = this.createDict(); } '{'
+          annotateAction[ $art ]*
+          '}' { this.finalizeDictOrArray( $art.actions ); }
+        { this.checkExtensionDict( $art.actions ); }
+        )?
         optionalSemi
+      |
+        ACTIONS { $art.actions = this.createDict(); } '{'
+        annotateAction[ $art ]*
+        '}' { this.finalizeDictOrArray( $art.actions ); }
+        { this.checkExtensionDict( $art.actions ); }
+        optionalSemi
+      |
+        '(' { $art.params = this.createDict(); }
+        annotateParam[ $art ]
+        ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
+          annotateParam[ $art ]
+        )*
+        ')' { this.finalizeDictOrArray( $art.params ); }
+        { this.checkExtensionDict( $art.params ); }
+        ( annotateReturns[ $art ]
+        | requiredSemi
+        )
+      |
+        annotateReturns[ $art ]
       |
         requiredSemi
       )
-    |
-      // TODO: set proper $art.returns
-      RETURNS { $art.elements = this.createDict(); } { $art['$'+'syntax'] = 'returns'; } '{'
-      annotateElement[ $art ]*
-      '}' { this.finalizeDictOrArray( $art.elements ); }
-      { this.checkExtensionDict( $art.elements ); }
-      optionalSemi
-
-    |
-      requiredSemi
     )
   ;
 
@@ -1126,17 +1129,27 @@ annotateAction [ outer ] locals [ art = {} ]
       { this.checkExtensionDict( $art.params ); }
     )?
     (
-      // TODO: set proper $art.returns
-      RETURNS { $art.elements = this.createDict(); } { $art['$'+'syntax'] = 'returns'; } '{'
-      annotateElement[ $art ]*
-      '}' { this.finalizeDictOrArray( $art.elements ); }
-      { this.checkExtensionDict( $art.elements ); }
-      optionalSemi
+      annotateReturns[ $art ]
     |
       requiredSemi
     )
   ;
 
+annotateReturns[ art ]
+@after{ this.attachLocation( $art.returns ); }
+  :
+    ret=RETURNS { $art.returns = { kind: 'annotate' }; }
+    { this.docComment( $art.returns ); }
+    annotationAssignment_ll1[ $art.returns ]*
+    ( '{' { $art.returns.elements = this.createDict(); }
+      annotateElement[ $art.returns ]*
+      '}' { this.finalizeDictOrArray( $art.returns.elements ); }
+      { this.checkExtensionDict( $art.returns.elements ); }
+      optionalSemi
+    | requiredSemi
+    )
+  ;
+
 annotateParam [ outer ] locals [ art = {} ]
 @after{ this.attachLocation( $art ); }
   :
@@ -1190,6 +1203,8 @@ returnTypeSpec[ art ]
 @after{ /* #ATN 1 */ }
   :
     ret=RETURNS { $art.returns = { location: this.tokenLocation( $ret ), kind: 'param' }; }
+    { this.docComment( $art.returns ); }
+    annotationAssignment_ll1[ $art.returns ]*
     // #ATN: typeSimple can start with ARRAY or TYPE
     ( typeStruct[ $art.returns ]
       nullability[ $art.returns ]?
@@ -1246,8 +1261,10 @@ typeSpecSemi[ art ]      // with 'includes', for type and annotation defs
       many=HelperToken1         // rewritten MANY before '{'
       { $art.items = { location: this.tokenLocation( $many ) };}
       typeStruct[ $art.items ]
-      nullability[ $art.items ]?
-      optionalSemi // TODO(v4): Should be requiredSemi with nullability
+      ( nullability[ $art.items ]
+        requiredSemi
+      | optionalSemi
+      )
     |
       (
         array=ARRAY of=OF
@@ -1257,8 +1274,10 @@ typeSpecSemi[ art ]      // with 'includes', for type and annotation defs
       )
       // #ATN: typeRefOptArgs can start with TYPE
       ( typeStruct[ $art.items ]
-        nullability[ $art.items ]?
-        optionalSemi // TODO(v4): Should be requiredSemi with nullability
+        ( nullability[ $art.items ]
+          requiredSemi
+        | optionalSemi
+        )
       | ( typeTypeOf[ $art.items ] | typeRefOptArgs[ $art.items ] )
         nullability[ $art.items ]?
         { this.docComment( $art ); }
@@ -1267,26 +1286,23 @@ typeSpecSemi[ art ]      // with 'includes', for type and annotation defs
           ENUM '{' { $art.items.enum = this.createDict(); }
           enumSymbolDef[ $art.items ]*
           '}' { this.finalizeDictOrArray( $art.items.enum ); }
-          (
-            nullability[ $art.items ]
+          ( nullability[ $art.items ]
             requiredSemi
-          |
-            optionalSemi
+          | optionalSemi
           )
-        |
-          requiredSemi
+        | requiredSemi
         )
       )
     |
       typeTypeOf[ $art ]
-      defaultAndNullablity[ $art ]?
+      defaultAndNullability[ $art ]?
       { this.docComment( $art ); }
       annotationAssignment_ll1[ $art ]*
       requiredSemi
     |
       l=LOCALIZED { $art.localized = this.valueWithTokenLocation( true, $l ); }
       typeRefOptArgs[ $art ]
-      defaultAndNullablity[ $art ]?
+      defaultAndNullability[ $art ]?
       { this.docComment( $art ); }
       annotationAssignment_ll1[ $art ]*
       requiredSemi
@@ -1301,20 +1317,18 @@ typeSpecSemi[ art ]      // with 'includes', for type and annotation defs
           { $art.type.scope = $art.type.path.length; }
           simplePath[ $art.type, 'ref']
         )?
+        optInvisibleNullability[ $art ]
         { this.docComment( $art ); }
         annotationAssignment_ll1[ $art ]*
         (
           ENUM '{' { $art.enum = this.createDict(); }
           enumSymbolDef[ $art ]*
           '}' { this.finalizeDictOrArray( $art.enum ); }
-          (
-            optionalSemi
-          |
-            defaultAndNullablity[ $art ]
+          ( optionalSemi
+          | defaultAndNullability[ $art ]
             requiredSemi
           )
-        |
-          defaultAndNullablity[ $art ]?
+        | defaultAndNullability[ $art ]?
           requiredSemi
         )
       |
@@ -1512,7 +1526,7 @@ foreignKey[ outer ] locals[ art = {}, elem = {} ]
 typeTypeOf[ art ] locals[ _sync = 'nop' ]
 @after { this.attachLocation($art.type); }
   :
-    TYPE OF
+    t=TYPE o=OF
     { $art.type = { scope: 'typeOf' }; }
     simplePath[ $art.type, 'ref' ]
     ( ':'
@@ -1521,6 +1535,12 @@ typeTypeOf[ art ] locals[ _sync = 'nop' ]
       { $art.type.scope = $art.type.path.length; }
       simplePath[ $art.type, 'ref']
     )?
+    // We do not use (…|) here instead (…)? due to different ANTLR code generation:
+    // (…|) would check for follow set, which does not work with local token rewrite
+    { if ($art.type.scope === 'typeOf')
+      // Better error locations and much simpler code if we consider it as a path breakout:
+      $art.type.path.unshift( { id: 'type of', location: this.tokenLocation( $t, $o )} );
+    }
   ;
 
 typeRefOptArgs[ art ]
@@ -1621,7 +1641,7 @@ projectionSpec returns[ query ] locals[ src ]
     proj=PROJECTION ON
     // now a simplified `tableTerm`:
     {
-      $src = { path: [], scope: 0 };
+      $src = { path: [] };
       $query = { op: this.valueWithTokenLocation( 'SELECT', $proj ), from: $src, location: this.startLocation() };
     }
     fromPath[ $src, 'artref']
@@ -1750,11 +1770,19 @@ tableExpression returns[ table ] // TableOrJoin
 tableTerm returns [ table ]
 @after{ /* #ATN 1 */ this.attachLocation($table); }
   :
-    { $table = { path: [], scope: 0 }; }
-    fromPath[ $table, 'artref']
-    ( ':'
-      { $table.scope = $table.path.length; }
-      fromPath[ $table, 'ref']
+    { $table = { path: [] }; }
+    f=fromPath[ $table, 'artref']
+    { if ($f.dotAfterFilter)
+        this.warning( 'syntax-invalid-path-separator', $f.dotAfterFilter,
+                      { '#': 'dot', code: '.', newcode: ':' } );
+    }
+    ( { if (!$table.scope)
+          $table.scope = $table.path.length;
+        else
+          this.warning( 'syntax-invalid-path-separator', this.getCurrentToken(),
+                      { '#': 'colon', code: ':', newcode: '.' } );
+      }
+      ':' fromPath[ $table, 'ref']
     )?
     ( AS n1=ident['FromAlias'] { $table.name = $n1.id }
     | n2=identNoKeyword['FromAlias'] { $table.name = this.fragileAlias( $n2.id ); }
@@ -1770,7 +1798,7 @@ tableTerm returns [ table ]
     (
       qe=queryExpression close=')'
       { $table = this.surroundByParens( $qe.query, $open, $close, true ); }
-      ( AS a1=ident['FromAlias'] { $table.name = $a1.id } // for defining table aliass
+      ( AS a1=ident['FromAlias'] { $table.name = $a1.id } // for defining table alias
       | a2=identNoKeyword['FromAlias'] { $table.name = this.fragileAlias( $a2.id, true ); }
         // not using ident` to have a similar behavior to above
       )?
@@ -1780,17 +1808,25 @@ tableTerm returns [ table ]
     )
   ;
 
-fromPath[ qp, idkind ]
+fromPath[ qp, idkind ] returns[ dotAfterFilter = null ]
 @after{ this.attachLocation($qp); }
   :
     id=ident[$idkind] { this.pushIdent( $qp.path, $id.id ); }
     ( fromArguments[ $id.id ] cardinalityAndFilter[ $id.id ]?
+      { $dotAfterFilter = false; }
     | cardinalityAndFilter[ $id.id ]
+      { $dotAfterFilter = false; }
     )?
     (
+      { if ($dotAfterFilter === false) {
+        $dotAfterFilter = this.getCurrentToken();
+        if (!$qp.scope) $qp.scope = $qp.path.length;
+      } }
       '.' id=ident[$idkind] { this.pushIdent( $qp.path, $id.id ); }
-      ( fromArguments[ $id.id ] cardinalityAndFilter[ $id.id ]?
+      ( fromArguments[ $id.id ] cardinalityAndFilter[ $id.id ]? 
+        { if (!$dotAfterFilter) $dotAfterFilter = false; }
       | cardinalityAndFilter[ $id.id ]
+        { if (!$dotAfterFilter) $dotAfterFilter = false; }
       )?
     )*
   ;
@@ -2301,9 +2337,7 @@ simplePath[ art, category ] locals[ _sync = 'nop' ]
 // path as broken in this case.
   :
     head=ident[ $category ]
-    { if (!$art.path) $art.path = []; this.pushIdent( $art.path, $head.id );
-      if ($category === 'artref') $art.scope = 0;
-    }
+    { if (!$art.path) $art.path = []; this.pushIdent( $art.path, $head.id ); }
     (
       '.' tail=ident[ $category ] { this.pushIdent( $art.path, $tail.id ); }
     )*
@@ -2529,14 +2563,34 @@ windowFrameStartSpec[ args = [] ]
 
 cardinalityAndFilter[ pathStep ] locals [ _sync = 'nop' ]
   :
-    '['
+    { if (!$pathStep) $pathStep = {}; }
+    openFilter='['
     optionalCardinality[ pathStep ]?
-    //{ $LeaveLoop = false; }
-    optionalWhereForFilter
-    co=condition { if ($pathStep) $pathStep.where = $co.cond; }
-    ']'
+
+    filterWhereClause[ $pathStep ] // required, see rule's comment
+    (
+      group=GROUP by=BY
+      e1=expression { $pathStep.groupBy = [ $e1.expr ]; }
+      ( ',' en=expression { $pathStep.groupBy.push( $en.expr ); } )*
+      { this.csnParseOnly('syntax-unexpected-sql-clause', [ $group, $by ], { keyword: 'GROUP BY' }); }
+    )?
+    ( hv=HAVING
+      having=condition { $pathStep.having = $having.cond; }
+      { this.csnParseOnly('syntax-unexpected-sql-clause', [ $hv ], { keyword: 'HAVING' }); }
+    )?
+    ( { const orderKw = this._input.LT(1); const byKw = this._input.LT(2); }
+      ob=orderByClause[ $pathStep ] { $pathStep = $ob.query;; }
+      { this.csnParseOnly('syntax-unexpected-sql-clause', [ orderKw, byKw ], { keyword: 'ORDER BY' }); }
+    )?
+    ( { const limit = this._input.LT(1); }
+      lc=limitClause[ $pathStep ]   { $pathStep = $lc.query;; }
+      { this.csnParseOnly('syntax-unexpected-sql-clause', [ limit ], { keyword: 'LIMIT' }); }
+    )?
+
+    closeFilter=']'
   ;
 
+
 optionalCardinality[ pathStep ]
 @after { if ($pathStep && $pathStep.cardinality) this.attachLocation($pathStep.cardinality); }
   :
@@ -2549,17 +2603,36 @@ optionalCardinality[ pathStep ]
     )
   ;
 
+filterWhereClause[ pathStep ]
+  :
+    // NOTE: Keep in sync with optionalWhereForFilter!
+    //
+    // For ANTLR, WHERE is required, but the generated parser may skip `match(WHERE)` in
+    // `optionalWhereForFilter`. Because `(WHERE cond)?` would invoke adaptive predict,
+    // we use this hack that skips parsing of the condition, if the token is a SQL clause,
+    // but makes Antlr assume that it is required.
+    {
+      const tok = this.getCurrentToken();
+      if (tok.type === languageParser.GROUP
+         || tok.type === languageParser.ORDER
+         || tok.type === languageParser.LIMIT
+         || tok.type === languageParser.HAVING)
+        return $ctx;
+    }
+    optionalWhereForFilter cond=condition { if ($pathStep) $pathStep.where = $cond.cond; }
+  ;
+
 optionalWhereForFilter
   :
+    // NOTE: only call from rule filterWhereClause!
+    //
     // For ANTLR, WHERE is required, but we allow the generated parser skipping
-    // the call of match(WHERE) except for the future (optional) clauses GROUP,
-    // ORDER, LIMIT.  This hack requires that sync() at each state in the
-    // calling rule does not throw an error if the current token does not match
+    // the call of match(WHERE).  This hack requires that sync() at each state in
+    // the calling rule does not throw an error if the current token does not match
     // one of the expected ones.
     {
-      var text = this.getCurrentToken().text.toUpperCase();
-      if (!['WHERE','GROUP','ORDER','LIMIT'].includes( text )) return $ctx;
-      // TODO: should we somehow add those keywords to $(EXPECTED)?
+      if (this.getCurrentToken().type !== languageParser.WHERE)
+        return $ctx; // TODO: should we somehow add those keywords to $(EXPECTED)?
     }
     WHERE
   ;
@@ -2693,9 +2766,7 @@ annotationPath[ art, category, headat = null ] locals[ _sync = 'nop' ]
 // path as broken in this case.
   :
     head=ident[ $category ]
-    { $art.path = []; this.pushIdent( $art.path, $head.id, $headat );
-      if ($category === 'artref') $art.scope = 0;
-    }
+    { $art.path = []; this.pushIdent( $art.path, $head.id, $headat ); }
     (
       '.' at='@'? tail=ident[ $category ]
       { this.pushIdent( $art.path, $tail.id, $at );