@sap/cds-compiler 5.4.4 → 5.5.2

package/lib/parsers/AstBuildingParser.js

@@ -70,37 +70,34 @@ class AstBuildingParser extends BaseParser {
     return this.$messageFunctions.info( id, location?.location || location, args, text );
   }
 
-  expectingArray( token ) {
-    const expecting = this._expecting( token );
-    let array = Object.keys( expecting );
-    // compatibility: replace true+false by Boolean
-    if (expecting.true && expecting.false)
+  expectingArray() {
+    const savedState = this.s;
+    this.s = this.errorState;
+    let array = this.expectingArray_();
+    this.s = savedState;
+    // compatibility: replace true+false by Boolean - TODO: delete
+    if (array.includes( 'true' ))
       array = [ 'Boolean', ...array.filter( n => n !== 'true' && n !== 'false' ) ];
-    return array.map( antlrName )
+    return array.map( tok => this.antlrName( tok ) )
       .sort( (a, b) => (tokenPrecedence(a) < tokenPrecedence(b) ? -1 : 1) );
   }
 
-  reportUnexpectedToken_( token ) {
-    const expecting = this.expectingArray( token );
+  reportUnexpectedToken_() {
+    const token = this.la();
+    const expecting = this.expectingArray();
     const err = this.error( 'syntax-unexpected-token', token,
-                            { offending: antlrName( token ), expecting } );
+                            { offending: this.antlrName( token ), expecting } );
     // No 'unwanted' variant, no 'syntax-missing-token'
     err.expectedTokens = expecting;
   }
-  reportReservedWord_( token ) {
+  reportReservedWord_() {
+    const token = this.la();
     const err = this.message( 'syntax-unexpected-reserved-word', token,
                               { code: token.text, delimited: token.text } );
     // TODO: at least if one expected keyword is similar, mention expected set
     err.expectedTokens = this.expectingArray();
   }
 
-  reportInternalError_( token ) {
-    this.error( null, token, { offending: antlrName( token ) },
-                'Mismatched $(OFFENDING); skipped one token' );
-    // TMP: should not happen anymore → remove method in redepage
-    throw new Error( 'Repeated error reporting with same token' );
-  }
-
   tableWithoutAs() {
     // TODO TOOL: if the tool properly creates `default: this.giR()`, this
     // condition method is most likely not necessary
@@ -180,7 +177,7 @@ class AstBuildingParser extends BaseParser {
     return this.lGenericIntroOrExpr( false );
   }
 
-  lGenericSeparator() {
+  lGenericSeparator() {         // TODO: { keyword, type } as arg ?
     const { keyword, type } = this.la();
     // TODO: use lower-case in specialFunctions
     const text = typeof keyword === 'string' ? keyword.toUpperCase() : type;
@@ -191,7 +188,7 @@ class AstBuildingParser extends BaseParser {
   translateParserToken_( tokenName ) {
     const realTokens = this.dynamic_.generic?.[parserTokens[tokenName]];
     // TODO: avoid parserTokens dict, use lower-case in specialFunctions
-    return realTokens?.map( s => s.toLowerCase() ) ?? [];
+    return realTokens?.map( s => s.toLowerCase() ) ?? [ tokenName ];
   }
 
   inSelectItem( _test, arg ) {  // only as action
@@ -211,14 +208,14 @@ class AstBuildingParser extends BaseParser {
       return true;
     // TODO: it would be best to set this.dynamic_.inSelectItem to null in filters
     // (as <prepare>)
-    const next = this.tokens[this.tokenIdx + 1].type;
+    const next = this.tokens[this.tokenIdx + 1]?.type;
     return next !== '*' && next !== '{';
   }
 
   // <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 );
   }
 
@@ -261,13 +258,13 @@ class AstBuildingParser extends BaseParser {
    *
    * Called as <prepare=…>:
    *
-   * - <…, arg=default> in `returnsSpec`: after `returns`
-   *   disallow `default` in `typeExpression`
    * - <…,arg=elem> in `elementDef` (before calling `typeExpression`):
    *   allow `default`/`= calcExpr` with final annotation assignments,
    *   delay final doc comment
+   * - <…, arg=default> in `returnsSpec`: after `returns`
+   *   disallow `default` in `typeExpression`
    * - <…, arg=calc> in `typeExpression` (with associations, etc)
-   *   now disallow `= calcExpr` (with annotation assignments) in `elementDef`,
+   *   now disallow `= calcExpr` in `elementDef`,
    *   do not delay final doc comments anymore
    * - <…, arg=anno> in `typeExpression` after enums:
    *   now disallow annotation assignments after `= calcExpr`,
@@ -275,25 +272,48 @@ class AstBuildingParser extends BaseParser {
    *
    * Called as <cond=…>:
    *
-   * - <…, arg=default> in `nullabilityAndDefault`:
-   *   is `default` allowed?  If used, disallow calc (with anno assignments)
+   * - <…, arg=default> in `typeExpression` and `typeProperties`
+   *   is `default` allowed?  If used, disallow calc and further DEFAULT
+   * - <…, arg=notNull> in `typeExpression` and `typeProperties`
+   *   is `null`/`not null` allowed? ensures that it is only used once
    * - <…, arg=calc> in `elementDef`:
-   *   is `= calcExpr` allowed?  If so, check for final doc
+   *   is `= calcExpr` allowed? not with struct, assoc or MANY…
    * - <…, arg=anno> in `elementDef`:
-   *   are annotation assignments after `= calcExpr` allowed?
+   *   are annotation assignments after `= calcExpr` allowed? not with ENUM…
+   *
+   * The value of the dynamic var `elementCtx` looks like [REJECTED, DEFAULT,
+   * NOTNULL] where
+   *
+   * - REJECTED is the string containing a to-be-rejected test `arg`
+   * - DEFAULT: true if `default` had been provided
+   * - NOTNULL: true if `null` or `not null` had been provided
    */
   elementRestriction( test, arg ) {
-    const { elementCtx } = this.dynamic_;
+    let { elementCtx } = this.dynamic_;
     if (test) {
-      if (!elementCtx || elementCtx[0] === arg)
-        return !elementCtx;
+      if (elementCtx?.[0] === arg)
+        return false;
+      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;
+        elementCtx[1] = true;
         elementCtx[0] = 'calc';
         this.prec_ = PRECEDENCE_OF_EQUAL; // only expressions for DEFAULT expr
       }
+      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
+        }
+        elementCtx[2] = this.la().keyword;
+      }
     }
     else if (arg === 'elem' || arg === 'default') {
-      this.dynamic_.elementCtx = [ arg ];
+      this.dynamic_.elementCtx = [ arg, false, false ];
     }
     else if (elementCtx) {
       elementCtx[0] = arg;
@@ -301,10 +321,6 @@ class AstBuildingParser extends BaseParser {
     return true;
   }
 
-  inExpandInline() {            // not as <cond>
-    this.dynamic_.inSelectItem = 'nested';
-  }
-
   /**
    * `;` between statements is optional only after a `}` (ex braces of structure
    * values for annotations).
@@ -338,8 +354,11 @@ class AstBuildingParser extends BaseParser {
       const { arrayAnno } = this.dynamic_;
       if (!arrayAnno[0])
         return false;
-      if (this.tokens[this.tokenIdx + 1]?.type === ',')
-        arrayAnno[0] = false;
+      arrayAnno[0] = this.tokens[this.tokenIdx + 1]?.keyword;
+    }
+    else if (arg === 'bracket') {
+      // closing bracket not allowed if last `...` in array is with `up to
+      return typeof this.dynamic_.arrayAnno[0] !== 'string';
     }
     else {                      // orNotEmpty
       return this.dynamic_.arrayAnno || this.lb().type !== '{';
@@ -737,22 +756,10 @@ class AstBuildingParser extends BaseParser {
    *  - misplaced doc comments would lead to a parse error (incompatible),
    *  - would influence the prediction and error recovery,
    *  - is only slightly "more declarative" in the grammar.
-   *
-   * With argument `delayed`, potentially delay the doc processing.
-   * See also `elementRestriction`.
    */
-  docComment( art, delayed = undefined ) {
-    if (delayed !== this.dynamic_?.[0]) {
-      if (delayed === 'type')
-        return;
-    }
-    else if (delayed === 'elem') {
-      this.dynamic_[0] = 'type';
-      return;
-    }
-
+  docComment( art ) {
     const { line: prevLine, col: prevCol } = this.lb()?.location ?? { line: 0, col: 0 };
-    const { line: currLine, col: currCol } = this.la().location;
+    const { line: currLine, col: currCol } = (this.la() ?? this.lb()).location;
     let token;
     for (;;) {
       token = this.docComments[this.docCommentIndex];
@@ -783,16 +790,20 @@ class AstBuildingParser extends BaseParser {
     }
   }
 
+  // TODO: can we remove `;`/EOF from the expected-set for `annotate Foo with ⎀`?
   checkWith( keyword ) {
     if (this.lb() !== keyword)
       return;
     const tok = this.la();
-    if (this.docCommentIndex < tok.location.tokenIndex &&
-        this.docCommentIndex > this.lb().location.tokenIndex)
+    const docTokenIndex = this.docCommentIndex &&
+          this.docComments[this.docCommentIndex - 1].location.tokenIndex;
+    if (docTokenIndex < tok.location.tokenIndex &&
+        docTokenIndex > this.lb().location.tokenIndex)
       return;
-    const expecting = this.expectingArray(); // TODO: filter
+    // filter out what comes after current rule (no generic way necessary):
+    const expecting = this.expectingArray().filter( t => t !== '<EOF>' && t !== '\'}\'' );
     const msg = this.warning( 'syntax-unexpected-semicolon', tok,
-                              { offending: antlrName( tok ), expecting, keyword: 'with' },
+                              { offending: this.antlrName( tok ), expecting, keyword: 'with' },
                               // eslint-disable-next-line @stylistic/js/max-len
                               'Unexpected $(OFFENDING), expecting $(EXPECTING) - ignored previous $(KEYWORD)' );
     msg.expectedTokens = expecting;
@@ -801,13 +812,16 @@ class AstBuildingParser extends BaseParser {
   setNullability( art, val, location = this.lb().location ) {
     const notNull = { val, location };
     if (art.notNull) {
-      this.reportDuplicateClause( 'notNull', art.notNull, notNull,
+      // complain about the second
+      this.reportDuplicateClause( 'notNull', notNull, art.notNull,
                                   (val ? 'not null' : 'null') );
     }
-    art.notNull = notNull;
+    else {
+      art.notNull = notNull;
+    }
   }
 
-  setAssocAndComposition( art, assoc, card, target ) {
+  setAssocAndComposition( art, assoc, card, target = {} ) {
     const { location } = assoc;
     art.type = {
       path: [ { id: keywordTypeNames[assoc.keyword], location } ],
@@ -816,7 +830,7 @@ class AstBuildingParser extends BaseParser {
     };
     art.target = target;
     if (!card)
-      return;
+      return target;
 
     const targetMax = (card.keyword === 'one')
       ? { val: 1, literal: 'number', location: card.location }
@@ -829,17 +843,19 @@ class AstBuildingParser extends BaseParser {
     else {
       art.cardinality = { targetMax, location: targetMax.location };
     }
+    return target;
   }
 
   reportExpandInline( column, isInline ) {
+    // called before matching `{`
     const { name } = column;
     if (column.value && !column.value.path) {
-      const token = this.la();
       // improve error location when using "inline" `.{…}` after ref (arguments and
       // filters not covered, not worth the effort); after an expression where
       // the last token is an identifier, not the `.` is wrong, but the `{`:
-      // if (isInline && !name && this._input.LT(-1).type >= this.constructor.Identifier)
-      //   token = this._input.LT(2); -- TODO: still valid?
+      const token = (isInline && this.tokens[this.tokenIdx - 2].type !== 'Id')
+        ? this.lb()
+        : this.la();
       this.error( 'syntax-unexpected-nested-proj', token,
                   { code: isInline ? '.{ ‹inline› }' : '{ ‹expand› }' },
                   'Unexpected $(CODE); nested projections can only be used after a reference' );
@@ -868,9 +884,10 @@ class AstBuildingParser extends BaseParser {
       col: chosen.location.col,
     };
     if (erroneous.val === chosen.val) {
+      // TODO v6: duplicate clause = error, independently whether it is the same
       this.warning( 'syntax-duplicate-equal-clause', erroneous.location, args );
     }
-    else {
+    else if (prop !== 'notNull') { // already via guard in grammar
       if (literalValIfNotEq)
         args.code = chosen.val;
       this.message( 'syntax-duplicate-clause', erroneous.location, args );
@@ -1277,6 +1294,17 @@ class AstBuildingParser extends BaseParser {
                             parent, 'elements', kind, seg );
     }
   }
+
+  // For compatibility with ANTLR-based parser:
+  antlrName( type ) {
+    if (typeof type !== 'string') {
+      type = (!type.parsedAs && this.keywords[type.keyword ?? ''] != null ||
+              type.parsedAs === 'keyword') && type.keyword || type.type;
+    }
+    if (/^[A-Z]+/.test( type ))// eslint-disable-next-line no-nested-ternary
+      return (type === 'Id') ? 'Identifier' : (type === 'EOF') ? '<EOF>' : type;
+    return (/^[a-z]+/.test( type )) ? type.toUpperCase() : `'${ type }'`;
+  }
 }
 
 function addOneForDefinition( count, ext ) {
@@ -1299,15 +1327,6 @@ function relevantDigits( val ) {
 }
 
 
-// For compatibility with ANTLR-based parser:
-function antlrName( type ) {
-  if (typeof type !== 'string')
-    type = (!type.parsedAs || type.parsedAs === 'keyword') && type.keyword || type.type;
-  if (/^[A-Z]+/.test( type ))// eslint-disable-next-line no-nested-ternary
-    return (type === 'Id') ? 'Identifier' : (type === 'EOF') ? '<EOF>' : type;
-  return (/^[a-z]+/.test( type )) ? type.toUpperCase() : `'${ type }'`;
-}
-
 // Used for sorting in messages (TODO: make it part of messages.js?)
 const token1sort = {
   // 0: Identifier, Number, ...