@sap/cds-compiler 5.6.0 → 5.7.2

package/lib/json/from-csn.js

@@ -486,6 +486,7 @@ const schema = compileSchema( {
   val: {
     type: value,
     inKind: [ '$column', 'enum' ],
+    xorException: '#',          // see xorGroup :expr
     // see also extra handling for 'element' in extension, see definition()
   },
   literal: {
@@ -499,6 +500,7 @@ const schema = compileSchema( {
     // Note: We emit a warning if '#' is used in enums.  Because the compiler
     // can generate CSN like this, we need to be able to parse it.
     inKind: [ '$column', 'enum' ],
+    xorException: 'val',        // see xorGroup :expr
     // see also extra handling for 'element' in extension, see definition()
   },
   path: {                     // in CSN v0.1.0 'foreignKeys'

package/lib/json/to-csn.js

@@ -1132,7 +1132,7 @@ function value( node ) {
     return extra( { '=': node.variant ? `${ ref }#${ pathName(node.variant.path) }` : ref }, node );
   }
   if (node.literal === 'enum')
-    return extra( { '#': node.sym.id }, node );
+    return enumValue( node );
   if (node.literal === 'array')
     return node.val.map( value );
   if (node.literal === 'token' && node.val === '...')
@@ -1146,6 +1146,15 @@ function value( node ) {
   return r;
 }
 
+function enumValue( node ) {
+  const r = extra( { '#': node.sym.id }, node );
+  const sym = node.sym._artifact;
+  // add calculated `val`, but not for chained symbols:
+  if (sym && (!gensrcFlavor || gensrcFlavor === 'column') && !sym.value?.sym)
+    r.val = sym.value ? sym.value.val : sym.name.id;
+  return r;
+}
+
 function targetElement( val, csn, node ) {
   const key = addExplicitAs( { ref: val.path.map( pathItem ) },
                              node.name, neqPath( val ) );
@@ -1210,10 +1219,10 @@ function exprInternal( node, xprParens ) {
     return extra( { ref }, node );
   }
   if (node.literal) {
-    if (typeof node.val === node.literal || node.val === null)
+    if (node.literal === 'enum')
+      return enumValue( node );
+    else if (typeof node.val === node.literal || node.val === null)
       return extra( { val: node.val }, node );
-    else if (node.literal === 'enum')
-      return extra( { '#': node.sym.id }, node );
     else if (node.literal === 'token')
       return node.val;          // * in COUNT(*)
     return extra( { val: node.val, literal: node.literal }, node );

package/lib/language/docCommentParser.js

@@ -7,7 +7,6 @@ const {
 } = require('./textUtils');
 
 const fencedCommentRegEx = /^\s*[*]/;
-const footerFenceRegEx = /\s*[*]+\/$/;
 const hasContentOnFirstLineRegEx = /\/\*+\s*\S/;
 
 /**
@@ -37,9 +36,8 @@ function parseDocComment( comment ) {
   if (lines.length === 1) {
     // Special case for one-liners.
     // Remove "/***/" and trim white space and asterisks.
-    const content = lines[0]
-      .replace(/^\/[*]{2,}/, '')
-      .replace(/\**\/$/, '') // for `/*****/`, only `/` remains
+    let content = lines[0].replace(/^\/[*]{2,}/, '');
+    content = removeFooterFence(content) // for `/*****/`, only `/` remains
       .replace('*\\/', '*/') // escape sequence
       .trim();
     return isWhitespaceOrNewLineOnly(content) ? null : content;
@@ -153,7 +151,15 @@ function removeHeaderFence( line ) {
  * @returns {string} header without fence
  */
 function removeFooterFence( line ) {
-  return line.replace(footerFenceRegEx, '');
+  let trimAt = line.length - 1;
+  // '-1': remove trailing `/`
+  for (let i = trimAt - 1; i >= 0 && line[i] === '*'; --i)
+    trimAt = i;
+  // We know that trimAt is at a '*', regardless of whether the previous loop ran.
+  for (let i = trimAt - 1; i >= 0 && /^\s$/.test(line[i]); --i)
+    trimAt = i;
+  // Either trimAt is a ' ' or '*', regardless of whether any loop ran.
+  return line.slice(0, trimAt);
 }
 
 /**

package/lib/language/errorStrategy.js

@@ -235,9 +235,9 @@ function singleTokenDeletion( recognizer ) {
     return null;
 
   const nextTokenType = recognizer.getTokenStream().LA(2);
-  const { Number } = recognizer.constructor;
-  if (nextTokenType > Number && // next token is Id|Unreserved|IllegalToken
-      token.type <= Number)     // current token is not
+  const { Number: num } = recognizer.constructor;
+  if (nextTokenType > num && // next token is Id|Unreserved|IllegalToken
+      token.type <= num)     // current token is not
     return null;
 
   const expecting = this.getExpectedTokens(recognizer);

package/lib/language/genericAntlrParser.js

@@ -1059,6 +1059,8 @@ function assignAnnotationValue( anno, value ) {
 }
 
 function relevantDigits( val ) {
+  // We know the value does not contain newlines, hence the RegEx is safe.
+  // eslint-disable-next-line sonarjs/slow-regex
   val = val.replace( /e.+$/i, '' );
 
   // To avoid the super-linear RegEx `0+$`, use the non-backtracking version and

package/lib/model/csnUtils.js

@@ -1014,7 +1014,12 @@ function getRootArtifactName( artifactName, csn ) {
 //   'foo' => 'foo';
 //   'foo::bar' => 'bar'
 function getLastPartOf( name ) {
-  return name.substring(name.search(/[^.:]+$/));
+  // Not using RegEx /[^.:]+$/ to avoid ReDoS.
+  for (let i = name.length - 1; i >= 0; --i) {
+    if (name[i] === '.' || name[i] === ':')
+      return name.substring(i + 1);
+  }
+  return name;
 }
 
 // Return the last part of reference array 'ref'

package/lib/optionProcessor.js

@@ -197,6 +197,7 @@ optionProcessor.command('H, toHana')
   .option('    --assert-integrity-type <type>', { valid: ['RT', 'DB'], ignoreCase: true })
   .option('    --pre2134ReferentialConstraintNames')
   .option('    --disable-hana-comments')
+  .option('    --standard-database-functions')
   .help(`
   Usage: cdsc toHana [options] <files...>
 
@@ -233,6 +234,7 @@ optionProcessor.command('H, toHana')
                                            DB : Create database constraints for associations
    --pre2134ReferentialConstraintNames   Do not prefix the constraint identifier with "c__"
    --disable-hana-comments    Disable rendering of doc comments as SAP HANA comments.
+   --standard-database-functions Enable rendering of standard database function mappings.
 `);
 
 optionProcessor.command('O, toOdata')
@@ -340,6 +342,7 @@ optionProcessor.command('Q, toSql')
   .option('    --better-sqlite-session-variables <bool>')
   .option('    --transitive-localized-views')
   .option('    --with-hana-associations <bool>', { valid: [ 'true', 'false' ] })
+  .option('    --standard-database-functions')
   .help(`
   Usage: cdsc toSql [options] <files...>
 
@@ -399,9 +402,10 @@ optionProcessor.command('Q, toSql')
    --transitive-localized-views  If set, the backends will create localized convenience views for
                               those views, that only have an association to a localized entity/view.
    --with-hana-associations <bool>
-                              Enable and disable rendering of "WITH ASSOCIATIONS" for sqlDialect 'hana'.
+                              Enable or disable rendering of "WITH ASSOCIATIONS" for sqlDialect 'hana'.
                                 true  : (default) Render "WITH ASSOCIATIONS"
                                 false : Do not render "WITH ASSOCIATIONS"
+   --standard-database-functions Enable rendering of standard database function mappings.
 `);
 
 optionProcessor.command('toRename')

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,11 +37,18 @@ 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 };
+  leanConditions = { afterBrace: true, fail: true };
 
   constructor( lexer, keywords, table, options, messageFunctions ) {
     super( lexer, keywords, table ); // lexer has file
@@ -86,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,
@@ -100,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;
   }
 
   /**
@@ -116,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()' );
     }
@@ -139,7 +153,7 @@ class AstBuildingParser extends BaseParser {
     const noQuery = parenthesesCtx?.[0];
     if (arg && parenthesesCtx)
       parenthesesCtx[0] = arg;
-    return !noQuery;
+    return noQuery;
   }
 
   prepareSpecialFunction() {
@@ -187,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');
   }
 
   /**
@@ -202,38 +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 ) {
+  notAfterEntityArgOrFilter( mode ) { // TODO: for <hide>
     if (mode !== 'M')
-      return true;
+      return false;
     const { type } = this.lb();
     if (type !== ')' && type !== ']')
-      return true;
+      return false;
     const { followState } = this.stack.at( -1 );
-    return !this.table[followState][':'];
+    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 !== '=>';
   }
 
   /**
@@ -241,45 +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$;
-    // TODO: should we use (text of) syntax-unexpected-assoc somewhere ?
+      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 null;
+    return true;
+  }
+
+  nestedExpand( mode ) {
+    if (!mode)
+      this.nestedExpand$ = this.tokenIdx;
+    return this.nestedExpand$ !== this.tokenIdx;
+  }
+  nestedExpandError() {
+    // This is intentionally left empty
   }
 
   /**
@@ -299,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
@@ -321,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
@@ -336,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;
       }
@@ -347,17 +398,34 @@ 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 true;
-    if (mode === 'M')
       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;
+    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 = '[…]';
   }
 
   /**
@@ -366,21 +434,25 @@ class AstBuildingParser extends BaseParser {
    *
    * Beware: mentioned in leanConditions, i.e. executed in predictions!
    */
-  afterBrace( test ) {
-    if (!test)
-      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 true;
+      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 true;
-    return this.afterBrace$ === this.tokenIdx;
+      return false;
+    return this.afterBrace$ !== this.tokenIdx;
   }
 
   /**
@@ -389,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;
   }
 
   /**
@@ -405,21 +477,39 @@ 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 !== ':';
+  }
+
+  fail( mode ) {
+    // TODO TOOL: the following test belongs to the BaseParser.js:
+    if (this.conditionTokenIdx === this.tokenIdx &&        // tested on same
+        this.conditionStackLength == null && // after error recover
+        mode !== 'M')
+      return false;
+    return true; //  mode !== 'Y';
   }
 
   // Space handling etc, locations ----------------------------------------------
@@ -635,12 +725,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 ) {
@@ -898,7 +985,7 @@ class AstBuildingParser extends BaseParser {
     return target;
   }
 
-  // TODO: as condition
+  // see also <guard=nestedExpand>
   reportExpandInline( column, isInline ) {
     // called before matching `{`
     if (column.value && !column.value.path) {
@@ -1129,7 +1216,7 @@ class AstBuildingParser extends BaseParser {
     };
   }
 
-  // TODO: as condition
+  // no extra message syntax-unexpected-assoc for guard failure
   associationInSelectItem( art ) {
     if (art.name)
       return;
@@ -1348,15 +1435,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( /\./, '' );
 }