@sap/cds-compiler 5.5.2 → 5.7.0

package/lib/parsers/AstBuildingParser.js

@@ -9,6 +9,7 @@ const { functionsWithoutParentheses } = require('./identifiers');
 const { pathName } = require('../compiler/utils');
 const { quotedLiteralPatterns, specialFunctions } = require('../compiler/builtins');
 const parserTokens = { // TODO: precompile into specialFunction
+  __proto__: null,
   GenericIntro: 'intro',
   GenericExpr: 'expr',
   GenericSeparator: 'separator',
@@ -36,10 +37,19 @@ const queryOps = {
   minus: 'query',
 };
 
+const extensionsCode = {
+  __proto__: null,
+  definitions: 'extend … with definitions',
+  context: 'extend context',
+  service: 'extend service',
+};
+
 const PRECEDENCE_OF_IN_PREDICATE = 10;
 const PRECEDENCE_OF_EQUAL = 10;
 
 class AstBuildingParser extends BaseParser {
+  leanConditions = { afterBrace: true };
+
   constructor( lexer, keywords, table, options, messageFunctions ) {
     super( lexer, keywords, table ); // lexer has file
     this.options = options;
@@ -84,12 +94,18 @@ class AstBuildingParser extends BaseParser {
 
   reportUnexpectedToken_() {
     const token = this.la();
-    const expecting = this.expectingArray();
-    const err = this.error( 'syntax-unexpected-token', token,
-                            { offending: this.antlrName( token ), expecting } );
+    const args = { offending: this.antlrName( token ), expecting: this.expectingArray() };
+    const errorMethod = this.conditionTokenIdx === this.tokenIdx &&
+          this[`${ this.conditionName }Error`];
+    let err = errorMethod && errorMethod.call( this, args, token );
+    // TODO: should we set the msg variant always?  (→ no nestedExpandError necessary)
+    if (errorMethod && !err)
+      args['#'] ??= this.conditionName;
+    err ||= this.error( 'syntax-unexpected-token', token, args );
     // No 'unwanted' variant, no 'syntax-missing-token'
-    err.expectedTokens = expecting;
+    err.expectedTokens = args.expecting;
   }
+
   reportReservedWord_() {
     const token = this.la();
     const err = this.message( 'syntax-unexpected-reserved-word', token,
@@ -98,13 +114,13 @@ class AstBuildingParser extends BaseParser {
     err.expectedTokens = this.expectingArray();
   }
 
-  tableWithoutAs() {
+  tableWithoutAs() {            // not used in <guard=…>, only called by other guard
     // TODO TOOL: if the tool properly creates `default: this.giR()`, this
     // condition method is most likely not necessary
     const { keyword } = this.la();
     // TODO: if necessary, we could allow some keywords, and just make sure that
     // all JOIN variants are still possible
-    return !keyword || this.keywords[keyword] == null;
+    return keyword && this.keywords[keyword] != null;
   }
 
   /**
@@ -114,22 +130,22 @@ class AstBuildingParser extends BaseParser {
    *   recursive call, it can finally turn to be both a query or expr/table
    * - <prepare=queryOnLeft, arg=‹SomeVal›>: make the current parentheses
    *   context to be not a query anymore
-   * - <cond=queryOnLeft> tests whether the expression on the left is a query
-   * - <cond=queryOnLeft, arg=‹SomeVal›>: tests whether the expression on the
+   * - <guard=queryOnLeft> tests whether the expression on the left is a query
+   * - <guard=queryOnLeft, arg=‹SomeVal›>: tests whether the expression on the
    *   left is a query, then make the current context to be not a query anymore
-   * - <cond=queryOnLeft, arg=tableWithoutAs>: …after having checked
+   * - <guard=queryOnLeft, arg=tableWithoutAs>: …after having checked
    *   whether the next token is no (reserved or unreserved) keyword
    */
   queryOnLeft( test, arg ) {
     if (arg === 'tableWithoutAs') {
-      if (!this.tableWithoutAs())
-        return false;
+      if (this.tableWithoutAs())
+        return true;
     }
     else if (!arg && !test) {
       // provide new dynamic parentheses context, except with direct
       // recursive call:
       if (this.inSameRule_( this.s, this.stack.at( -1 ).followState ))
-        return true;
+        return false;
       this.dynamic_.parenthesesCtx = [ null ];
       this._tracePush( 'Parentheses()' );
     }
@@ -137,7 +153,7 @@ class AstBuildingParser extends BaseParser {
     const noQuery = parenthesesCtx?.[0];
     if (arg && parenthesesCtx)
       parenthesesCtx[0] = arg;
-    return !noQuery;
+    return noQuery;
   }
 
   prepareSpecialFunction() {
@@ -185,14 +201,21 @@ class AstBuildingParser extends BaseParser {
     return (generic === 'separator') ? 'GenericSeparator' : ',';
   }
 
-  translateParserToken_( tokenName ) {
-    const realTokens = this.dynamic_.generic?.[parserTokens[tokenName]];
-    // TODO: avoid parserTokens dict, use lower-case in specialFunctions
-    return realTokens?.map( s => s.toLowerCase() ) ?? [ tokenName ];
+  addTokenToSet_( set, tokenName, val, collectKeywordsOnly ) {
+    const realTokens = parserTokens[tokenName] && this.dynamic_.generic?.[parserTokens[tokenName]];
+    // TODO: avoid 2nd parserTokens dict use, use lower-case in specialFunctions
+    if (!realTokens) {
+      super.addTokenToSet_( set, tokenName, val, collectKeywordsOnly );
+    }
+    else {
+      for (const t of realTokens)
+        super.addTokenToSet_( set, t.toLowerCase(), val, collectKeywordsOnly );
+    }
   }
 
   inSelectItem( _test, arg ) {  // only as action
-    this.dynamic_.inSelectItem = arg;
+    this.dynamic_.inSelectItem = arg ||
+      (this.tokens[this.tokenIdx - 2].type === '.' ? 'inline' : 'expand');
   }
 
   /**
@@ -200,28 +223,47 @@ class AstBuildingParser extends BaseParser {
    * (also inside sub queries in those, which will be rejected later anyway)
    */
   modifierRestriction() {
-    return this.dynamic_.inSelectItem !== 'nested';
+    const { inSelectItem } = this.dynamic_;
+    // TODO: really reject for top-level "inline"?
+    return inSelectItem === 'expand' || inSelectItem === 'inline';
+  }
+  modifierRestrictionError( args, offending ) {
+    return this.error( 'syntax-unexpected-modifier', offending, args,
+                       // TODO: we would have text variant for expand or inline,
+                       // but we probably allow `key` in nested top-level inline
+                       'Unexpected $(OFFENDING) in nested expand/inline, expecting $(EXPECTING)' );
   }
 
   isDotForPath() {              // see also inSelectItem
+    // TODO: also consider whether we are in the <prefer>ed `valuePath` branch
     if (this.dynamic_.inSelectItem == null)
-      return true;
+      return false;
     // TODO: it would be best to set this.dynamic_.inSelectItem to null in filters
     // (as <prepare>)
     const next = this.tokens[this.tokenIdx + 1]?.type;
-    return next !== '*' && next !== '{';
+    return next === '*' || next === '{';
+  }
+
+  notAfterEntityArgOrFilter( mode ) { // TODO: for <hide>
+    if (mode !== 'M')
+      return false;
+    const { type } = this.lb();
+    if (type !== ')' && type !== ']')
+      return false;
+    const { followState } = this.stack.at( -1 );
+    return this.table[followState][':'];
   }
 
   // <prec=10, postfix=once> + test that the next token is not `null`; TODO: code
   // completion for `… default 3 not ~;` → currently just `null` but hey
   isNegatedRelation( _test, prec ) {
-    return this.tokens[this.tokenIdx + 1]?.keyword !== 'null' &&
+    return this.tokens[this.tokenIdx + 1]?.keyword === 'null' ||
       this.precNone_( _test, prec );
   }
 
   isNamedArg() {
-    const { type } = this.tokens[this.tokenIdx + 1];
-    return type === ':' || type === '=>';
+    const type = this.tokens[this.tokenIdx + 1]?.type;
+    return type !== ':' && type !== '=>';
   }
 
   /**
@@ -229,28 +271,66 @@ class AstBuildingParser extends BaseParser {
    * `namespace`
    */
   namespaceRestriction() {
-    return ++this.topLevel$ < 1;
+    return ++this.topLevel$ > 0;
   }
 
   /**
    * `extend`/`annotate` is forbidden inside `extend … with definitions` and
-   * variants
+   * variants.  TODO: combine with `vocabularyRestriction`.
    */
   extensionRestriction() {
-    // TODO: use `syntax-unexpected-extension` as message
+    // 'syntax-unexpected-extension': 'Unexpected $(KEYWORD) inside $(CODE) block',
     const r = this.dynamic_.inExtension;
-    this.dynamic_.inExtension = true;
-    return !r;
+    this.dynamic_.inExtension = this.tokenIdx + 1;
+    return r;
+  }
+  extensionRestrictionError( args, token ) {
+    const extendIdx = this.conditionFailure;
+    const variant = this.tokens[extendIdx + 1]?.type === 'Id' &&
+          this.tokens[extendIdx].keyword;
+    args.code = extensionsCode[variant] || extensionsCode.definitions;
+    args['#'] = 'new-parser';
+    return this.error( 'syntax-unexpected-extension', token, args );
   }
 
   /**
-   * `annotation` def is only allowed top-level
+   * `annotation` def is only allowed top-level. TODO: combine with `extensionRestriction`
    */
   vocabularyRestriction( test ) {
-    // TODO: use `syntax-unexpected-vocabulary` as message
     if (!test)
-      this.dynamic_.inBlock = true;
-    return !this.dynamic_.inBlock;
+      this.dynamic_.inBlock = this.tokenIdx;
+    return this.dynamic_.inBlock ?? this.dynamic_.inExtension;
+  }
+  vocabularyRestrictionError( args, token ) {
+    const extendIdx = this.conditionFailure;
+    args['#'] = `${ this.tokens[extendIdx - 1].keyword }-new`;
+    return this.error( 'syntax-unexpected-vocabulary', token, args );
+  }
+
+  /**
+   * Restrictions according to the expression of a select column.
+   * Currently only to restrict it to a single `Id` for published associations.
+   * No extra syntax-unexpected-assoc for failure.
+   */
+  columnExpr( mode, arg ) {
+    if (mode)
+      return !this.columnExpr$;
+    if (arg)
+      this.columnExpr$ = this.tokenIdx;
+    else if (this.columnExpr$ !== this.tokenIdx - 1 ||
+             this.lb().type !== 'Id' ||
+             [ 'true', 'false', 'null' ].includes( this.lb().keyword ) )
+      this.columnExpr$ = null;
+    return true;
+  }
+
+  nestedExpand( mode ) {
+    if (!mode)
+      this.nestedExpand$ = this.tokenIdx;
+    return this.nestedExpand$ !== this.tokenIdx;
+  }
+  nestedExpandError() {
+    // This is intentionally left empty
   }
 
   /**
@@ -270,7 +350,7 @@ class AstBuildingParser extends BaseParser {
    *   now disallow annotation assignments after `= calcExpr`,
    *   ignore doc comment after having called `typeExpression`
    *
-   * Called as <cond=…>:
+   * Called as <guard=…>:
    *
    * - <…, arg=default> in `typeExpression` and `typeProperties`
    *   is `default` allowed?  If used, disallow calc and further DEFAULT
@@ -292,14 +372,14 @@ class AstBuildingParser extends BaseParser {
     let { elementCtx } = this.dynamic_;
     if (test) {
       if (elementCtx?.[0] === arg)
-        return false;
+        return arg;
       if (!elementCtx) { // with type, param, or annotation defs
         // eslint-disable-next-line no-multi-assign
         elementCtx = this.dynamic_.elementCtx = [ null, false, false ];
       }
       if (arg === 'default') {
         if (elementCtx[1])
-          return false;
+          return true;
         elementCtx[1] = true;
         elementCtx[0] = 'calc';
         this.prec_ = PRECEDENCE_OF_EQUAL; // only expressions for DEFAULT expr
@@ -307,7 +387,7 @@ class AstBuildingParser extends BaseParser {
       else if (arg === 'notNull') {
         if (elementCtx[2]) {
           if (this.la().keyword !== elementCtx[2] || test === 'M') // TODO v6: always error
-            return false;       // error if different nullibility specification
+            return true;        // error if different nullibility specification
         }
         elementCtx[2] = this.la().keyword;
       }
@@ -318,17 +398,61 @@ class AstBuildingParser extends BaseParser {
     else if (elementCtx) {
       elementCtx[0] = arg;
     }
-    return true;
+    return false;
+  }
+  elementRestrictionError( args, token ) {
+    if (this.conditionFailure !== 'calc')
+      return null;
+    args.keyword = 'default';
+    // TODO: investigate why 'null', '@' are not in the expected-set
+    // TODO: simplified version for predictions, such that ops are in expected-set ?
+    // TODO: also test `default 3 null = 4`
+    return this.error( 'syntax-unexpected-calc', token, args,
+                       'Unexpected $(OFFENDING) after $(KEYWORD) clause, expecting $(EXPECTING)' );
+  }
+
+  noRepeatedCardinality( mode ) {
+    if (this.tokens[this.tokenIdx - 2]?.type !== ']')
+      return false;
+    if (mode === 'M')
+      return true;
+    // currently just warning if same cardinality provided twice
+    const same = { one: '1', many: '*' }[this.la().keyword];
+    return this.tokens[this.tokenIdx - 3]?.text !== same;
+  }
+  noRepeatedCardinalityError( args ) {
+    let openIdx = this.tokenIdx - 2;
+    while (this.tokens[--openIdx].type !== '[')
+      ;
+    args.location = this.tokens[openIdx].location;
+    args.code = '[…]';
   }
 
   /**
    * `;` between statements is optional only after a `}` (ex braces of structure
-   * values for annotations).
+   * values for annotations and foreign key specifications).
+   *
+   * Beware: mentioned in leanConditions, i.e. executed in predictions!
    */
-  afterBrace( test ) {
-    if (!test)
-      this.afterBrace$ = this.tokenIdx;
-    return this.afterBrace$ === this.tokenIdx;
+  afterBrace( test, arg ) {
+    if (!test) {
+      this.afterBrace$
+        = (!arg || this.afterBrace$ > 0 && this.tokens[this.afterBrace$ - 1].keyword === arg)
+          ? this.tokenIdx
+          : -1;
+    }
+    // TODO TOOL: the following test belongs to the BaseParser.js:
+    if (this.conditionTokenIdx === this.tokenIdx &&        // tested on same
+        this.conditionStackLength == null && // after error recover
+        test !== 'M')
+      return false;
+    // Strange optional `;` after PROJECTION ON source: the rule exit prediction
+    // for fromRefWithOptAlias etc now checks C(afterBrace):
+    if (test === 'E' && this.afterBrace$ > 0 &&
+        this.tokens[this.afterBrace$ - 1]?.keyword === 'projection' &&
+        this.tokens[this.afterBrace$].keyword === 'on')
+      return false;
+    return this.afterBrace$ !== this.tokenIdx;
   }
 
   /**
@@ -337,8 +461,8 @@ class AstBuildingParser extends BaseParser {
   annoInSameLine( test ) {
     if (!test)
       this.dynamic_.safeAnno = true;
-    return this.dynamic_.safeAnno ||
-      this.lb().location.line === this.la().location.line;
+    return !this.dynamic_.safeAnno &&
+      this.lb().location.line !== this.la().location.line;
   }
 
   /**
@@ -353,21 +477,30 @@ class AstBuildingParser extends BaseParser {
     else if (arg === 'ellipsis') { // on '...'
       const { arrayAnno } = this.dynamic_;
       if (!arrayAnno[0])
-        return false;
+        return arrayAnno[0] == null ? 'duplicate' : arg;
       arrayAnno[0] = this.tokens[this.tokenIdx + 1]?.keyword;
     }
-    else if (arg === 'bracket') {
+    else if (arg === 'bracket') { // syntax-invalid-ellipsis
       // closing bracket not allowed if last `...` in array is with `up to
-      return typeof this.dynamic_.arrayAnno[0] !== 'string';
+      return typeof this.dynamic_.arrayAnno[0] === 'string' && arg;
     }
-    else {                      // orNotEmpty
-      return this.dynamic_.arrayAnno || this.lb().type !== '{';
+    else {                      // orNotEmpty -> anno value must not be empty struct
+      return !this.dynamic_.arrayAnno && this.lb().type === '{' && 'empty';
     }
-    return true;
+    return false;
+  }
+  arrayAnnoError( args, token ) {
+    if (this.conditionFailure === 'duplicate') {
+      args['#'] = 'std';      // normal syntax-unexpected-token
+      return null;
+    }
+    args.code = '...';
+    args['#'] = this.conditionFailure;
+    return this.error( 'syntax-invalid-anno', token, args );
   }
 
   beforeColon() {
-    return this.tokens[this.tokenIdx + 1]?.text === ':';
+    return this.tokens[this.tokenIdx + 1]?.text !== ':';
   }
 
   // Space handling etc, locations ----------------------------------------------
@@ -583,12 +716,9 @@ class AstBuildingParser extends BaseParser {
       const tokenIndex = ref?.path.at(-1)?.location.tokenIndex;
       const token = this.prevTokenWithIndex( tokenIndex ) ?? this.tokens[this.tokenIdx - 1];
       const { parsedAs } = token;
-      if (parsedAs && parsedAs !== 'token' && parsedAs !== 'keyword') {
+      if (parsedAs && parsedAs !== 'token' && parsedAs !== 'keyword')
         token.parsedAs = category;
-        return { token, parsedAs };
-      }
     }
-    return null;
   }
 
   taggedIfQuery( query ) {
@@ -838,7 +968,7 @@ class AstBuildingParser extends BaseParser {
     // TODO: `literal` needed?
     if (art.cardinality) {
       this.reportDuplicateClause( 'cardinality', targetMax, art.cardinality.targetMax,
-                                  card.keyword, true );
+                                  card.keyword );
     }
     else {
       art.cardinality = { targetMax, location: targetMax.location };
@@ -846,9 +976,9 @@ class AstBuildingParser extends BaseParser {
     return target;
   }
 
+  // see also <guard=nestedExpand>
   reportExpandInline( column, isInline ) {
     // called before matching `{`
-    const { name } = column;
     if (column.value && !column.value.path) {
       // improve error location when using "inline" `.{…}` after ref (arguments and
       // filters not covered, not worth the effort); after an expression where
@@ -864,18 +994,9 @@ class AstBuildingParser extends BaseParser {
       // - no errors for refs inside expand/inline, but for refs in sibling expr
       // - think about: reference to these (sub) elements from other view
     }
-    if (isInline && name) {
-      const alias = this.tokens[this.tokenIdx - 2];
-      const location = (isInline === true)
-        ? alias.location
-        : this.combineLocation( isInline, alias );
-      this.error( 'syntax-unexpected-alias', location, { code: '.{ ‹inline› }' },
-                  'Unexpected alias name before $(CODE)' );
-      // continuation semantics: ignore AS
-    }
   }
 
-  reportDuplicateClause( prop, erroneous, chosen, code, literalValIfNotEq ) {
+  reportDuplicateClause( prop, erroneous, chosen, code ) {
     // probably easier for message linters not to use (?:) for the message id...?
     const args = {
       '#': prop,
@@ -887,11 +1008,7 @@ class AstBuildingParser extends BaseParser {
       // TODO v6: duplicate clause = error, independently whether it is the same
       this.warning( 'syntax-duplicate-equal-clause', erroneous.location, args );
     }
-    else if (prop !== 'notNull') { // already via guard in grammar
-      if (literalValIfNotEq)
-        args.code = chosen.val;
-      this.message( 'syntax-duplicate-clause', erroneous.location, args );
-    }
+    // TODO extra msg text 'syntax-duplicate-clause' for noRepeatedCardinality()
   }
 
   setTypeFacet( art, name, value ) {
@@ -1090,20 +1207,16 @@ class AstBuildingParser extends BaseParser {
     };
   }
 
+  // no extra message syntax-unexpected-assoc for guard failure
   associationInSelectItem( art ) {
+    if (art.name)
+      return;
     this.classifyImplicitName( 'ItemAssoc', art.value );
     const path = art.value?.path;
-    // we cannot compare "just one token before `:`" because there might be annos
-    if (path && path.length === 1 && !art.name && !art.expand && !art.inline) {
-      const name = path[0];
-      if (path.length === 1 && !name.args && !name.cardinality && !name.where) {
-        art.name = name;
-        delete art.value;
-        return;
-      }
+    if (path?.length) {
+      art.name = path.at( -1 ); // usually length 1, but make it also work during error recovery
+      delete art.value;
     }
-    this.error( 'syntax-unexpected-assoc', this.la(), {},
-                'Unexpected association definition in select item' );
   }
 
   // must be in action directly after having parsed '{', '(`, or a keyword before
@@ -1313,15 +1426,16 @@ function addOneForDefinition( count, ext ) {
 
 // Significant digits (before exponent) without leading and trailing zeros
 function relevantDigits( val ) {
+  // eslint-disable-next-line sonarjs/slow-regex
+  val = val.replace( /e.+$/i, '' ); // this regex has no newlines -> is not slow
+
   const init = /^[-+0.]+/g;     // global flag to have lastIndex
   const zeros = /[0.]+/g;
   if (init.test( val ))         // sets init.lastIndex
     zeros.lastIndex = init.lastIndex;
 
   let r;
-  while ((r = zeros.exec( val )) != null &&
-         zeros.lastIndex < val.length &&
-         val.charAt( zeros.lastIndex ).toLowerCase() !== 'e')
+  while ((r = zeros.exec( val )) != null && zeros.lastIndex < val.length)
     ;
   return val.slice( init.lastIndex, r?.index ).replace( /\./, '' );
 }