@sap/cds-compiler 6.4.6 → 6.5.0

package/lib/compiler/resolve.js

@@ -75,7 +75,6 @@ const $location = Symbol.for( 'cds.$location' );
 const $inferred = Symbol.for( 'cds.$inferred' );
 
 // TODO: make this part of specExpected in shared.js
-// (standard: not possible on last if !ref.$expected → ref.scope: '$exists')
 const expWithFilter = [ 'from', 'expand', 'inline' ];
 
 // Export function of this file.  Resolve type references in augmented CSN
@@ -1557,16 +1556,6 @@ function resolve( model ) {
   }
 
   function resolveExprPath( expr, expected, user ) {
-    // TODO: re-think this $expected: 'exists' thing
-    if (expr.$expected === 'exists') {
-      if (expected !== 'annotation') { // `exists e[…]` allowed in annotation expressions
-        error( 'expr-unexpected-exists', [ expr.location, user ], {},
-               'An EXISTS predicate is not expected here' );
-      }
-      // We complain about the EXISTS before, as EXISTS subquery is also not supported
-      // TODO: location of EXISTS, TODO: really do this in define.js
-      expr.$expected = 'approved-exists'; // only complain once
-    }
     const ref = resolvePath( expr, expected, user );
 
     if (expected === 'annotation') {
@@ -1588,9 +1577,10 @@ function resolve( model ) {
         last._navigation?.kind === '$tableAlias') // error already reported
       return ref;
 
-    if (expr.$expected === 'approved-exists') {
+    if (expr.$syntax === 'after-exists') {
       if (last.where?.args?.length === 0) {
         // at the moment, empty filter is not allowed on last path step
+        // TODO: allow it at some places
         reportUnexpectedArgsAndFilter( last, expected, user, null, 'last-empty-filter' );
       }
       return ref;

package/lib/compiler/shared.js

@@ -64,6 +64,17 @@ function fns( model ) {
       notFound: undefinedForAnnotate,
       accept: extendableArtifact,
     },
+    'annotate-sec': {
+      isMainRef: 'all',
+      lexical: userBlock,
+      dynamic: modelDefinitions,
+      notFound: undefinedDefinition,
+      messageMap: {
+        'ref-undefined-art': 'ext-undefined-art-sec',
+        'ref-undefined-def': 'ext-undefined-def-sec',
+      },
+      accept: extendableArtifact,
+    },
     extend: {
       isMainRef: 'no-generated',
       lexical: userBlock,
@@ -233,6 +244,7 @@ function fns( model ) {
       check: checkAssocOn,
       param: () => '$scopePar', // TODO: check that assocs containing param in ON is not published
     },
+    'rewrite-on': {},           // only for traversal when rewriting on condition
     'orderBy-ref': {
       lexical: tableAliasesAndSelf,
       dollar: true,
@@ -382,7 +394,7 @@ function fns( model ) {
     }
     if (expr.args) {
       const args = Array.isArray( expr.args ) ? expr.args : Object.values( expr.args );
-      for (const arg of args ) {
+      for (const arg of args) {
         if (traverseExpr( arg, exprCtx, user, callback ) === traverseExpr.STOP)
           return traverseExpr.STOP;
       }
@@ -1283,11 +1295,11 @@ function fns( model ) {
 
   // Functions called via semantics.notFound: -----------------------------------
 
-  function undefinedDefinition( user, item, valid, _dict, prev ) {
+  function undefinedDefinition( user, item, valid, _dict, prev, _path, semantics ) {
     // in a CSN source or for `using`, only one env was tested (valid.length 1) :
     const art = (!prev) ? item.id : searchName( prev, item.id, 'absolute' );
     signalNotFound( (valid.length > 1 ? 'ref-undefined-art' : 'ref-undefined-def'),
-                    [ item.location, user ], valid, { art } );
+                    [ item.location, user ], valid, { art }, semantics );
     // TODO: improve text, use text variant for: "or builtin" or "definitions" or none
   }
 
@@ -1876,8 +1888,9 @@ function fns( model ) {
     }
     const index = userTargetElementPathIndex( user, path );
     checkOnlyForeignKeyNavigation( user, path, index );
+    // TODO: did we check for no filter/args, no `exists` etc?
     const last = path[path.length - 1];
-    if (!last.where && ref._artifact?.on) { // filter already complained about
+    if (!last.where && ref._artifact?.on) { // filter already complained about - TODO: where?
       const target = index > 0 && index < path.length && ref._artifact?.target;
       const msg = (target?._artifact === user._main) ? 'self' : 'unmanaged';
       error( 'ref-unexpected-assoc', [ last.location, user ],
@@ -2016,7 +2029,7 @@ function fns( model ) {
   }
 
   function checkNoUnmanaged( ref, user, self, messageVariant = 'unmanaged' ) {
-    if (ref._artifact?.on && !ref.$expected) {
+    if (ref._artifact?.on && ref.$syntax !== 'after-exists') {
       const { path } = ref;
       const last = path[path.length - 1];
       if (self && last.where)   // already complained about filter

package/lib/compiler/tweak-assocs.js

@@ -5,7 +5,6 @@
 const {
   forEachGeneric,
   forEachInOrder,
-  isBetaEnabled,
 } = require('../base/model');
 const { dictLocation, weakLocation, weakRefLocation } = require('../base/location');
 
@@ -138,10 +137,10 @@ function tweakAssocs( model ) {
 
   function handleQueryElements( column ) {
     rewriteAssociationCheck( column );
-    if (!isBetaEnabled( model.options, '$calcForDraft' ))
-      return;
+    if (model.options.noDollarCalc || column._columnParent)
+      return;                   // no $calc supported with inline
     const { value } = column;  // `value` = column expression
-    if (!value || !value.args && !value.suffix)
+    if (!value || value.path)  // not with references
       return;
     // TODO: what about non-simple refs (assocs, even with filter/args)?
 
@@ -946,6 +945,8 @@ function tweakAssocs( model ) {
    * for item.
    */
   function rewriteColumnPath( ref, column ) {
+    if (ref.query)
+      return traverseExpr.STOP; // sub queries rewrite not supported
     if (!ref._artifact)
       return null;
     const root = ref.path?.[0];
@@ -1010,9 +1011,12 @@ function tweakAssocs( model ) {
           state = setArtifactLink( i, elem );
       }
       else {
-        state = rewriteItem( state, i, assoc );
-        if (!state || state === true)
-          break;
+        state = rewriteItem( state, i, assoc, !location );
+        if (state && state !== true)
+          continue;
+        if (!state && !location)
+          return true;
+        break;
       }
     }
     if (state !== true)
@@ -1032,7 +1036,7 @@ function tweakAssocs( model ) {
    * @param item Path segment to rewrite.
    * @param assoc Published association of query.
    */
-  function rewriteItem( elem, item, assoc ) {
+  function rewriteItem( elem, item, assoc, noError ) {
     if (!elem._redirected)
       return true;
     let name = item.id;
@@ -1055,7 +1059,7 @@ function tweakAssocs( model ) {
     if (env?.target)
       env = env.target._artifact?._effectiveType;
     const found = setArtifactLink( item, env?.elements?.[name] );
-    if (found)
+    if (found || noError)
       return found;
 
     const isExplicit = elem.target && !elem.target.$inferred;

package/lib/compiler/utils.js

@@ -134,6 +134,28 @@ function proxyCopyMembers( art, dictProp, originDict, location, kind, tmpDepreca
   }
 }
 
+// Initialization (define.js), shared with extend.js: ---------------------------
+
+/**
+ * Initialize artifact links inside `obj.items` (for nested ones as well).
+ * Does nothing, it `obj.items` does not exist.
+ *
+ * @param {XSN.Artifact} obj
+ * @param {object} block
+ * @return {XSN.Artifact}
+ */
+function initItemsLinks( obj, block ) {
+  let { items } = obj;
+  while (items) {
+    setLink( items, '_outer', obj );
+    setLink( items, '_parent', obj._parent );
+    setLink( items, '_block', block );
+    obj = items;
+    items = obj.items;
+  }
+  return obj;
+}
+
 /**
  * Set the member `elem` to have a _parent link to `parent` and a corresponding
  * _main link.  Also set the member's name accordingly, where argument `name`
@@ -162,6 +184,76 @@ function createAndLinkCalcDepElement( elem ) {
   setLink( r, '_outer', elem );
 }
 
+function initExprAnnoBlock( art, block ) {
+  // remark: `art` could also be the extension
+  for (const prop in art) {
+    if (prop.charAt(0) !== '@')
+      continue;
+    const anno = art[prop];
+    // _block links needed for `cast( … as Type )`, `[ ..., cast( … as Type ) ]`
+    if (anno.literal === 'array') {
+      anno.kind = '$annotation';
+      for (const item of anno.val)
+        setLink( item, '_block', block );
+    }
+    else if (anno.$tokenTexts) {
+      // remark: it wouldn't hurt to set it always...
+      anno.kind = '$annotation';
+      setLink( anno, '_block', block );
+    }
+  }
+}
+
+function initDollarSelf( art ) {
+  // TODO: use setMemberParent() ?
+  const self = {
+    name: { id: '$self', location: art.location },
+    kind: '$self',
+    location: art.location,
+  };
+  setLink( self, '_parent', art );
+  setLink( self, '_main', art ); // used on main artifact
+  setLink( self, '_origin', art );
+  art.$tableAliases = Object.create( null );
+  art.$tableAliases.$self = self;
+}
+
+function initDollarParameters( art ) {
+  // TODO: use setMemberParent() ?
+  const parameters = {
+    name: { id: '$parameters' },
+    kind: '$parameters',
+    location: art.location,
+    deprecated: true, // hide in code completion
+  };
+  setLink( parameters, '_parent', art );
+  setLink( parameters, '_main', art );
+  // Search for :const after :param.  If there will be a possibility in the
+  // future that we can extend <query>.columns, we must be sure to use
+  // _block of that new column after :param (or just allow $parameters there).
+  setLink( parameters, '_block', art._block );
+  if (art.params) {
+    parameters.elements = art.params;
+    parameters.$tableAliases = art.params; // TODO: find better name - $lexical?
+  }
+  art.$tableAliases.$parameters = parameters;
+}
+
+function initBoundSelfParam( params, main ) {
+  if (!params)
+    return;
+  const first = params[Object.keys( params )[0] || ''];
+  const type = first?.type || first?.items?.type; // this sequence = no derived type
+  const path = type?.path;
+  if (path?.length === 1 && path[0]?.id === '$self') { // TODO: no where: ?
+    const $self = main.$tableAliases?.$self ||
+      main.kind === 'extend' && { name: { id: '$self' } };
+    // remark: an 'extend' has no "table alias" `$self` (relevant for parse-cdl)
+    setLink( type, '_artifact', $self );
+    setLink( path[0], '_artifact', $self );
+  }
+}
+
 /**
  * Adds a dependency user -> art with the given location.
  *
@@ -702,8 +794,13 @@ module.exports = {
   proxyCopyMembers,
   dependsOn,
   dependsOnSilent,
+  initItemsLinks,
   setMemberParent,
   createAndLinkCalcDepElement,
+  initExprAnnoBlock,
+  initDollarSelf,
+  initDollarParameters,
+  initBoundSelfParam,
   storeExtension,
   withAssociation,
   pathName,

package/lib/compiler/xpr-rewrite.js

@@ -395,7 +395,8 @@ function xprRewriteFns( model ) {
       }
     }
 
-    if (isSimpleSelectItem && model.options.testMode)
+    if (isSimpleSelectItem && model.options.testMode &&
+        destination.value?.path[0]._navigation?.kind !== 'mixin')
       throw new CompilerAssertion(`select item has no table alias: ${ JSON.stringify(destination.value.path) }`);
 
     if (isAnnoPathAbsolute( expr ))

package/lib/edm/annotations/edmJson.js

@@ -93,8 +93,6 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     //----------------------------------
     // operators not supported as dynamic expression
     '.': notADynExpr,
-    isNull: (p, o) => notADynExpr(p, o, null, null, null, null, 'is null'),
-    isNotNull: (p, o) => notADynExpr(p, o, null, null, null, null, 'is not null'),
     exists: notADynExpr,
     SELECT: notADynExpr,
     SET: (p, o) => notADynExpr(p, o, null, null, null, null, 'UNION'),
@@ -302,6 +300,8 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
   transform.$Mul = noOp;
   transform['/'] = op('$DivBy');
   transform.$DivBy = noOp;
+  transform.isNull = op('$Eq');
+  transform.isNotNull = op('$Ne');
   // $Div, $Mod are functions
   //----------------------------------
   // LITERALS
@@ -885,10 +885,13 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
       if (xpr.length === 2 && (xpr[0] === '+' || xpr[0] === '-' || xpr[0] === 'not' || xpr[0] === 'new'))
         return { [xpr[0]]: xpr[1] };
 
-      if (xpr.length === 3 && xpr[1] === 'is' && xpr[2] === 'null') {
-        rejectInvalidExpression(xpr);
-        return xpr;
-      }
+      // is null
+      if (xpr.length === 3 && xpr[1] === 'is' && xpr[2] === 'null')
+        return { isNull: [ xpr[0], { val: null } ] };
+
+      // is not null
+      if (xpr.length === 4 && xpr[1] === 'is' && xpr[2] === 'not' && xpr[3] === 'null')
+        return { isNotNull: [ xpr[0], { val: null } ] };
 
       // binary operators: '=', '<>', 'like', ...
       if (xpr.length === 3 && typeof xpr[1] === 'string')

package/lib/edm/annotations/genericTranslation.js

@@ -916,8 +916,8 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
         }
         // expression
         const res = handleExpression(cAnnoValue['='], dTypeName);
-        oTarget.setXml( { [res.name]: res.value });
-        oTarget.setJSON( { [res.name]: res.value });
+        oTarget.setXml({ [res.name]: res.value });
+        oTarget.setJSON({ [res.name]: res.value });
       }
       else if (cAnnoValue['#'] !== undefined) {
         const enumSymbol = cAnnoValue['#'];
@@ -968,9 +968,13 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       }
       else if (cAnnoValue.$edmJson) {
         // "pseudo-structure" used for embedding a piece of JSON that represents "OData CSDL, JSON Representation"
-        oTarget.append(handleEdmJson(cAnnoValue.$edmJson, msg));
+        const edmNode = handleEdmJson(cAnnoValue.$edmJson, msg);
+        if (edmNode && edmNode._kind === 'Path' && typeof edmNode._value === 'string' && !edmNode._children.length)
+          oTarget.setXml({ [edmNode._kind]: edmNode._value });
+        else
+          oTarget.append(edmNode);
       }
-      else if ( Object.keys(cAnnoValue).filter( x => x[0] !== '@' ).length === 0) {
+      else if (Object.keys(cAnnoValue).filter( x => x[0] !== '@' ).length === 0) {
         // object consists only of properties starting with "@", no $value
         setProp(oTarget, '$isInvalid', true);
         message('odata-anno-value', msg.location,

package/lib/edm/csn2edm.js

@@ -49,7 +49,6 @@ function csn2edm( _csn, serviceName, _options, messageFunctions ) {
 function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
   // get us a fresh model copy that we can work with
   const csn = cloneFullCsn(_csn, _options);
-  const special$self = !csn?.definitions?.$self && '$self';
   messageFunctions.setModel(csn);
 
   const {
@@ -689,7 +688,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
               }
             }
 
-            if (options.isV2() && isBetaEnabled(options, 'draftAdminDataHiddenFilter')) {
+            if (options.isV2()) {
               if (elementCsn._edmParentCsn.name === `${ elementCsn._edmParentCsn.$mySchemaName }.DraftAdministrativeData`)
                 elementCsn['@UI.HiddenFilter'] ??= true;
             }
@@ -762,7 +761,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
           const entries = Object.entries(actionCsn.params);
           const firstParam = entries[0][1];
           const type = firstParam?.items?.type || firstParam?.type;
-          if (type === special$self) {
+          if (type === '$self') {
             bpName = entries[0][0];
             setProp(actionCsn, '$bindingParam', firstParam);
             // preserve the original type (as it is the key to reqDefs.defintions)
@@ -938,7 +937,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
             if (parameterCsn['@cds.api.ignore'])
               return;
             const type = parameterCsn?.items?.type || parameterCsn?.type;
-            if (i === 0 && type === special$self) {
+            if (i === 0 && type === '$self') {
             // skip and remove the first parameter if it is a $self binding parameter to
             // omit annotation rendering later on
               setProp(actionCsn, '$bindingParam', parameterCsn);

package/lib/edm/edmInboundChecks.js

@@ -130,12 +130,11 @@ function inboundQualificationChecks( csn, options, messageFunctions,
     // we need to know if the first path step is the bindind param
     // for the rejection of V2 paths where the BP is ignored
     function markBindingParamPaths( action, loc ) {
-      const special$self = !csn?.definitions?.$self && '$self';
       if (action.params) {
         const params = Object.entries(action.params);
         const firstParam = params[0][1];
         const type = firstParam?.items?.type || firstParam?.type;
-        if (type === special$self) {
+        if (type === '$self') {
           const bindingParamName = params[0][0];
           const markBindingParam = {
             ref: (parent, prop, xpr) => {

package/lib/edm/edmPreprocessor.js

@@ -40,7 +40,6 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
   const {
     info, warning, error, message,
   } = messageFunctions;
-  const special$self = !csn?.definitions?.$self && '$self';
   const csnUtils = getUtils(csn);
 
   // proxies are merged into the final model after all proxy elements are collected
@@ -2077,7 +2076,8 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
 
     function iterateParams( action, location ) {
       let optPns = [];
-      const isBP = p => (p.items?.type || p.type) === special$self;
+      const isBP = p => (p.items?.type || p.type) === '$self' &&
+        p === Object.values( action.params )[0];
 
       if (action.params) {
         Object.entries(action.params).forEach(([ pn, p ]) => {
@@ -2126,7 +2126,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
             }
             else if (action.kind === 'function') {
               // this is a mandatory parameter, warn about all previously collected optional parameters
-              if (optPns.filter(op => (op.items?.type || op.type) !== special$self).length)
+              if (optPns.length)
                 error('odata-parameter-order', location.concat(pn));
               optPns = [];
             }

package/lib/gen/CdlGrammar.checksum

@@ -1 +1 @@
-8e38091fda3711e1d4d2b8b87fbdd328
+2af41f8c84ca1fa40a50b8c58903dadc

package/lib/gen/CdlParser.js

@@ -3827,7 +3827,7 @@ case 645:this.s=651;{ this.attachLocation( $.expr ); }continue
 case 646:if(this.valuePath(_={},651)){e=_.expr; this.valuePathAstWithNew( $.expr, e ); }continue
 case 647:switch(this.l()){
 case'(':if(this.c(648))open=this.lb();continue
-case'Id':if(this.valuePath(_={},651)){e=_.expr; e = this.valuePathAst( e ); e.$expected = 'exists';
+case'Id':if(this.valuePath(_={},651)){e=_.expr; e = this.valuePathAst( e ); e.$syntax = 'after-exists';
 $.expr.args.push( e ); this.attachLocation( $.expr ); }continue
 case'?':if(this.c(651)){ this.csnParseOnly( 'syntax-unsupported-param', -1, { '#': 'dynamic', code: '?' } );
 $.expr.args.push( { param: this.valueWithLocation(), scope: 'param' } ); this.attachLocation( $.expr ); }continue

package/lib/gen/Dictionary.json

@@ -596,7 +596,7 @@
         "Property",
         "Parameter"
       ],
-      "Type": "Edm.String"
+      "Type": "Edm.PrimitiveType"
     },
     "Common.FieldControl": {
       "AppliesTo": [
@@ -910,6 +910,13 @@
       "$deprecationText": "Use terms [Aggregation.RecursiveHierarchy](https://github.com/oasis-tcs/odata-vocabularies/blob/main/vocabularies/Org.OData.Aggregation.V1.md#RecursiveHierarchy) and [Hierarchy.RecursiveHierarchy](https://github.com/SAP/odata-vocabularies/blob/main/vocabularies/Hierarchy.md#RecursiveHierarchy) instead",
       "Type": "Common.RecursiveHierarchyType"
     },
+    "Common.ReferentialConstraint": {
+      "$experimental": true,
+      "AppliesTo": [
+        "NavigationProperty"
+      ],
+      "Type": "Collection(Common.ReferentialConstraintType)"
+    },
     "Common.RelatedRecursiveHierarchy": {
       "AppliesTo": [
         "Property"
@@ -3345,6 +3352,14 @@
         "NodeDrillStateProperty": "Edm.PropertyPath"
       }
     },
+    "Common.ReferentialConstraintType": {
+      "$experimental": true,
+      "$kind": "ComplexType",
+      "Properties": {
+        "Property": "Edm.PropertyPath",
+        "ReferencedProperty": "Edm.PropertyPath"
+      }
+    },
     "Common.SAPObjectNodeTypeType": {
       "$experimental": true,
       "$kind": "ComplexType",

package/lib/json/from-csn.js

@@ -1682,15 +1682,13 @@ function exprOrString( val, spec ) {
     : expr( val, spec );
 }
 
-// mark path argument of 'exists' predicate with $expected:'exists'
+// mark path argument of 'exists' predicate with $syntax:'after-exists'
 function exprArgs( cond, spec ) {
   const rxsn = arrayOf( exprOrString )( cond, spec );
-  // TODO: do that in definer.js, neither here nor in CDL parser
   if (Array.isArray( rxsn )) {
-    for (let i = 0; i < rxsn.length - 1; i++) {
-      // TODO: disallow param ref - write test
-      if (cond[i] === 'exists' && rxsn[i + 1].path)
-        rxsn[++i].$expected = 'exists';
+    for (let i = 0; i < rxsn.length - 1;) {
+      if (cond[i++] === 'exists' && rxsn[i].path)
+        rxsn[i].$syntax = 'after-exists';
     }
   }
   return rxsn;

package/lib/json/to-csn.js

@@ -1172,15 +1172,15 @@ function enumValueOrCalc( v, csn, node, prop ) {
   if (node.kind === 'enum') {
     Object.assign( csn, expression( v ) );
   }
-  else if (v === true && prop === '$calc') {
-    return true;                // calculation has used non-projected elements
+  else if (prop === '$calc') {
+    return v === true || expression( v );
   }
   // In XSN, there are combined elem/column objects: do not represent column
   // expression when presented as element in CSN
 
   // node.$syntax set in define.el(!), but not inside an `extend`, a _parent might
   // not be set always for parse-only, especially with CSN input
-  else if (node.$syntax === 'calc' || prop === '$calc' ||
+  else if (node.$syntax === 'calc' ||
            !node._parent || node._parent.kind === 'extend') {
     const stored = v.stored ? { stored: value(v.stored) } : {};
     return Object.assign( stored, expression( v ) );

package/lib/model/csnRefs.js

@@ -519,6 +519,8 @@ function csnRefs( csn, universalReady ) {
    * Return the object pointing to by the artifact reference (in 'type',
    * 'includes', 'target').  For `from`, use artifactRefFrom()!
    *
+   * Warning: do not use it for the binding parameter if the ref is `$self`.
+   *
    * @param {CSN.ArtifactReferencePath|string} ref
    * @param {any} [notFound] Value that is returned in case the artifact reference
    *                         could not be found.
@@ -612,9 +614,16 @@ function csnRefs( csn, universalReady ) {
 
   function getOriginRaw( art ) {
     if (art.type) {               // TODO: make robust against "linked" = only direct
-      return (art.type !== '$self' || csn.definitions.$self)
-        ? artifactRef( art.type, BUILTIN_TYPE )
-        : getCache( boundActionOrMain( art ), '_parent' );
+      if (art.type !== '$self')
+        return artifactRef( art.type, BUILTIN_TYPE );
+      const action = boundActionOrMain( art );
+      const binding = action?.params && Object.values( action.params )[0];
+      // binding parameter must be typed with `$self` or `many $self`:
+      const entity = binding && (art === binding || art === binding.items) &&
+        getCache( action, '_parent' );
+      // if name-deprecated-$self is a non-config error, this could be simplified to:
+      // const entity = action?.params && getCache( action, '_parent' );
+      return entity || artifactRef( art.type, BUILTIN_TYPE );
     }
     if (typeof art.$origin === 'object') // null, […], {…}
       return getOriginExplicit( art.$origin );
@@ -798,7 +807,7 @@ function csnRefs( csn, universalReady ) {
       }
 
       if (!qcache)
-        throw new CompilerAssertion( `Query not in cache at: ${ locationString(query.$location) }` );
+        throw new CompilerAssertion( `For semantics '${ refCtx }', query not in cache at: ${ locationString(query.$location) }` );
 
       if (semantics.dynamic === 'query') {
         // TODO: for ON condition in expand, would need to use cached _element

package/lib/model/enrichCsn.js

@@ -69,7 +69,6 @@ function enrichCsn( csn, options = {} ) {
   // options.enrichCsn = 'DEBUG';
   let $$cacheObjectNumber = 0;   // for debugging
   const debugLocationInfo = options.enrichCsn === 'DEBUG' && Object.create(null);
-  const special$self = !csn.definitions.$self && '$self';
 
   setLocations( csn, false, null );
   const {
@@ -180,7 +179,10 @@ function enrichCsn( csn, options = {} ) {
       parent[`_${ prop }`] = ref.map( r => refLocation( artifactRef( r, notFound ) ) );
     }
     else if (typeof ref === 'string') {
-      if (!ref.startsWith( 'cds.') && ref !== special$self)
+      // Don't use `artifactRef( 'self' )` for binding parameter. Because it is not
+      // easily recognizable here, always omit `_type` property for `$self` even if
+      // there is a type named `$self` (which would induce a configurable error):
+      if (!ref.startsWith( 'cds.') && ref !== '$self')
         parent[`_${ prop }`] = refLocation( artifactRef( ref, notFound ) );
     }
     else if (!ref.elements) {

package/lib/optionProcessor.js

@@ -2,11 +2,13 @@
 
 /* eslint @stylistic/max-len: 0 */
 
-// Remarks:
-// - The specification is client-tool centric (bin/cdsc.js):
+// Remarks (`git blame` on these remarks does not reveal the options designer)
+// - The specification is client-tool centric (../bin/cdsc.js):
 //   an option named `fooBar` is “produced” by `.option('  --foo-bar')`.
 // - Also list the option in the `help` text, used with `cdsc -h`.
-// - Specify valid values for non-boolean options in lib/api/validate.js.
+// - All options must also be added to ./api/options.js.
+// - Specify valid values for non-boolean options in ./api/validate.js.
+// - Beta and deprecated options are specified in ./base/model.js.
 
 'use strict';
 
@@ -54,7 +56,8 @@ optionProcessor
   .option('    --add-texts-language-assoc')
   .option('    --localized-without-coalesce')
   .option('    --tenant-discriminator')
-  .option('    --no-composition-includes')
+  .option('    --no-composition-includes') // TODO: missed to be removed in #13762
+  .option('    --no-dollar-calc')          // for grep: option `noDollarCalc`
   .option('    --default-binary-length <length>')
   .option('    --default-string-length <length>')
   .option('    --struct-xpr')
@@ -157,6 +160,7 @@ optionProcessor
                                     to "sap.common.Languages" if it exists
        --localized-without-coalesce Omit coalesce in localized convenience views
        --no-composition-includes  Do NOT add named aspects to 'includes' property of generated composition entity.
+       --no-dollar-calc     Don't set $calc property in CSN
        --no-recompile       Don't recompile in case of internal errors
        --struct-xpr         Write structured expressions to the compiler CSN output (possibly then
                             used as input for backends)

package/lib/render/utils/sql.js

@@ -198,10 +198,11 @@ function _artifactIsProjectionView( csn, artifact ) {
     referencedElements[column.ref.at(-1)] = true;
   }
 
-  // Full primary key needs to be projected according to HANA SQL spec
+  // Full primary key/not null chain needs to be projected according to HANA SQL spec
+  // https://help.sap.com/docs/hana-cloud-database/sap-hana-cloud-sap-hana-database-sql-reference-guide/create-projection-view-statement-data-definition
   for (const elementName in source.elements) {
     const element = source.elements[elementName];
-    if (element.key && !referencedElements[elementName])
+    if ((element.notNull || element.key) && !referencedElements[elementName])
       return false;
   }
 

package/lib/transform/db/applyTransformations.js

@@ -211,7 +211,7 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
    *
    * @param {object | Array} node the thing that has _prop
    * @param {string|number} _prop the name of the current property
-   * @param {any} _path The value of node[_prop]
+   * @param {Array} _path The value of node[_prop]
    */
   function pathRef( node, _prop, _path ) {
     csnPath.push( _prop );