@sap/cds-compiler 3.9.4 → 4.0.2

package/lib/checks/enricher.js

@@ -28,7 +28,7 @@ function enrichCsn( csn ) {
     mixin: dictionary,
     ref: pathRef,
     type: simpleRef,
-    target: simpleRef,
+    target,
     includes: simpleRef,
     columns,
     // Annotations are ignored.
@@ -99,11 +99,10 @@ function enrichCsn( csn ) {
   }
 
   // eslint-disable-next-line jsdoc/require-jsdoc
-  function simpleRef( node, prop ) {
+  function simpleRef( node, prop, ref ) {
     setProp(node, '$path', [ ...csnPath ]);
     cleanupCallbacks.push(() => delete node.$path);
 
-    const ref = node[prop];
     if (typeof ref === 'string') {
       const art = artifactRef( ref, null );
       if (art || !ref.startsWith( 'cds.')) {
@@ -112,9 +111,19 @@ function enrichCsn( csn ) {
       }
     }
     else if (Array.isArray( ref )) {
+      // e.g. `includes: [ 'E' ]`, which gets a parallel `_includes`.
       setProp(node, `_${ prop }`, ref.map( r => artifactRef( r, null ) ));
       cleanupCallbacks.push(() => delete node[`_${ prop }`]);
     }
+    else if (typeof ref === 'object') {
+      // e.g. type refs via `{ type: { ref: [ 'E', 'field' ] } }
+      standard(node, prop, ref);
+      const art = artifactRef( ref, null );
+      if (art) {
+        setProp(node, `_${ prop }`, art);
+        cleanupCallbacks.push(() => delete node[`_${ prop }`]);
+      }
+    }
   }
 
   // eslint-disable-next-line jsdoc/require-jsdoc
@@ -152,6 +161,20 @@ function enrichCsn( csn ) {
     } );
     csnPath.pop();
   }
+
+  /**
+   * A target is either an anonymous aspect (with elements, etc.) via gensrc or a reference.
+   *
+   * @param {object} parent
+   * @param {string} prop
+   * @param {any} node
+   */
+  function target( parent, prop, node ) {
+    if (node?.elements) // e.g. via gensrc
+      standard(parent, prop, node);
+    else
+      simpleRef(parent, prop, node);
+  }
 }
 
 module.exports = enrichCsn;

package/lib/checks/onConditions.js

@@ -74,6 +74,7 @@ function validateOnCondition( member, memberName, property, path ) {
         const validDollarSelf = otherSideIsValidDollarSelf(member.on, i);
         const validStructuredElement = otherSideIsExpandableStructure.call(this, member.on, i);
         for (let j = 0; j < _links.length - 1; j++) {
+          let hasPathError = false;
           const csnPath = path.concat([ 'on', i, 'ref', j ]);
 
           // For error messages
@@ -88,25 +89,34 @@ function validateOnCondition( member, memberName, property, path ) {
             if (stepArt.on) {
               // It's an unmanaged association - traversal is always forbidden
               this.error('ref-unexpected-navigation', csnPath, { '#': 'unmanaged', id, elemref });
+              hasPathError = true;
             }
             else {
               // It's a managed association - access of the foreign keys is allowed
-              const nextRef = ref[j + 1].id || ref[j + 1];
-              if (!stepArt.keys.some(r => r.ref[0] === nextRef)) {
+              checkForeignKeyAccess(member.on[i], j, csnPath, (errorIndex) => {
                 this.error('ref-unexpected-navigation', csnPath, {
-                  '#': 'std', id, elemref, name: nextRef,
+                  '#': 'std', id, elemref, name: ref[errorIndex].id || ref[errorIndex],
                 });
-              }
+                hasPathError = true;
+              });
             }
           }
-          if (stepArt.virtual)
-            this.error(null, csnPath, { id, elemref }, 'Virtual elements can\'t be used in ON-conditions, step $(ID) of path $(ELEMREF)');
-
-          if (ref[j].where)
-            this.error(null, csnPath, { id, elemref }, 'ON-conditions must not contain filters, step $(ID) of path $(ELEMREF)');
+          if (stepArt.virtual) {
+            this.error(null, csnPath, { id, elemref }, //
+                       'Virtual elements can\'t be used in ON-conditions, step $(ID) of path $(ELEMREF)');
+            hasPathError = true;
+          }
+          if (ref[j].where) {
+            this.error('ref-unexpected-filter', csnPath, { '#': 'on-condition', id, elemref });
+            hasPathError = true;
+          }
+          if (ref[j].args) {
+            this.error('ref-unexpected-args', csnPath, { '#': 'on-condition', id, elemref });
+            hasPathError = true;
+          }
 
-          if (ref[j].args)
-            this.error(null, csnPath, { id, elemref }, 'ON-conditions must not contain parameters, step $(ID) of path $(ELEMREF)');
+          if (hasPathError)
+            break; // avoid too many consequent errors
         }
 
         if (_art && !($scope === '$self' && ref.length === 1)) {
@@ -145,6 +155,51 @@ function validateOnCondition( member, memberName, property, path ) {
   }
 }
 
+
+/**
+ * Ensure that only foreign keys of the association `parent.ref[refIndex]` are accessed in `parent.ref`.
+ * If a non-fk field is accessed, `callback` is invoked.
+ *
+ * @param {object} parent Object containing `ref` and `_links` from csnRefs.
+ * @param {number} refIndex Index of the to-be-checked association in `parent.ref`
+ * @param {CSN.Path} csnPath
+ * @param {(errorIndex: number) => void} callback Called if there are non-fk path steps. Argument is index in
+ *          `parent.ref` that is faulty.  If a fk-step is missing, `errorIndex` will be `> parent.ref.length`.
+ */
+function checkForeignKeyAccess( parent, refIndex, csnPath, callback ) {
+  const { ref, _links } = parent;
+  const assoc = _links[refIndex].art;
+
+  const next = ref[refIndex + 1].id || ref[refIndex + 1];
+  let possibleKeys = next && assoc.keys.filter(r => r.ref[0] === next);
+  if (!possibleKeys || possibleKeys.length === 0) {
+    callback(refIndex + 1);
+  }
+  else {
+    // For cases where `Association to T { struct.one, struct.two };` is used instead of `{ struct }`.
+    // Note: We know that `{ struct, struct.one }` is not possible, so no prefix check required.
+    let fkIndex = 0;
+    let success = false;
+    while (!success && possibleKeys.length > 0) {
+      const pathStep = ref[refIndex + fkIndex + 1].id || ref[refIndex + fkIndex + 1];
+
+      // Function is immediately executed, before next iteration of loop. Access is fine.
+      // eslint-disable-next-line no-loop-func
+      possibleKeys = possibleKeys.filter((r) => {
+        const result = r.ref[fkIndex] === pathStep;
+        if (result && r.ref.length - 1 === fkIndex)
+          success = true; // full fk matched
+
+        return result;
+      });
+      ++fkIndex;
+    }
+    if (!success)
+      callback(refIndex + fkIndex);
+  }
+}
+
+
 /**
  * Run the above validations also for mixins.
  *
@@ -156,4 +211,4 @@ function validateMixinOnCondition( query, path ) {
     forEachGeneric( query.SELECT, 'mixin', validateOnCondition.bind(this), path );
 }
 
-module.exports = { validateOnCondition, validateMixinOnCondition };
+module.exports = { validateOnCondition, validateMixinOnCondition, checkForeignKeyAccess };

package/lib/checks/queryNoDbArtifacts.js

@@ -17,121 +17,122 @@ const { hasAnnotationValue, isPersistedOnDatabase, isBuiltinType } = require('..
  * @param {CSN.Query} query Query to check
  */
 function checkQueryForNoDBArtifacts( query ) {
-  /**
-   * Count the leaf-elements resulting from a given element.
-   *
-   * @param {CSN.Element} def Definition to check
-   * @returns {number} Number of leaf elements
-   */
-  const leafCount = (def) => {
-    let c = 0;
-    if (!def)
-      return c;
-    if (def.elements) {
-      c += Object.values(def.elements).reduce((acc, e) => {
-        acc += leafCount(e);
-        return acc;
-      }, 0);
-    }
-    else if (def.keys) {
-      c += def.keys.reduce((acc, e) => {
-        acc += leafCount(e._art);
-        return acc;
-      }, 0);
-    }
-    else if (def.type) {
-      if (isBuiltinType(def.type) && !(def.target))
-        return 1;
-      c += leafCount(this.csn.definitions[def.type]);
+  if (isPersistedOnDatabase(this.artifact) && !hasAnnotationValue(this.artifact, '@cds.persistence.table')) {
+    const generalQueryProperties = [ 'from', 'columns', 'where', 'groupBy', 'orderBy', 'having', 'limit' ];
+    for (const prop of generalQueryProperties) {
+      const queryPart = (query.SELECT || query.SET)[prop];
+      if (Array.isArray(queryPart)) {
+        for (const part of queryPart)
+          checkRef.call(this, part, prop === 'columns');
+      }
+      else if (typeof queryPart === 'object') {
+        checkRef.call(this, queryPart, prop === 'columns');
+      }
     }
+  }
+}
+
+/**
+ * Count the leaf-elements resulting from a given element.
+ *
+ * @param {CSN.Element} def Definition to check
+ * @returns {number} Number of leaf elements
+ */
+function leafCount( def ) {
+  let c = 0;
+  if (!def)
     return c;
-  };
-  /**
-   * Check the given ref for usage of skipped/abstract assoc targets
-   *
-   * @param {object} obj CSN "thing" to check
-   * @param {boolean} inColumns True if the ref is part of a from
-   */
-  const checkRef = (obj, inColumns) => {
-    if (!(obj && obj.ref) || !obj._links || obj.$scope === 'alias')
-      return;
+  if (def.elements) {
+    c += Object.values(def.elements).reduce((acc, e) => {
+      acc += leafCount.call(this, e);
+      return acc;
+    }, 0);
+  }
+  else if (def.keys) {
+    c += def.keys.reduce((acc, e) => {
+      acc += leafCount.call(this, e._art);
+      return acc;
+    }, 0);
+  }
+  else if (def.type) {
+    if (isBuiltinType(def.type) && !(def.target))
+      return 1;
+    c += leafCount.call(this, this.csn.definitions[def.type]);
+  }
+  return c;
+}
 
-    const links = obj._links;
+/**
+ * Check the given ref for usage of skipped/abstract assoc targets
+ *
+ * @param {object} obj CSN "thing" to check
+ * @param {boolean} inColumns True if the ref is part of a from
+ */
+function checkRef( obj, inColumns ) {
+  if (!(obj && obj.ref) || !obj._links || obj.$scope === 'alias')
+    return;
 
-    // Don't check the last element - to allow association publishing in columns
-    for (let i = 0; i < (inColumns ? links.length - 1 : links.length); i++) {
-      const link = links[i];
-      if (!link)
-        continue;
+  const links = obj._links;
 
-      const { art } = link;
-      if (!art)
-        continue;
+  // Don't check the last element - to allow association publishing in columns
+  for (let i = 0; i < (inColumns ? links.length - 1 : links.length); i++) {
+    const link = links[i];
+    if (!link)
+      continue;
 
-      const endArtifact = art.target ? this.csn.definitions[art.target] : art;
-      const pathStep = obj.ref[i].id ? obj.ref[i].id : obj.ref[i];
-      const name = art.target ? art.target : pathStep;
-      if (!isPersistedOnDatabase(endArtifact)) {
-        const nextElement = obj.ref[i + 1];
-        /**
-         * if we only navigate to foreign keys of the managed association in a view, we do not need to join,
-         * thus we can produce the view even if the target of the association is not persisted
-         *
-         * @param {CSN.Element} assoc association in ref
-         * @param {string} nextStep the ref step following the association
-         * @returns {boolean} true if no join will be generated
-         */
-        const isJoinRelevant = (assoc, nextStep) => {
-          if (!assoc.keys)
-            return true;
-          const isExposedColumnAssocOrComposition = this.csnUtils.isAssocOrComposition(obj._art);
-          return !assoc.keys
-            .some(fk => fk.ref[0] === nextStep && !isExposedColumnAssocOrComposition);
-        };
-        if (isJoinRelevant(art, nextElement)) {
-          const cdsPersistenceSkipped = hasAnnotationValue(endArtifact, '@cds.persistence.skip');
-          this.error( null, obj.$path, {
-            id: pathStep, elemref: obj, name, '#': cdsPersistenceSkipped ? 'std' : 'abstract',
-          }, {
-            std: 'Unexpected “@cds.persistence.skip” annotation on association target $(NAME) of $(ID) in path $(ELEMREF)',
-            abstract: 'Unexpected “abstract” association target $(NAME) of $(ID) in path $(ELEMREF)',
-          } );
-        }
-      }
-      // check managed association to have foreign keys array filled
-      if (art.keys && leafCount(art) === 0) {
-        this.error(null,
-                   obj.$path,
-                   { id: pathStep, elemref: obj },
-                   'Path step $(ID) of $(ELEMREF) has no foreign keys');
-      }
+    const { art } = link;
+    if (!art)
+      continue;
 
-      if (art.on) {
-        for (let j = 0; j < art.on.length; j++) {
-          if (j < art.on.length - 2 && art.on[j].ref && art.on[j + 1] === '=' && art.on[j + 2].ref) {
-            const [ fwdAssoc, fwdPath ] = getForwardAssociation(pathStep, art.on[j], art.on[j + 2]);
-            if (fwdAssoc && fwdAssoc.keys && leafCount(fwdAssoc) === 0) {
-              this.error(null, obj.$path,
-                         { name: pathStep, elemref: obj, id: fwdPath },
-                         'Path step $(NAME) of $(ELEMREF) is a $self comparison with $(ID) that has no foreign keys');
-              j += 2;
-            }
-          }
-        }
+    const endArtifact = art.target ? this.csn.definitions[art.target] : art;
+    const pathStep = obj.ref[i].id ? obj.ref[i].id : obj.ref[i];
+    const name = art.target ? art.target : pathStep;
+    if (!isPersistedOnDatabase(endArtifact)) {
+      const nextElement = obj.ref[i + 1];
+      /**
+       * if we only navigate to foreign keys of the managed association in a view, we do not need to join,
+       * thus we can produce the view even if the target of the association is not persisted
+       *
+       * @param {CSN.Element} assoc association in ref
+       * @param {string} nextStep the ref step following the association
+       * @returns {boolean} true if no join will be generated
+       */
+      const isJoinRelevant = (assoc, nextStep) => {
+        if (!assoc.keys)
+          return true;
+        const isExposedColumnAssocOrComposition = this.csnUtils.isAssocOrComposition(obj._art.type);
+        return !assoc.keys
+          .some(fk => fk.ref[0] === nextStep && !isExposedColumnAssocOrComposition);
+      };
+      if (isJoinRelevant(art, nextElement)) {
+        const cdsPersistenceSkipped = hasAnnotationValue(endArtifact, '@cds.persistence.skip');
+        this.error( null, obj.$path, {
+          id: pathStep, elemref: obj, name, '#': cdsPersistenceSkipped ? 'std' : 'abstract',
+        }, {
+          std: 'Unexpected “@cds.persistence.skip” annotation on association target $(NAME) of $(ID) in path $(ELEMREF)',
+          abstract: 'Unexpected “abstract” association target $(NAME) of $(ID) in path $(ELEMREF)',
+        } );
       }
     }
-  };
+    // check managed association to have foreign keys array filled
+    if (art.keys && leafCount.call(this, art) === 0) {
+      this.error(null,
+                 obj.$path,
+                 { id: pathStep, elemref: obj },
+                 'Path step $(ID) of $(ELEMREF) has no foreign keys');
+    }
 
-  if (isPersistedOnDatabase(this.artifact) && !hasAnnotationValue(this.artifact, '@cds.persistence.table')) {
-    const generalQueryProperties = [ 'from', 'columns', 'where', 'groupBy', 'orderBy', 'having', 'limit' ];
-    for (const prop of generalQueryProperties) {
-      const queryPart = (query.SELECT || query.SET)[prop];
-      if (Array.isArray(queryPart)) {
-        for (const part of queryPart)
-          checkRef(part, prop === 'columns');
-      }
-      else if (typeof queryPart === 'object') {
-        checkRef(queryPart, prop === 'columns');
+    if (art.on) {
+      for (let j = 0; j < art.on.length; j++) {
+        if (j < art.on.length - 2 && art.on[j].ref && art.on[j + 1] === '=' && art.on[j + 2].ref) {
+          const [ fwdAssoc, fwdPath ] = getForwardAssociation(pathStep, art.on[j], art.on[j + 2]);
+          if (fwdAssoc && fwdAssoc.keys && leafCount.call(this, fwdAssoc) === 0) {
+            this.error(null, obj.$path,
+                       { name: pathStep, elemref: obj, id: fwdPath },
+                       'Path step $(NAME) of $(ELEMREF) is a $self comparison with $(ID) that has no foreign keys');
+            j += 2;
+          }
+        }
       }
     }
   }

package/lib/checks/sql-snippets.js

@@ -22,6 +22,8 @@ function checkSqlAnnotationOnElement( member, memberName, prop, path ) {
       this.message('anno-invalid-sql-view-element', path, { anno: 'sql.append' }, 'Annotation $(ANNO) can\'t be used on elements in views' );
     else if (this.csnUtils.isStructured(member))
       this.message('anno-invalid-sql-struct', path, { anno: 'sql.append' }, 'Annotation $(ANNO) can\'t be used on structured elements' );
+    else if (member.value && !member.value.stored)
+      this.message('anno-invalid-sql-calc', path, { anno: 'sql.append' }, 'Annotation $(ANNO) can\'t be used on calculated elements on read' );
     else
       checkValidAnnoValue(member, '@sql.append', path, this.error, this.options);
   }

package/lib/checks/types.js

@@ -53,10 +53,10 @@ function checkElementTypeDefinitionHasType( member, memberName, prop, path ) {
   const parent = this.csn.definitions[path[1]];
 
   // should only happen with csn input, not in cdl
-  // calculated elements may not have a .type (requires beta flag)
-  if (!member.value &&
+  // calculated elements on-read may not have a .type (requires beta flag)
+  if ((!member.value || member.value.stored) &&
       !parent.projection && !parent.query && !hasArtifactTypeInformation(member)) {
-    errorAboutMissingType(this.error, path, memberName, true);
+    errorAboutMissingType(this.error, path, member, memberName, true);
     return;
   }
 
@@ -97,7 +97,7 @@ function checkTypeDefinitionHasType( artifact, artifactName, prop, path ) {
 
   // should only happen with csn input, not in cdl
   if (!hasArtifactTypeInformation(artifact)) {
-    errorAboutMissingType(this.error, path, artifactName);
+    errorAboutMissingType(this.error, path, artifact, artifactName);
     return;
   }
 
@@ -153,13 +153,19 @@ function checkTypeOfHasProperType( artOrElement, name, model, error, path, deriv
  *
  * @param {Function} error the error function
  * @param {CSN.Path} path the path to the element or the artifact
+ * @param {CSN.Artifact} artifact Element or other member/definition.
  * @param {string} name of the element or the artifact which is dubious
  * @param {boolean} isElement indicates whether we are dealing with an element or an artifact
  */
-function errorAboutMissingType( error, path, name, isElement = false ) {
-  error('check-proper-type', path, { art: name, '#': isElement ? 'elm' : 'std' }, {
+function errorAboutMissingType( error, path, artifact, name,
+                                isElement = false ) {
+  let variant = isElement ? 'elm' : 'std';
+  if (artifact.value?.stored)
+    variant = 'calc';
+  error('check-proper-type', path, { art: name, '#': variant }, {
     std: 'Dubious type $(ART) without type information',
     elm: 'Dubious element $(ART) without type information',
+    calc: 'A stored calculated element must have a type',
   });
 }
 

package/lib/checks/validator.js

@@ -19,7 +19,7 @@ const checkForParams = require('./parameters');
 const { validateDefaultValues } = require('./defaultValues');
 const { checkActionOrFunction } = require('./actionsFunctions');
 const {
-  checkCoreMediaTypeAllowence, checkAnalytics,
+  checkCoreMediaTypeAllowance, checkAnalytics,
   checkAtSapAnnotations, checkReadOnlyAndInsertOnly,
 } = require('./annotationsOData');
 // both
@@ -251,7 +251,7 @@ function forOdata( csn, that ) {
                        if (that.csnUtils.getServiceName(artifactName)) {
                          checkAtSapAnnotations.bind(that)(artifact);
                          forEachMemberRecursively(artifact, [
-                           checkCoreMediaTypeAllowence.bind(that),
+                           checkCoreMediaTypeAllowance.bind(that),
                            checkAnalytics.bind(that),
                            checkAtSapAnnotations.bind(that),
                          ]);

package/lib/compiler/assert-consistency.js

@@ -105,7 +105,6 @@ function assertConsistency( model, stage ) {
         '$blocks',
         '$messageFunctions',
         '$functions',
-        '$volatileFunctions',
         '_sortedSources',
       ],
     },
@@ -238,6 +237,7 @@ function assertConsistency( model, stage ) {
     // specified elements in query entities (TODO: introduce real "specified elements" instead):
     elements$: { kind: true, enumerable: false, test: TODO },
     enum$: { kind: true, enumerable: false, test: TODO },
+    typeProps$: { kind: true, enumerable: false, test: TODO },
     actions: { kind: true, inherits: 'definitions' },
     enum: { kind: true, inherits: 'definitions' },
     foreignKeys: { kind: true, inherits: 'definitions' },
@@ -253,6 +253,7 @@ function assertConsistency( model, stage ) {
         requires: [ 'op', 'location', 'args' ],
         optional: [
           'quantifier', 'orderBy', 'limit', 'name', '$parens', 'kind',
+          '_origin',            // TODO tmp, see TODO in getOriginRaw()
           '_parent', '_main', '_leadingQuery', '_effectiveType', '$effectiveSeqNo', // in FROM
         ],
       },
@@ -359,8 +360,9 @@ function assertConsistency( model, stage ) {
       optional: [
         '$delimited',               // TODO remove?
         'args', '$syntax',
-        'where', 'cardinality',
-        '_artifact', '_navigation',
+        'where', 'groupBy', 'limit', 'orderBy', 'having',
+        'cardinality',
+        '_artifact', '_navigation', '_user',
         '$inferred',
       ],
     },
@@ -386,6 +388,7 @@ function assertConsistency( model, stage ) {
     // locations of parentheses pairs around expression:
     $parens: { parser: true, test: TODO },
     $prefix: { test: isString }, // compiler-corrected path prefix
+    $extended: { test: TODO, kind: [ 'element', '$inline' ] }, // `extend … with columns`
     $syntax: {
       parser: true,
       kind: [ 'entity', 'view', 'type', 'aspect' ],
@@ -438,7 +441,7 @@ function assertConsistency( model, stage ) {
           ...typeProperties,    // for CAST
         ],
       },
-      query: { requires: [ 'query', 'location' ] },
+      query: { requires: [ 'query', 'location' ], optional: [ 'stored' ] },
     },
     literal: {                  // TODO: check value against literal
       test: isString,
@@ -564,6 +567,7 @@ function assertConsistency( model, stage ) {
     _parent: { kind: true, test: TODO },
     _service: { kind: true, test: TODO },
     _main: { kind: true, test: TODO },
+    _user: { kind: true, test: TODO },
     _artifact: { test: TODO },
     _navigation: { test: TODO },
     _effectiveType: { kind: true, test: TODO },
@@ -631,13 +635,12 @@ function assertConsistency( model, stage ) {
       parser: true,
       kind: true,
       test: isOneOf([
-        '',                     // constructed “super annotate” statement
+        '', // constructed “super annotate” statement, redirected user-provided target
         // Uppercase values are used in logic, lowercase value are "just for us", i.e.
         // debugging or to add properties such as $generated in Universal CSN.
         // However, that is no longer true. For example, `autoexposed` is used in populate.js
         // as well.
         'IMPLICIT',
-        'REDIRECTED',
         'NULL', // from propagator
         'prop', // from propagator
 
@@ -651,7 +654,7 @@ function assertConsistency( model, stage ) {
         'cast', // type from cast() function
         'composition-entity',
         'copy', // only used in rewriteCondition(): On-condition is copied
-        'duplicate-autoexposed', // just like `autoexposed`, but with `duplicate` error.
+        'def-duplicate-autoexposed', // just like `autoexposed`, but with `duplicate` error.
         'expanded', // expanded elements, items, params
         'include', // through includes, e.g. `entity E : F {}`
         'keys',
@@ -683,7 +686,6 @@ function assertConsistency( model, stage ) {
     $expected: { parser: true, test: isOneOf([ 'approved-exists', 'exists' ]) },
     $messageFunctions: { test: TODO },
     $functions: { test: TODO },
-    $volatileFunctions: { test: TODO },
   };
   let _noSyntaxErrors = null;
   assertProp( model, null, stageParser ? ':parser' : ':model', null, true );

package/lib/compiler/builtins.js

@@ -433,6 +433,8 @@ function initBuiltins( model ) {
   cds._subArtifacts.hana = hana;
   env( coreHana, 'cds.hana.', hana );
   model.$internal = { $frontend: '$internal' };
+  // namespace:"localized" reserved ---
+  model.definitions.localized = createNamespace( 'localized', 'reserved' );
   return;
 
   function createNamespace( name, builtin ) {
@@ -494,7 +496,7 @@ function initBuiltins( model ) {
         art.$requireElementAccess = magic.$requireElementAccess;
 
       createMagicElements( art, magic.elements );
-      if (options.variableReplacements)
+      if (options.variableReplacements?.[name])
         createMagicElements( art, options.variableReplacements[name] );
       // setProp( art, '_effectiveType', art );
     }
@@ -512,7 +514,11 @@ function initBuiltins( model ) {
     for (const n of names) {
       const magic = {
         kind: 'builtin',
-        name: { id: n, element: `${ art.name.element }.${ n }` },
+        name: {
+          id: n,
+          absolute: art.name.absolute,
+          element: art.name.element ? `${ art.name.element }.${ n }` : n,
+        },
       };
       // Propagate this property so that it is available for sub-elements.
       if (art.$uncheckedElements)