@sap/cds-compiler 5.5.2 → 5.6.0

package/CHANGELOG.md

@@ -7,6 +7,17 @@
 Note: `beta` fixes, changes and features are usually not listed in this ChangeLog but [here](doc/CHANGELOG_BETA.md).
 The compiler behavior concerning `beta` features can change at any time without notice.
 
+## Version 5.6.0 - 2024-12-12
+
+### Added
+
+- Allow to refer to draft state element `HasActiveEntity` and `HasDraftEntity` via variable `$draft` in annotation path expressions.
+- for.odata|to.edm(x): Introduce annotating the generated foreign keys
+
+### Changed
+
+- Update OData vocabularies: 'Common', 'EntityRelationship', 'UI'
+
 ## Version 5.5.2 - 2024-12-02
 
 ### Fixed
@@ -131,7 +142,7 @@ The compiler behavior concerning `beta` features can change at any time without
 ### Added
 
 - cdsc: Option `--stdin` was added to support input via standard input, e.g. `cat file.cds | cdsc --stdin`
-- Allow to refer to draft state element `IsActiveEntity` via magic variable `$draft.IsActiveEntity` in annotation path expressions.
+- Allow to refer to draft state element `IsActiveEntity` via variable `$draft.IsActiveEntity` in annotation path expressions.
   + for.odata: During draft augmentation `$draft.IsActiveEntity` is rewritten to `$self.IsActiveEntity` for all draft enabled
     entities (root and sub nodes but not for named types or entity parameters).
   + to.edm(x): (V4 only) Allow to refer to an entity element in a bound action via `$self` and not only via explicit binding parameter

package/bin/cdsse.js

@@ -158,6 +158,9 @@ function tokensAt( buf, _offset, col, symbol ) {
     else if (/^[A-Z_]+$/.test( n )) {
       console.log( n.toLowerCase(), 'keyword' );
     }
+    else if (n === 'Boolean') {
+      console.log( 'true keyword\nfalse keyword' );
+    }
     else if (n !== 'Identifier') {
       console.log( n, 'unknown' );
     }

package/lib/base/message-registry.js

@@ -1271,6 +1271,8 @@ const centralMessageTexts = {
     'magic': 'Unexpected magic variable $(ELEMREF) in $(ANNO)',
     'bparam_v2_expl': 'Unexpected explicit binding parameter path $(ELEMREF) for OData $(VERSION) in $(ANNO)',
     'bparam_v2_impl': 'Unexpected implicit binding parameter path $(ELEMREF) for OData $(VERSION) in $(ANNO)',
+    // forOdata/generateForeignKeys
+    'fk_substitution': 'Expected foreign key path $(ELEMREF) in $(ANNO) to end in a scalar typed leaf element',
   },
   // -----------------------------------------------------------------------------------
   // OData Message section ends here, no messages below this line

package/lib/compiler/builtins.js

@@ -206,6 +206,8 @@ const magicVariables = {
   $draft: {
     elements: {
       IsActiveEntity: {},
+      HasActiveEntity: {},
+      HasDraftEntity: {},
     },
     // Require that elements are accessed, i.e. no $draft, only $draft.<element>.
     $requireElementAccess: true,

package/lib/edm/annotations/vocabularyDefinitions.js

@@ -18,6 +18,7 @@
    Common (published)
    Communication (published)
    DataIntegration (published)
+   EntityRelationship (experimental)
    Graph (published, experimental)
    Hierarchy (published, experimental)
    HTML5 (published, experimental)
@@ -75,6 +76,11 @@ const vocabularyDefinitions = {
     inc: { Alias: 'DataIntegration', Namespace: 'com.sap.vocabularies.DataIntegration.v1' },
     int: { filename: 'DataIntegration.xml' },
   },
+  EntityRelationship: {
+    ref: { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/EntityRelationship.xml' },
+    inc: { Alias: 'EntityRelationship', Namespace: 'com.sap.vocabularies.EntityRelationship.v1' },
+    int: { filename: 'EntityRelationship.xml' },
+  },
   Graph: {
     ref: { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/Graph.xml' },
     inc: { Alias: 'Graph', Namespace: 'com.sap.vocabularies.Graph.v1' },

package/lib/gen/BaseParser.js

@@ -1,4 +1,4 @@
-// Base class for generated parser, for redepage v0.1.18
+// Base class for generated parser, for redepage v0.1.19
 
 'use strict';
 
@@ -32,6 +32,7 @@ class BaseParser {
   dynamic_ = {};                // TODO: extra class
   prec_ = null;
   $hasErrors = null;
+  leanConditions = {};
   // trace:
   trace = [];
 
@@ -163,6 +164,7 @@ class BaseParser {
       this._tracePush( [ 'E', true ] );
       return true;
     }
+    this._tracePush( [ 'E', 0 ] );
     const match = this._matchesInFollow( type, keyword, 'E' );
     // If the parser reaches this point with match = null, even the top-level rule
     // does not have a required token (typically `EOF`) at the end → the parser
@@ -203,8 +205,10 @@ class BaseParser {
   // cases
   giR( state, follow ) { // go to state (after trying to test again as identifier)
     const { keyword } = this.tokens[this.tokenIdx];
-    if (!keyword || this.keywords[keyword] ||
-        this._matchesInFollow( 'Id', keyword, 'R' ))
+    if (!keyword || this.keywords[keyword])
+      return this.g( state, follow );
+    this._tracePush( [ 'R', 0 ] );
+    if (this._matchesInFollow( 'Id', keyword, 'R' ))
       return this.g( state, follow );
     this.nextTokenAsId = true;
     return false;               // do not execute action after it
@@ -256,6 +260,8 @@ class BaseParser {
 
   // instead of c() for identifiers, used both with l() and lk()
   ci( state, ident = 'ident' ) {   // consume identifier token
+    if (this.tokenIdx === this.fixKeywordTokenIdx)
+      return this.e();
     const la = this.tokens[this.tokenIdx];
     if (this.keywords[la.keyword])
       this.reportReservedWord_();
@@ -385,95 +391,104 @@ class BaseParser {
     return true;
   }
 
-  // predicate used before rule call if with LL(1) conflict, 'Id' in other case
-  lP( first2 ) {             // only start rule if this predicate returns true
+  // predicate used before rule call (and called by `ckP` and `gP`) on keyword
+  // branch if with weak LL(1) conflict, i.e. there is an 'Id' branch or the
+  // default branch has `Id` in its first-set (TODO: or rule end, and `Id` is in
+  // follow-union)
+  lP( first2 ) {
     // nothing to check if not a non-reserved keyword:
     const { keyword: lk1 } = this.tokens[this.tokenIdx];
-    if (!lk1 || this.keywords[lk1] !== 0)
+    if (!lk1 || this.keywords[lk1] !== 0 || this.fixKeywordTokenIdx === this.tokenIdx)
       return true;
 
+    this._tracePush( [ 'K' ] );
     const { type: lt2, keyword: lk2 } = this.tokens[this.tokenIdx + 1];
-    // Argument first2 is just a performance hint with ckP():
+    if (lt2 === 'IllegalToken')
+      return true
+    // Argument first2 is just a performance hint:
     if (lk2 && first2?.[0] === 'Id' && !this.keywords[lk2] ||
         first2?.includes( lk2 || lt2 )) {
-      this._tracePush( [ 'K', true ] );
+      this._traceSubPush( true );
       return true;
     }
-    this._tracePush( [ 'K' ] );
     // now check it dynamically:
-    let cmd = this.table[this.s][lk1];
-    if (cmd[2] !== 1)
-      throw Error( `Unexpected command '${ cmd?.[0] }' without prediction at state ${ this.s } for ‘${ lk1 }’` );
+    if (this._walkPred( this.table[this.s][lk1], lk1, lt2, lk2 ))
+      return true;
+    this._tracePush( [ 'I' ] );
+    const choice = this.table[this.s];
+    if (!this._walkPred( choice.Id || choice[''], null, lt2, lk2 ))
+      return true;
+    this.nextTokenAsId = true;
+    return false;
+  }
 
-    // if not the keyword match, the command is “goto” or “rule call”
-    const savedState = this.s;
-    this.s = (cmd[0] === 'ck') ? cmd[1] : this._pred_keyword( cmd[1], lk1 );
+  _walkPred( cmd, lk1, lt2, lk2 ) {
+    const saved = this._saveForWalk();
+    const { length } = this.stack;
+    if (typeof cmd[0] !== 'number') // don't skip push to state with rule call
+      this.s = cmd[1];
+    if (cmd[0] !== (lk1 ? 'ck' : 'ci')) { // make the std case fast
+      let match1 = this._pred_next( 'Id', lk1, 'P' ); // TODO: really P for I?
+      if (!match1) {
+        if (lk1 || match1 === false) // assert for correct code generation
+          throw Error( `Cannot match first prediction token in rule at state ${ saved.s }` );
+        if (match1 == null) {
+          this._traceSubPush( 0 );  // TODO: make _pred_next push this
+          match1 = this._matchesInFollow( 'Id', lk1, 'I' );
+        }
+        else {
+          this._traceSubPush( false );
+        }
+        Object.assign( this, saved );
+        this.stack.length = length;
+        return !!match1;
+      }
+    }
 
+    this._traceSubPush( '' );   // between the two tokens
     ++this.tokenIdx;            // for user lookahead fns and conditions
-    const match = this._pred_next( lt2, lk2, 'K' );
+    let match2 = this._pred_next( lt2, lk2, (lk1 ? 'K' : 'I') );
+    if (match2 == null) {
+      this._traceSubPush( 0 );  // TODO: make _pred_next push this
+      match2 = !!this._matchesInFollow( lt2, lk2, (lk1 ? 'K' : 'I') );
+    }
+    else {
+      this._traceSubPush( match2 );
+    }
+    Object.assign( this, saved );
+    this.stack.length = length;
     --this.tokenIdx;
-    this.s = savedState;
-
-    const r = match ?? true;
-    if (match == null)
-      this._traceSubPush( 0 );
-    if (lt2 === 'IllegalToken')
-      return true
-    // TODO: instead of this IllegalToken test, implement a “confirm unreserved
-    // keyword as Id” prediction which tests whether the token after the then-Id
-    // matches.
-    this._traceSubPush( r );
-    if (!r)
-      this.nextTokenAsId = true;
-    return r;
+    return match2;
   }
 
   // Now the helper methods =====================================================
 
   // Standard weak-conflict predicate -------------------------------------------
 
-  _pred_keyword( state, keyword ) {
-    // returns state after matching the first token as keyword, for lP()
-    while (state) {
-      this._traceSubPush( state );
-      let cmd = this.table[state];
-      if (!Array.isArray( cmd ))
-        cmd = cmd[keyword] || cmd.Id || cmd[''];
-      switch (cmd[0]) {
-        case 'ck': case 'mk':
-          return cmd[1];        // state after token consumption
-        case 'g':               // TODO: another rule call?
-          break;
-        default:
-          if (typeof cmd[0] !== 'number')
-            throw Error( `Unexpected command ${ cmd[0] } at state ${ this.s }` );
-      }
-      state = cmd[1];
-    }
-    // reached end of rule without having consumed a token
-    throw Error( 'Not supported: option for unreserved keywords in follow set' );
-  }
-
-  _pred_next( type, keyword, mode ) { // mode = K | E | R | M
-    const useConditions = (mode === 'M'); // TODO: extra method with conditions ?
-    let hasEnteredRule = false;
+  _pred_next( type, keyword, mode ) { // mode = P | K | I | E | R | M
+    const properCall = (mode === 'P');
+    const lean = (mode !== 'M'); // TODO: extra method with conditions ?
+    // TODO: if false, use condition in this.leanConditions
+    let hasMatchedToken = null; // undecided yet → calculate on demand
     while (this.s) {
-      if (useConditions)
-        this._tracePush( this.s );
-      else
+      if (lean)
         this._traceSubPush( this.s );
+      else
+        this._tracePush( this.s ); // TODO: push new state instead
       let cmd = this.table[this.s];
       if (!Array.isArray( cmd )) {
         const lookahead = cmd[' lookahead'];
         const c = lookahead         // TODO: call with { keyword, type } ?
           ? cmd[this[lookahead]( mode )]
           : keyword && cmd[keyword] || cmd[type];
-        cmd = !(c && useConditions && this._rejectCondition( c, mode )) && c || cmd[''];
+        cmd = !(c && this._rejectCondition( c, mode, lean )) && c || cmd[''];
       }
+      const state = this.s;
+      this.s = cmd[1];
       switch (cmd[0]) {
         case 'c': case 'ck': case 'ckA': // TODO: re-check ckA
           return true;
-        case 'ciA':
+        case 'ciA':             // TODO: fixKeywordTokenIdx ?
           return mode !== 'R';
           // in the R prediction for optional `Id<reserved>` at rule end, only
           // alternative keyword matches are preferred, not identifier matches
@@ -481,7 +496,8 @@ class BaseParser {
           if (!keyword ||
               !this.keywords[keyword] && this.fixKeywordTokenIdx !== this.tokenIdx)
             return mode !== 'R';
-          cmd = this.table[this.s]['']; // is currently always 'g' or 'e'
+          cmd = this.table[state]['']; // is currently always 'g' or 'e'
+          this.s = cmd[1];
           break;
         case 'm':
           return type === cmd[2];
@@ -497,17 +513,27 @@ class BaseParser {
           break;
         default:
           if (typeof cmd[0] !== 'number')
-            throw Error( `Unexpected command ${ cmd[0] } at state ${ this.s }` );
+            throw Error( `Unexpected command ${ cmd[0] } at state ${ state }` );
           // If the parser enters a rule, reaching the rule end (can happen with
           // option `minTokensMatched`) means "no match".
-          hasEnteredRule = true;
+          hasMatchedToken = false;
           // If we want to support conditions before matching the first token in a
           // rule, we would have to handle `this.stack` and `this.dynamically_`.
+          if (properCall) {
+            // rule_() - TODO: also w/ conditions before matching first token
+            this.stack.push( {
+              ruleState: cmd[1],
+              followState: cmd[0],
+              tokenIdx: this.tokenIdx,
+              prec: this.prec_,
+            } );
+            this.dynamic_ = Object.create( this.dynamic_ );
+            this.prec_ = null;
+          }
       }
       // We could optimize with rule call - only 'Id' must be further investigated
       // TODO: actually also with `g`
       // in both cases if no condition is evaluated
-      this.s = cmd[1];
       // TODO <prepare=…, arg=…> for real trial run also before all returns
       // if (cmd[5])
       //   this.cmd[5]( cmd[4], mode );
@@ -522,28 +548,31 @@ class BaseParser {
     // prediction, the tool can normally omit the prediction (and output a
     // message), no so with `ruleStartingWithUnreserved`.  We will rather look
     // behind the current rule _after_ having decided that the token is to be
-    // matched as identifier.
-    return !hasEnteredRule && null; // let caller decide how to interpret this
+      // matched as identifier.
+    return (hasMatchedToken ?? this.tokenIdx > this.stack.at( -1 ).tokenIdx)
+      && null; // let caller decide how to interpret this
   }
 
-  _rejectCondition( cmd, mode ) {
+  _rejectCondition( cmd, mode, lean ) {
     const cond = cmd[3];
-    if (!cond)
+    if (!cond || lean && !this.leanConditions[cond])
       return false;
     if (!this.constructor.tracingParser)
       return !this[cond]( mode, cmd[4] );
-      // TODO: let this[cond]( true ) return recovery badness in error case
-    const { traceName } = this[cond];
-    this._tracePush( [ 'C', traceName?.call( this, cmd[4] ) ?? cond ] );
-    // calling the condition might have side effects (precendence conditions have)
-    // → call tracing “name” before
+    // TODO: let this[cond]( true ) return recovery badness in error case
+    if (!lean) {
+      const { traceName } = this[cond];
+      this._tracePush( [ 'C', traceName?.call( this, cmd[4] ) ?? cond ] );
+      // calling the condition might have side effects (precendence conditions have)
+      // → call tracing “name” before
+    }
     const fail = !this[cond]( mode, cmd[4] );
-    this._traceSubPush( !fail );
+    this._traceSubPush( lean ? { true: 'C✔', false: 'C✖' }[!fail] : !fail );
     return fail;
   }
 
   _matchesInFollow( type, keyword, mode ) { // mode = E | R
-    this._tracePush( [ mode, 0 ] );
+    // TODO: now also set stack!
     const savedState = this.s;
     // TODO: caching
     const { dynamic_ } = this;
@@ -564,9 +593,11 @@ class BaseParser {
   }
 
   _confirmExpected( token, saved ) { // mode = M
-    const [ type, keyword ] = (/^[_a-z]/.test( token )) ? [ 'Id', token ] : [ token ];
+    const fix = /^[_a-z]/.test( token );
+    const [ type, keyword ] = (fix) ? [ 'Id', token ] : [ token ];
     Object.assign( this.la(), { type, keyword } );
     this._cloneFromSaved( saved );
+    this.fixKeywordTokenIdx = fix && this.tokenIdx;
     this.trace = [];
     let match;
     while (this.stack.length) {
@@ -639,6 +670,8 @@ class BaseParser {
         for (const prop in dict) {
           if (prop && Object.hasOwn( dict, prop ) && prop !== 'Id' &&
               !Object.hasOwn( expecting, prop ) && prop.charAt(0) !== ' ') {
+            // TODO: or call this.translateParserToken_ always?
+            // it should then directly set the dictionary -> setTokenInSet_()
             if (lookahead) {    // yes, independently from ckA()
               for (const p of this.translateParserToken_( prop, lookahead ))
                 expecting[p] = val;
@@ -715,12 +748,14 @@ class BaseParser {
       delete set[type];         // delete Id if Id token or non-reserved keyword
 
     this._trace( 'collect tokens for message,' );
+    const { trace } = this;
     const saved = this._saveForWalk();
     const expecting = Object.keys( set )
       .filter( tok => this._confirmExpected( tok, saved ) );
     token.type = type;          // overwritten by _confirmExpected
     token.keyword = keyword;
     Object.assign( this, saved );
+    this.trace = trace;
     // TODO: also trace M(…) collection, extra line for each token, with condition
     return expecting;
   }
@@ -761,6 +796,7 @@ class BaseParser {
     // Continue parsing: ignore next predicate (TODO: except some specified ones?)
     this.conditionTokenIdx = this.tokenIdx;
     this.conditionStackLength = null;
+    this.fixKeywordTokenIdx = -1; // was set when collecting expecting-set
 
     // TODO: re-check for rule calls which are at the optional rule end:
     //   x: 'x not'; b: 'b'? x {console.log('x→b')} 'b'?; a: b {console.log('b→a')} 'a'
@@ -887,6 +923,9 @@ class BaseParser {
 
   // Predefined conditions with extra option names:
 
+  hide_( mode ) {
+    return mode !== 'M';
+  }
   precLeft_( _test, prec ) {    // <prec=…>, <…,assoc=left>, <…,prefix=once>
     const parentPrec = this.stack.at( -1 ).prec;
     if (parentPrec != null && parentPrec >= prec)