@sap/cds-compiler 5.8.2 → 5.9.0

package/lib/parsers/CdlGrammar.g4

@@ -772,6 +772,7 @@ extendElementsBlock[ art, start = undefined ]
 elementDefOrExtend[ outer ] locals[ art = new XsnArtifact() ]
 @finally{ this.checkWith( $keyword ); this.attachLocation( $art ); }
   :
+    { $art.location = this.startLocation(); }
     { this.docComment( $art ); } annoAssignStd[ $art ]*
     (
       elementDef[ $outer, $art ]
@@ -1604,6 +1605,8 @@ expression returns[ default expr = {} ]
         | <prec=10, assoc=none> '='/'<>'/'>'/'>='/'<'/'<='/'!='
           { $expr = this.applyOpToken( $expr ); }
           ( ANY/SOME/ALL { this.pushXprToken( $expr ); } )?
+        | <prec=10, assoc=none> '=='
+          { $expr = this.applyOpToken( $expr ); }
         )
         e=expression { $expr.args.push( $e ); }
 
@@ -1707,30 +1710,10 @@ options{ minTokensMatched = 1 }
       // action here, default action won't be executed with failed condition (TODO
       // TOOL? at least msg)
       (
-        <default=fallback>      // TODO TOOL: allow in loop
-        (
-          expr=funcExpression { $pathStep.args.push( $expr ); }
-          (
-            ','<prepare=nextFunctionArgument>
-            ( expr=funcExpression { $pathStep.args.push( $expr ); }
-            | DeleteStarFromSet // Workaround for missing feature, see #13485, TODO
-            | <exitLoop, guard=atRightParen>
-              // TODO: later allow ')' <exitRule>, or ')'<mock, exitLoop>, or <exitBlock=MainAlt> with ( options{ block=MainAlt }: …)
-            )
-          )*
-          (   // ORDER BY in generic functions, e.g. `first_value(id order by name)`
-            ORDER { $expr = $pathStep.args[$pathStep.args.length - 1] = this.applyOpToken( $expr ); }
-            BY { this.pushXprToken( $expr ); }
-            orderByClauseAsXpr[ $expr.args ]
-            { this.attachLocation( $expr ); }
-          )?
-        |
-          DeleteStarFromSet     // Workaround for missing feature, see #13485, TODO
-        )?
-      |
-        // TODO: if we want perfect CC and error recovery, `isNamedArg` would work
-        // like keyword prediction and also do something similar to the (future)
-        // "identifier confirmation prediction" (consider argument `(par ‡ : 42)`
+        // TODO: if we want perfect CC and error recovery, `isNamedArg` would not
+        // only check the next token for the ':'/'=>', but probably also for the
+        // one after that, at least if the next token could not be a valid
+        // operator (consider that parameter references look like `:PAR`)
         <guard=isNamedArg> id=Id_all['paramname']
         (
           ':' { $pathStep.args = this.createDict( $open ); $pathStep.$syntax = ':'; }
@@ -1752,6 +1735,24 @@ options{ minTokensMatched = 1 }
             )
           )*
         )
+      |
+        <default=fallback>
+        (
+          expr=funcExpression { $pathStep.args.push( $expr ); }
+          (
+            ','<prepare=nextFunctionArgument>
+            ( expr=funcExpression { $pathStep.args.push( $expr ); }
+            | <exitLoop, guard=atRightParen>
+              // TODO: later allow ')' <exitRule>, or ')'<mock, exitLoop>, or <exitBlock=MainAlt> with ( options{ block=MainAlt }: …)
+            )
+          )*
+          (   // ORDER BY in generic functions, e.g. `first_value(id order by name)`
+            ORDER { $expr = $pathStep.args[$pathStep.args.length - 1] = this.applyOpToken( $expr ); }
+            BY { this.pushXprToken( $expr ); }
+            orderByClauseAsXpr[ $expr.args ]
+            { this.attachLocation( $expr ); }
+          )?
+        )?
       )
       ')' { this.finalizeDictOrArray( $pathStep.args ); }
     )?
@@ -1789,8 +1790,8 @@ funcExpression returns[ default expr ] locals[ args ]
   ;
 
 // TODO: check Id_all - necessary if generic token is a reserved word?
-GenericExpr
-  : Id_all | '*' ;
+GenericExpr // workaround TODO Runtime: no-skip/exit recovery w/o guards, see #13485
+  : Id_all | '*' | DeleteStarFromSet ; // → DeleteStarFromSet to avoid failing on same token
 GenericIntro
   : Id_all ;
 GenericSeparator
@@ -2055,11 +2056,15 @@ annoValue returns[ default value = {} ]
   ;
 
 // Shorten tokens array in this.gr() calls in top-level rules by reducing
-// intersection follow set:
+// intersection follow set, see cap/redepage#97:
 ignoredRule
 options{ excludeRuleFrom = Parser }
   :
     usingDeclaration ';'
     artifactDefOrExtend ';'
+    boundActionFunctionDef ';'
+    elementDef ';'
+    annotateBoundAction ';'
+    annotateElement ';'
+    elementDefOrExtend ';'
   ;
-

package/lib/parsers/Lexer.js

@@ -19,7 +19,7 @@ const { Location } = require('../base/location'); // TODO main: add tokenIndex
 const rules = [                     // must not contain capturing groups!
   { type: comment, re: '/[*/]' },
   // token type = token text (`type: null`):
-  { type: null, re: '[-+*?()\\[\\]{},;:/@#]|\\.(?:\\.\\.?)?|<[=>]?|>=?|=>?|!=|\\|\\|' },
+  { type: null, re: '[-+*?()\\[\\]{},;:/@#]|\\.(?:\\.\\.?)?|<[=>]?|>=?|=[=>]?|!=|\\|\\|' },
   { type: ident, re: '[$_\\p{ID_Start}][$\\p{ID_Continue}\u200C\u200D]*|!\\[|"' },
   { type: string, re: '[\'"]|`(?:``)?' }, // strings, template literal without …${}
   { type: 'Number', re: '\\d+(?:\\.\\d+)?(?:e[-+]?\\d+)?' },

package/lib/parsers/XprTree.js

@@ -2,6 +2,7 @@
 
 // See ./CdlGrammar.js for the operator precedences.
 
+// CSN representation of window functions: unfortunately not Option 4 in #7632
 
 'use strict';
 
@@ -31,7 +32,7 @@ const binaryOperators = {
   '<': 10,
   '<=': 10,
   '!=': 10,
-  '==': 10,                     // not supported yet in CDL or backends
+  '==': 10,
   and: 4,
   or: 2,
   // with second token or ternary (in the grammar, these ops have prec=10, but
@@ -56,8 +57,10 @@ const secondTokens = {
 };
 
 const naryOperators = {
+  // all strings on the right must not have a precedence mentioned in secondTokens
+  // true must not be used for operator (precedence) with secondTokens
   __proto__: null,
-  '.': true,                    // CSN-tree really as left-assoc binary?
+  '.': true,                    // CSN-tree not as left-assoc binary?
   '*': true,
   '/': true,
   '+': true,
@@ -74,7 +77,7 @@ class XprTree {
   nodes;                        // array value of CSN property `xpr`/`where`/…
   nodeIdx = 0;
   args;        // corresponding XSN array, with already tree-like sub expressions
-  location;
+  location;    // true → CSN input: direct array, no n-ary
 
   constructor( nodes, args, location ) {
     this.nodes = nodes;
@@ -85,15 +88,21 @@ class XprTree {
   tree() {
     const args = [];
     const { length } = this.args;
+    // TODO: orderByClauseAsXpr, overClause
     while (this.nodeIdx < length) {
       const expr = this.expression( -1 );
       if (expr)
         args.push( expr );
     }
-    return (args.length === 1) ? args[0] : this.create( args );
+    if (args.length === 1) {
+      // For CSN, keep xpr arrays as arrays
+      return (this.location === true) ? args : args[0];
+    }
+    return this.create( args );
   }
 
   expression( parentPrec ) {
+    // console.log('B:',this.nodeIdx,parentPrec)
     let append;
     let naryOp;
     let args;
@@ -129,23 +138,20 @@ class XprTree {
       if (!prec || parentPrec >= prec)
         return expr;
 
-      // handle n-ary operators including ternary
-      append = (typeof naryOp === 'string')
-        ? !append && naryOp     // `and` after `between`, `escape` after `like`˛
-        : naryOp && node;       // nary operators like `+`
-      if (node === append) {
+      // handle n-ary extensions of binary operators
+      if (node === append && this.location !== true) { // not for CSN input
         args.push( this.args[this.nodeIdx++] );
       }
       else {
         naryOp = naryOperators[node];
-        append = false;
+        append = naryOp === true && node;
         args = [ expr, this.args[this.nodeIdx++] ];
         expr = this.create( args, naryOp === true );
       }
 
-      // handle second token of operator:
+      // handle second token of operator (there must be none for naryOp=true):
       const second = this.nodes[this.nodeIdx];
-      if (typeof second === 'string' && secondTokens[second] === prec && !append) {
+      if (typeof second === 'string' && secondTokens[second] === prec) {
         args.push( this.args[this.nodeIdx++] );
         if (node === 'not')
           naryOp = naryOperators[second];
@@ -157,8 +163,10 @@ class XprTree {
         return expr;
       args.push( right );
       node = this.nodes[this.nodeIdx];
-      // TODO: simplyfy between-and and like-escape with pushTokenAndExpression()
+      if (node === naryOp && typeof node === 'string')
+        node = this.pushTokenAndExpression( args, prec );
     }
+    // console.log('E:',this.nodeIdx)
     return expr;
   }
 
@@ -183,16 +191,17 @@ class XprTree {
     return expr;
   }
 
-  pushTokenAndExpression( args ) {
+  pushTokenAndExpression( args, prec = -1 ) {
     args.push( this.args[this.nodeIdx++] );
-    const value = this.expression( -1 );
+    const value = this.expression( prec );
     if (value)
       args.push( value );
     return this.nodes[this.nodeIdx];
   }
 
   create( args, isNary = false ) {
-    // could be adopted for CSN expression tree
+    if (this.location === true) // for CSN
+      return args;
     return {
       op: { val: (isNary ? 'nary' : 'ixpr'), location: this.location },
       location: this.location,