@sap/cds-compiler 5.5.0 → 5.6.0

package/lib/gen/Dictionary.json

@@ -1114,6 +1114,13 @@
       ],
       "$experimental": true
     },
+    "Common.WebSocketChannel": {
+      "Type": "Edm.String",
+      "AppliesTo": [
+        "EntityContainer"
+      ],
+      "$experimental": true
+    },
     "Communication.Contact": {
       "Type": "Communication.ContactType",
       "AppliesTo": [
@@ -1463,6 +1470,61 @@
         "EntitySet"
       ]
     },
+    "EntityRelationship.entityType": {
+      "Type": "Edm.String",
+      "AppliesTo": [
+        "EntityType"
+      ],
+      "$experimental": true
+    },
+    "EntityRelationship.propertyType": {
+      "Type": "Edm.String",
+      "AppliesTo": [
+        "Property"
+      ],
+      "$experimental": true
+    },
+    "EntityRelationship.entityIds": {
+      "Type": "Collection(EntityRelationship.entityId)",
+      "AppliesTo": [
+        "EntityType"
+      ],
+      "$experimental": true
+    },
+    "EntityRelationship.reference": {
+      "Type": "EntityRelationship.singleReference",
+      "AppliesTo": [
+        "Property"
+      ]
+    },
+    "EntityRelationship.compositeReferences": {
+      "Type": "Collection(EntityRelationship.compositeReference)",
+      "AppliesTo": [
+        "EntityType"
+      ],
+      "$experimental": true
+    },
+    "EntityRelationship.temporalIds": {
+      "Type": "Collection(EntityRelationship.temporalId)",
+      "AppliesTo": [
+        "EntityType"
+      ],
+      "$experimental": true
+    },
+    "EntityRelationship.temporalReferences": {
+      "Type": "Collection(EntityRelationship.temporalReference)",
+      "AppliesTo": [
+        "EntityType"
+      ],
+      "$experimental": true
+    },
+    "EntityRelationship.referencesWithConstantIds": {
+      "Type": "Collection(EntityRelationship.referencesWithConstantId)",
+      "AppliesTo": [
+        "EntityType"
+      ],
+      "$experimental": true
+    },
     "Graph.traceId": {
       "Type": "Edm.String",
       "$experimental": true
@@ -1719,6 +1781,7 @@
         "EntityType",
         "Action",
         "Function",
+        "ActionImport",
         "FunctionImport"
       ]
     },
@@ -1783,7 +1846,8 @@
       "Type": "Collection(UI.CriticalityLabelType)",
       "AppliesTo": [
         "Property",
-        "EntityType"
+        "EntityType",
+        "TypeDefinition"
       ],
       "$experimental": true
     },
@@ -1823,6 +1887,16 @@
         "EntityType"
       ]
     },
+    "UI.OperationParameterFacets": {
+      "Type": "Collection(UI.ReferenceFacet)",
+      "AppliesTo": [
+        "Action",
+        "Function",
+        "ActionImport",
+        "FunctionImport"
+      ],
+      "$experimental": true
+    },
     "UI.SelectionPresentationVariant": {
       "Type": "UI.SelectionPresentationVariantType",
       "AppliesTo": [
@@ -1878,14 +1952,16 @@
       "Type": "Core.Tag",
       "AppliesTo": [
         "Property",
-        "Term"
+        "Term",
+        "TypeDefinition"
       ]
     },
     "UI.IsImage": {
       "Type": "Core.Tag",
       "AppliesTo": [
         "Property",
-        "EntityType"
+        "EntityType",
+        "TypeDefinition"
       ],
       "$experimental": true
     },
@@ -1894,7 +1970,8 @@
       "AppliesTo": [
         "Property",
         "PropertyValue",
-        "Parameter"
+        "Parameter",
+        "TypeDefinition"
       ]
     },
     "UI.Placeholder": {
@@ -2070,7 +2147,8 @@
       "Type": "UI.RecommendationListType",
       "AppliesTo": [
         "Property",
-        "Parameter"
+        "Parameter",
+        "TypeDefinition"
       ]
     },
     "UI.Recommendations": {
@@ -2089,7 +2167,8 @@
     "UI.DoNotCheckScaleOfMeasuredQuantity": {
       "Type": "Edm.Boolean",
       "AppliesTo": [
-        "Property"
+        "Property",
+        "TypeDefinition"
       ],
       "$experimental": true
     },
@@ -3301,6 +3380,7 @@
       "Properties": {
         "SourceProperties": "Collection(Edm.PropertyPath)",
         "SourceEntities": "Collection(Edm.NavigationPropertyPath)",
+        "SourceEvents": "Collection(Edm.String)",
         "TargetProperties": "Collection(Edm.String)",
         "TargetEntities": "Collection(Edm.NavigationPropertyPath)",
         "EffectTypes": "Common.EffectType",
@@ -3777,6 +3857,105 @@
         "DELETE"
       ]
     },
+    "EntityRelationship.singleReference": {
+      "$kind": "ComplexType",
+      "Properties": {
+        "name": "Edm.String",
+        "referencedEntityType": "EntityRelationship.entityTypeID",
+        "referencedPropertyType": "EntityRelationship.propertyTypeID"
+      }
+    },
+    "EntityRelationship.entityId": {
+      "$kind": "ComplexType",
+      "Properties": {
+        "name": "Edm.String",
+        "description": "Edm.String",
+        "propertyTypes": "Collection(EntityRelationship.propertyTypeID)"
+      }
+    },
+    "EntityRelationship.compositeReference": {
+      "$kind": "ComplexType",
+      "Properties": {
+        "name": "Edm.String",
+        "referencedEntityType": "EntityRelationship.entityTypeID",
+        "referencedPropertyType": "Collection(EntityRelationship.referencedPropertyType)"
+      }
+    },
+    "EntityRelationship.referencedPropertyType": {
+      "$kind": "ComplexType",
+      "Properties": {
+        "referencedPropertyType": "EntityRelationship.propertyTypeID",
+        "localPropertyName": "Edm.PropertyPath"
+      }
+    },
+    "EntityRelationship.temporalId": {
+      "$kind": "ComplexType",
+      "Properties": {
+        "name": "Edm.String",
+        "description": "Edm.String",
+        "propertyTypes": "Collection(EntityRelationship.propertyTypeID)",
+        "temporalIntervalType": "EntityRelationship.temporalIntervalTypeEnum",
+        "temporalType": "EntityRelationship.temporalTypeEnum",
+        "temporalIntervalStartProperty": "Edm.PropertyPath",
+        "temporalIntervalEndProperty": "Edm.PropertyPath"
+      }
+    },
+    "EntityRelationship.temporalReference": {
+      "$kind": "ComplexType",
+      "Properties": {
+        "name": "Edm.String",
+        "referencedEntityType": "EntityRelationship.entityTypeID",
+        "referencedPropertyType": "Collection(EntityRelationship.referencedPropertyType)",
+        "category": "EntityRelationship.temporalCategoryEnum",
+        "selectionDateProperty": "Edm.PropertyPath"
+      }
+    },
+    "EntityRelationship.referenceWithConstantId": {
+      "$kind": "ComplexType",
+      "Properties": {
+        "name": "Edm.String",
+        "referencedEntityType": "EntityRelationship.entityTypeID",
+        "referencedPropertyType": "Collection(EntityRelationship.referencedPropertyTypeWithConstantId)"
+      }
+    },
+    "EntityRelationship.referencedPropertyTypeWithConstantId": {
+      "$kind": "ComplexType",
+      "Properties": {
+        "referencedPropertyType": "EntityRelationship.propertyTypeID",
+        "localPropertyName": "Edm.PropertyPath",
+        "constantValue": "Edm.String"
+      }
+    },
+    "EntityRelationship.temporalIntervalTypeEnum": {
+      "$kind": "EnumType",
+      "Members": [
+        "CLOSED_CLOSED",
+        "OPEN_OPEN",
+        "OPEN_CLOSED",
+        "CLOSED_OPEN"
+      ]
+    },
+    "EntityRelationship.temporalTypeEnum": {
+      "$kind": "EnumType",
+      "Members": [
+        "DATE",
+        "DATETIME"
+      ]
+    },
+    "EntityRelationship.temporalCategoryEnum": {
+      "$kind": "EnumType",
+      "Members": [
+        "TEMPORAL_DATE"
+      ]
+    },
+    "EntityRelationship.propertyTypeID": {
+      "$kind": "TypeDefinition",
+      "UnderlyingType": "Edm.String"
+    },
+    "EntityRelationship.entityTypeID": {
+      "$kind": "TypeDefinition",
+      "UnderlyingType": "Edm.String"
+    },
     "Graph.DetailsType": {
       "$kind": "ComplexType",
       "Properties": {

package/lib/model/cloneCsn.js

@@ -2,7 +2,7 @@
 
 const { csnPropertyOrder } = require('../json/to-csn');
 const { ModelError } = require('../base/error');
-const { setHidden } = require('../utils/objectUtils');
+const { setHidden, hasNonEnumerable } = require('../utils/objectUtils');
 const { isAnnotationExpression } = require('../base/builtins');
 
 const csnDictionaries = {
@@ -110,10 +110,6 @@ function cloneCsn( csn, options, sort ) {
   return r;
 }
 
-function hasNonEnumerable( object, property ) {
-  return Object.prototype.hasOwnProperty.call( object, property ) &&
-    !Object.prototype.propertyIsEnumerable.call( object, property );
-}
 
 /**
  * Deeply clone the given CSN dictionary and return it.

package/lib/parsers/AstBuildingParser.js

@@ -40,6 +40,8 @@ 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;
@@ -71,11 +73,14 @@ class AstBuildingParser extends BaseParser {
   }
 
   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) );
   }
 
@@ -83,7 +88,7 @@ class AstBuildingParser extends BaseParser {
     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;
   }
@@ -209,6 +214,16 @@ class AstBuildingParser extends BaseParser {
     return next !== '*' && next !== '{';
   }
 
+  notAfterEntityArgOrFilter( mode ) {
+    if (mode !== 'M')
+      return true;
+    const { type } = this.lb();
+    if (type !== ')' && type !== ']')
+      return true;
+    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 ) {
@@ -250,6 +265,23 @@ class AstBuildingParser extends BaseParser {
     return !this.dynamic_.inBlock;
   }
 
+  /**
+   * Restrictions according to the expression of a select column.
+   * Currently only to restrict it to a single `Id` for published associations.
+   */
+  columnExpr( mode, arg ) {
+    if (mode)
+      return this.columnExpr$;
+    // TODO: should we use (text of) syntax-unexpected-assoc somewhere ?
+    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;
+  }
+
   /**
    * Prepare element restrictions and check validility of final anno assignments.
    *
@@ -318,17 +350,36 @@ class AstBuildingParser extends BaseParser {
     return true;
   }
 
-  inExpandInline() {            // not as <cond>
-    this.dynamic_.inSelectItem = 'nested';
+  noRepeatedCardinality( mode ) {
+    if (this.tokens[this.tokenIdx - 2]?.type !== ']')
+      return true;
+    if (mode === 'M')
+      return false;
+    // currently just warning if same cardinality provided twice
+    const same = { one: '1', many: '*' }[this.la().keyword];
+    return this.tokens[this.tokenIdx - 3]?.text === same;
   }
 
   /**
    * `;` 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;
+    // 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;
+    // 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;
   }
 
@@ -355,8 +406,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 !== '{';
@@ -788,16 +842,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;
@@ -832,7 +890,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 };
@@ -840,15 +898,16 @@ class AstBuildingParser extends BaseParser {
     return target;
   }
 
+  // TODO: as condition
   reportExpandInline( column, isInline ) {
-    const { name } = column;
+    // called before matching `{`
     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' );
@@ -857,18 +916,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,
@@ -880,11 +930,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 ) {
@@ -1083,20 +1129,16 @@ class AstBuildingParser extends BaseParser {
     };
   }
 
+  // TODO: as condition
   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
@@ -1287,6 +1329,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 ) {
@@ -1309,15 +1362,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, ...