@sap/cds-compiler 3.6.2 → 3.7.2

package/CHANGELOG.md

@@ -7,6 +7,47 @@
 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 3.7.2 - 2023-02-24
+
+### Fixed
+
+- CSN parser: Structured annotations containing `=` were accidentally interpreted as expressions,
+  even though the corresponding beta flag was not set.
+
+## Version 3.7.0 - 2023-02-22
+
+### Added
+
+- Several `annotate` statement can append/prepend values
+  to the same array-valued annotation without an `anno-duplicate` error,
+  even if there is no `using from` dependency between the involved sources
+- SQL methods such as `point.ST_X()` can be used in views.
+- The SQL `new` keyword can be used for `ST_*` types such as `new ST_POINT('Point(0.5 0.5)') )`
+
+### Changed
+
+- Update OData vocabularies 'Common', 'Core', 'Measures', 'PDF', 'UI'.
+- to.edm(x): Empty complex types are no longer warned about as they are allowed.
+
+### Fixed
+
+- `parse.cql` and `parse.expr` no longer ignore type arguments such as `cast(field as String(12))`.
+  One argument is interpreted as `length` and two are interpreted as `precision` and `scale`, similar to
+  how custom types and their arguments are interpreted.
+- Previously, the compiler could not always find a unique redirection target if there were
+  one direct projection on the model target and two or more projections on that projection.
+- The performance of compiler-checks for deeply nested expressions/queries has been improved
+- Fix various bugs in Association to Join translation:
+  + Recursive `$self` dereferencing
+  + Correct resolution of table alias in non-bijective `$self` backlink associations in combination with
+    explicit redirection.
+- to.edm(x): Process value help list convenience annotations on unbound action parameters.
+
+### Removed
+
+- tbd
+
 ## Version 3.6.2 - 2023-02-06
 
 ### Fixed
@@ -365,6 +406,14 @@ The compiler behavior concerning `beta` features can change at any time without
   it is now only allowed for `count`, `min`, `max`, `sum`, `avg`, `stddev`, `var`.
 - All non-SNAPI options.
 
+## Version 2.15.10 - 2023-01-26
+
+### Fixed
+
+- If an entity with parameters is auto-exposed, the generated projection now has
+  the same formal parameters and its query forwards these parameters to the origin entity.
+- to.edm(x): Respect record type hint `$Type` in EDM JSON as full qualified `@type` URI property.
+
 ## Version 2.15.8 - 2022-08-02
 
 ### Fixed

package/README.md

@@ -29,6 +29,9 @@ Or maintain your package.json dependencies as follows:
 
 Please refer to the [official CDS documentation](https://cap.cloud.sap/docs/cds/).
 
+## How to Obtain Support
+
+In case you find a bug, please report an [incident](https://cap.cloud.sap/docs/resources/#reporting-incidents) on SAP Support Portal.
 
 ## License
 

package/bin/cdsc.js

@@ -239,10 +239,13 @@ function displayUsage( error, helpText, code ) {
   // Display help text first, error at the end (more readable, no scrolling)
   out.write(`${helpText}\n`);
   if (error) {
-    if (error instanceof Array)
-      out.write(`${error.map(err => `cdsc: ERROR: ${err}`).join('\n')}\n`);
-    else
+    if (error instanceof Array) {
+      const errors = error.map(err => `cdsc: ERROR: ${err}`).join('\n');
+      out.write(`${errors}\n`);
+    }
+    else {
       out.write(`cdsc: ERROR: ${error}\n`);
+    }
   }
   throw new ProcessExitError(code);
 }
@@ -389,8 +392,8 @@ function executeCommandLine( command, options, args ) {
   // Execute the command line option 'manageConstraints' and display the results.
   function manageConstraints( model ) {
     const csn = options.directBackend ? model : compactModel(model, options);
-    const alterConstraintsResult = alterConstraintsWithCsn(csn, options);
     const { src } = options || {};
+    const alterConstraintsResult = alterConstraintsWithCsn(csn, options);
     Object.keys(alterConstraintsResult).forEach((id) => {
       const renderedConstraintStatement = alterConstraintsResult[id];
       if (src === 'hdi')
@@ -499,8 +502,9 @@ function executeCommandLine( command, options, args ) {
         .forEach(msg => log(msg));
     }
     else if (options.noMessageContext) {
+      // TODO: currently, ‹↓› = "downgradable" is only shown here
       messages.filter(msg => (messageLevels[msg.severity] <= options.warning))
-        .forEach(msg => log(main.messageString(msg, normalizeFilename, !!options.noMessageId)));
+        .forEach(msg => log(main.messageString(msg, normalizeFilename, !!options.noMessageId, false, options.testMode && 'compile'))); // TODO: use module name
     }
     else {
       // Contains file-contents that are split at '\n'. Try to avoid multiple `.split()` calls.

package/doc/CHANGELOG_BETA.md

@@ -8,6 +8,24 @@ Note: `beta` fixes, changes and features are listed in this ChangeLog just for i
 The compiler behavior concerning `beta` features can change at any time without notice.
 **Don't use `beta` fixes, changes and features in productive mode.**
 
+
+## Version 3.7.0 - 2023-02-22
+
+### Added `calculatedElements`
+
+Allows to define calculated elements in entities and aspects.  When used in views, they
+are replaced by their value, for example:
+
+```cds
+entity E { one: Integer; two = one + 1; };
+entity P as projection on E { two };
+// P is the same as:
+entity P as projection on E { one + 1 as two };
+```
+
+This allows to define calculations centrally at the entity, which can be used by
+other views.
+
 ## Version 3.5.0 - 2022-12-07
 
 ### Added `odataTerms`
@@ -250,7 +268,7 @@ Render JOIN cardinality in native HANA association if provided. If no cardinalit
 
 ### Removed `aspectCompositions`
 
-Aspect compositions aka managed compositions are now avaible without beta option.
+Aspect compositions aka managed compositions are now available without beta option.
 _Warning_: the CSN representation can still change.
 
 ## Version 1.31.0 - 2020-06-26
@@ -286,5 +304,5 @@ This option does not enable:
 ### Added `keyRefError`
 
 Always signal an error (instead of just a warning in some cases),
-if not all references in the `keys` of an managed associations
+if not all references in the `keys` of a managed associations
 are projected in the new target.

package/doc/CHANGELOG_DEPRECATED.md

@@ -15,7 +15,7 @@ and several new features are not available.**
 
 ### Added `autoCorrectOrderBySourceRefs`
 
-When this option is set, calling `compile` auto-corrects direct `order by`
+When this option is set, calling `compile` autocorrects direct `order by`
 source element references without table alias for SELECT queries by adding the
 table alias to the `ref`.
 
@@ -153,7 +153,7 @@ Render old and broken temporal EDM API.
 ### Added `noElementsExpansion`
 
 When setting it, association in sub elements are not automatically redirected,
-and the sub elements cannot be annotated indivually.
+and the sub elements cannot be annotated individually.
 
 Do not use this.  Setting it might avoid some compile errors,
 but in most cases the reported errors are rightly reported.

package/lib/api/main.js

@@ -63,6 +63,7 @@ function attachTransformerCharacteristics( csn, transformation, options,
       relevant[name] = options[name];
   }
 
+  // eslint-disable-next-line sonarjs/no-empty-collection
   for (const name of relevantGeneralOptions ) {
     if (options[name] !== undefined)
       relevant[name] = options[name];
@@ -763,7 +764,7 @@ function flattenResultStructure( toProcess ) {
 /**
  * Print args to stderr if CDSC_TRACE_API is set
  *
- * @param {...any} args
+ * @param {...any} args to be logged to stderr
  */
 function traceApi( ...args ) {
   if (process?.env?.CDSC_TRACE_API !== undefined) {

package/lib/base/dictionaries.js

@@ -81,6 +81,15 @@ function dictAddArray( dict, name, entry, messageCallback ) {
   return entry;
 }
 
+function dictFirst( dict ) {
+  if (!dict)
+    return dict;
+  for (const name in dict) {
+    return dict[name];
+  }
+  return undefined;
+}
+
 // Push `entry` to the array value with key `name` in the dictionary `dict`.
 function pushToDict( dict, name, entry ) {
   if (dict[name])
@@ -93,5 +102,6 @@ module.exports = {
   dictAdd,
   dictForEach,
   dictAddArray,
+  dictFirst,
   pushToDict,
 };

package/lib/base/message-registry.js

@@ -159,6 +159,8 @@ const centralMessages = {
 
   'def-missing-element': { severity: 'Error' },
 
+  'def-unsupported-calc-elem': { severity: 'Error', configurableFor: true },
+
   'unexpected-keys-for-composition': { severity: 'Error' }, // TODO: more than 30 chars
   'unmanaged-as-key': { severity: 'Error', configurableFor: 'deprecated' }, // is confusing
   'composition-as-key': { severity: 'Error', configurableFor: 'deprecated' }, // is confusing and not supported
@@ -231,11 +233,15 @@ const centralMessageTexts = {
     std: 'Duplicate assignment with $(ANNO)',
     doc: 'Duplicate assignment with a doc comment',
   },
+  'anno-duplicate-same-file': {
+    std: 'Duplicate assignment with $(ANNO), using last',
+    doc: 'Duplicate assignment with a doc comment, using last',
+  },
   'anno-duplicate-unrelated-layer': {
     std: 'Duplicate assignment with $(ANNO)',
     doc: 'Duplicate assignment with a doc comment',
   },
-  'anno-unstable-array': 'Unstable order of array items due to repeated assignments for $(ANNO) in unrelated layers',
+  'anno-unstable-array': 'Unstable order of array items due to repeated assignments for $(ANNO)',
   'anno-mismatched-ellipsis': 'An array with $(CODE) can only be used if there is an assignment below with an array value',
   'anno-unexpected-ellipsis': 'No base annotation available to apply $(CODE)',
   'anno-unexpected-ellipsis-layers': 'No base annotation available to apply $(CODE)',
@@ -360,7 +366,6 @@ const centralMessageTexts = {
     dynamic: 'Dynamic parameter $(CODE) is not supported',
     positional: 'Positional parameter $(CODE) is not supported',
   },
-  // 'syntax-unsupported-method', 'syntax-unsupported-new'
 
   // Syntax messages, CSN parser - default: Error  ------------------------------
   'syntax-deprecated-dollar-syntax': {
@@ -420,7 +425,7 @@ const centralMessageTexts = {
     extend: 'CSN property $(PROP) is not expected by an extend in $(PARENTPROP)',
     annotate: 'CSN property $(PROP) is not expected by an annotate in $(PARENTPROP)',
   },
-  'syntax-invalid-calc-elem': {
+  'def-invalid-calc-elem': {
     std: 'Invalid calculated element',
     key: 'A primary key element can\'t be calculated',
     virtual: 'A virtual element can\'t be calculated',
@@ -430,7 +435,12 @@ const centralMessageTexts = {
     type: 'A type can\'t have calculated elements',
     action: 'An action can\'t have calculated elements',
     function: 'A function can\'t have calculated elements',
-    annotation: 'Annotation definitions can\'t have calculated elements'
+    annotation: 'Annotation definitions can\'t have calculated elements',
+    param: 'Parameters can\'t have calculated elements',
+  },
+  'def-unsupported-calc-elem': {
+    std: 'Calculated elements are not supported',
+    nested: 'Calculated elements in structures are not supported, yet'
   },
   // 'syntax-unknown-property' (Warning? Better configurable Error)
 
@@ -489,6 +499,10 @@ const centralMessageTexts = {
     std: '$(ART) can\'t be extended because it originates from an include',
     elements: '$(ART) can\'t be extended by elements/enums because it originates from an include',
   },
+  'ref-unexpected-scope': {
+    std: 'Unexpected parameter reference',
+    calc: 'Calculated elements can\'t use parameter references',
+  },
   'ref-unexpected-structured': {
     std: 'Unexpected usage of structured type $(ELEMREF)',
     expr: 'Structured elements can\'t be used in expressions',
@@ -503,6 +517,16 @@ const centralMessageTexts = {
     expr: 'Associations can\'t be used as values in expressions',
     cast: 'Casting to an association is not supported',
   },
+  'ref-unexpected-calculated': {
+    std: 'Unexpected reference to calculated element',
+    on: 'Calculated elements can\'t be used in ON-conditions of unmanaged associations',
+    fkey: 'Calculated elements can\'t be used as foreign keys for managed associations',
+  },
+
+  'ref-unexpected-navigation': {
+    std: 'Can\'t follow association $(ID) of path $(ELEMREF) in an ON-condition; only foreign keys can be referred to, but not $(NAME)',
+    unmanaged: 'Can\'t follow unmanaged association $(ID) of path $(ELEMREF) in an ON-condition; only foreign keys can be referred to',
+  },
 
   'type-unexpected-typeof': {
     std: 'Unexpected $(KEYWORD) for the type reference here',
@@ -545,14 +569,14 @@ const centralMessageTexts = {
   },
 
   'def-unexpected-paramview-assoc': {
-    std: 'SAP HANA does no support associations in/to parameterized entities',
-    view: 'SAP HANA does no support associations in parameterized entities',
-    target: 'SAP HANA does no support associations to parameterized entities',
+    std: 'SAP HANA doesn\'t support associations in/to parameterized entities',
+    view: 'SAP HANA doesn\'t support associations in parameterized entities',
+    target: 'SAP HANA doesn\'t support associations to parameterized entities',
   },
   'def-unexpected-calcview-assoc': {
-    std: 'SAP HANA does not allow associations in/to entities annotated with $(ANNO)',
-    'entity-persistence': 'SAP HANA does not allow associations in entities annotated with $(ANNO)',
-    'target-persistence': 'SAP HANA does not allow associations pointing to entities annotated with $(ANNO)',
+    std: 'SAP HANA doesn\'t allow associations in/to entities annotated with $(ANNO)',
+    'entity-persistence': 'SAP HANA doesn\'t allow associations in entities annotated with $(ANNO)',
+    'target-persistence': 'SAP HANA doesn\'t allow associations pointing to entities annotated with $(ANNO)',
   },
   'def-unexpected-key': {
     std: '$(ART) can\'t have additional keys',
@@ -566,9 +590,13 @@ const centralMessageTexts = {
     include:  '$(ART) can\'t have localized elements (through include)',
   },
   'def-unexpected-localized-anno': 'Annotations can\'t have localized elements',
+  'type-unexpected-structure': {
+    std: 'Unexpected structured type', // unused variant
+    calc: 'A structured type can\'t be used for calculated elements',
+  },
 
   'def-missing-element': {
-    std: 'Expecting entity to have at least one non-virtual element',
+    std: 'Expecting entity to have at least one element which is neither virtual nor calculated',
     view: 'Expecting view to have at least one non-virtual element'
   },
 
@@ -595,6 +623,11 @@ const centralMessageTexts = {
     param: 'Duplicate definition of parameter $(NAME)',
     alias: 'Duplicate definition of table alias or mixin $(NAME)',
   },
+  'ref-duplicate-include-member': {
+    std: 'Duplicate member $(NAME) through multiple includes $(SORTED_ARTS)',
+    elements: 'Duplicate element $(NAME) through multiple includes $(SORTED_ARTS)',
+    actions: 'Duplicate action or function $(NAME) through multiple includes $(SORTED_ARTS)',
+  },
 
   // TODO: rename to ref-expected-XYZ
   'expected-actionparam-type': 'A type, an element, or a service entity is expected here',
@@ -645,7 +678,10 @@ const centralMessageTexts = {
     std: 'Expected identifier for select item',
     assoc: 'Expected identifier as the association\'s name',
   },
-
+  'query-unsupported-calc': {
+    std: 'Using nested projections next to calculated elements is not supported, yet',
+    inside: 'Using calculated elements in nested projections is not supported, yet'
+  },
   'ref-sloppy-type': 'A type or an element is expected here',
   'ref-sloppy-actionparam-type': 'A type, an element, or a service entity is expected here',
   'ref-sloppy-target': 'An entity or an aspect (not type) is expected here',
@@ -658,6 +694,14 @@ const centralMessageTexts = {
     entity: 'Entity $(ART) with managed compositions can\'t be used in types', // yet
   },
 
+  // -----------------------------------------------------------------------------------
+  // Expressions
+  // -----------------------------------------------------------------------------------
+  'expr-invalid-operator': 'Comparing $(ID) is only allowed with $(OP)',
+  'expr-missing-comparison': {
+    std: 'Expected a comparison with $(OP) when using $(ID) in an ON-condition',
+  },
+
   'i18n-different-value': 'Different translation for key $(PROP) of language $(OTHERPROP) in unrelated layers',
 
   // OData version dependent messages

package/lib/base/messages.js

@@ -766,6 +766,12 @@ function transformManyWith( t, sorted ) {
   };
 }
 
+/**
+ * Quote the given string.  Performs a type sanity check.
+ *
+ * @param {string} name
+ * @return {string}
+ */
 function quoted( name ) {
   if (typeof name === 'string')
     return quote.double( name );
@@ -912,16 +918,16 @@ function weakLocation( loc ) {
  * @param {boolean} [noHome]
  * @returns {string}
  */
-function messageString( err, normalizeFilename, noMessageId, noHome ) {
-  return (err.$location && err.$location.file
-    ? `${ locationString( err.$location, normalizeFilename ) }: `
-    : '') +
-         (err.severity || 'Error') +
-         // TODO: use [message-id]
-         (err.messageId && !noMessageId ? ` ${ err.messageId }: ` : ': ') +
-         err.message +
-         // even with noHome, print err.home if the location is weak
-         (!err.home || noHome && err.$location && err.$location.endLine ? '' : ` (in ${ err.home })`);
+function messageString( err, normalizeFilename, noMessageId, noHome, moduleName = undefined ) {
+  const location = (err.$location?.file ? `${ locationString( err.$location, normalizeFilename ) }: ` : '');
+  const severity = err.severity || 'Error';
+  const downgradable = severity === 'Error' && moduleName &&
+    isDowngradable(err.messageId, moduleName, false) ? '‹↓›' : '';
+  // even with noHome, print err.home if the location is weak
+  const home = !err.home || noHome && err.$location?.endLine ? '' : ` (in ${ err.home })`;
+  // TODO: the plan was with brackets = `Error[ref-undefined-def]`
+  const id = err.messageId && !noMessageId ? ` ${ err.messageId }` : '';
+  return `${ location }${ severity }${ downgradable }${ id }: ${ err.message }${ home }`;
 }
 
 /**
@@ -1309,6 +1315,12 @@ function homeNameForExtend( art ) {
 function constructSemanticLocationFromCsnPath( model, options, csnPath ) {
   if (!model)
     return null;
+
+  if (options.testMode)
+    sanitizeCsnPath(csnPath);
+
+  const _quoted = options.testMode ? quoted : quote.double;
+
   let result = '';
   const csnDictionaries = [
     'args', 'params', 'enum', 'mixin', 'elements', 'actions', 'definitions',
@@ -1338,12 +1350,12 @@ function constructSemanticLocationFromCsnPath( model, options, csnPath ) {
   if (step === 'definitions') {
     next(); // "definitions"
     const kind = currentThing?.kind || 'artifact';
-    result += `${ kind }:${ quoted(step) }`;
+    result += `${ kind }:${ _quoted(step) }`;
   }
   else if (step === 'vocabularies') {
     next(); // dictionary name
     if (index < csnPath.length)
-      result += `annotation:${ quoted(csnPath[index]) }`;
+      result += `annotation:${ _quoted(csnPath[index]) }`;
     else
       result += 'vocabularies';
   }
@@ -1355,7 +1367,7 @@ function constructSemanticLocationFromCsnPath( model, options, csnPath ) {
     else {
       const name = currentThing.annotate || currentThing.extend;
       const kind = currentThing.annotate ? 'annotate' : 'extend';
-      result += `${ kind }:${ quoted(name) }`;
+      result += `${ kind }:${ _quoted(name) }`;
     }
   }
 
@@ -1381,7 +1393,7 @@ function constructSemanticLocationFromCsnPath( model, options, csnPath ) {
         next();
       }
       if (elementHierarchy.length > 0)
-        result += `/element:${quoted(elementHierarchy.join('.'))}`;
+        result += `/element:${ _quoted(elementHierarchy.join('.')) }`;
       // no trailing /elements or /items
       continue;
     }
@@ -1389,7 +1401,7 @@ function constructSemanticLocationFromCsnPath( model, options, csnPath ) {
       next(); // "actions"
       if (index < csnPath.length) {
         const kind = currentThing?.kind || 'action';
-        result += `/${ kind }:${ quoted(csnPath[index]) }`;
+        result += `/${ kind }:${ _quoted(csnPath[index]) }`;
       }
       else { // actions is last segment
         result += '/actions';
@@ -1419,7 +1431,7 @@ function constructSemanticLocationFromCsnPath( model, options, csnPath ) {
     }
     else if (step === 'target') {
       if (currentThing)
-        result += '/target:' + quoted(currentThing);
+        result += '/target:' + _quoted(currentThing);
       else
         result += '/target';
       break;
@@ -1447,14 +1459,14 @@ function constructSemanticLocationFromCsnPath( model, options, csnPath ) {
       next(); // "keys"
       if (index < csnPath.length) {
         const key = aliasOrReference();
-        result += `/key:${ key ? quoted(key) : step }`;
+        result += `/key:${ key ? _quoted(key) : step }`;
       }
       break;
     }
     else if (step[0] === '@') {
       // Annotations are always the last step.
       // Nothing comes after them, everything is user defined.
-      result += `/${ quoted(csnPath[index]) }`;
+      result += `/${ _quoted(csnPath[index]) }`;
       break;
     }
     else {
@@ -1470,7 +1482,7 @@ function constructSemanticLocationFromCsnPath( model, options, csnPath ) {
   function dictEntry( prefix ) {
     next(); // dictionary name
     if (index < csnPath.length)
-      result += `/${ prefix }:${ quoted(csnPath[index]) }`;
+      result += `/${ prefix }:${ _quoted(csnPath[index]) }`;
   }
 
   /**
@@ -1548,7 +1560,7 @@ function constructSemanticLocationFromCsnPath( model, options, csnPath ) {
         } while (index < csnPath.length);
 
         if (elementHierarchy.length > 0)
-          result += `/column:${ quoted(elementHierarchy.join('.')) }`;
+          result += `/column:${ _quoted(elementHierarchy.join('.')) }`;
       }
       else if(step === 'args') {
         // Should only be reached for cases, where no SELECT in a union is picked.
@@ -1595,6 +1607,13 @@ function queryDepthForMessage( csnPath, model, view ) {
   return 0;
 }
 
+function sanitizeCsnPath(csnPath) {
+  for (const step of csnPath) {
+    if (typeof step !== 'string' && typeof step !== 'number')
+      throw new CompilerAssertion(`Found CSN path step that is neither string nor number: ${step} ${ JSON.stringify(csnPath) }`)
+  }
+}
+
 /**
  * Get the explanation string for the given message-id.
  * Ensure to have called hasMessageExplanation() before.

package/lib/base/model.js

@@ -22,6 +22,7 @@ const queryOps = {
 const availableBetaFlags = {
   // enabled by --beta-mode
   calculatedElements: true,
+  annotationExpressions: true,
   toRename: true,
   assocsWithParams: true,
   hanaAssocRealCardinality: true,

package/lib/base/shuffle.js

@@ -2,7 +2,8 @@
 
 // By <https://github.com/bryc/code/blob/c97a26ad27a9f9d4f48cd3307fd8ee6f1772d4eb/jshash/PRNGs.md>:
 
-// The random seed must be an integer between 0 and 4294967295 (or 1 and 4294967296  = 2**32)
+// The random seed must be an integer between 1 and 4294967296 (= 2**32),
+// otherwise no shuffling takes place.
 function shuffleGen( seed ) {
   return (Number.isSafeInteger( seed ) && seed > 0)
     ? { shuffleArray, shuffleDict }

package/lib/checks/elements.js

@@ -208,6 +208,34 @@ function checkRecursiveTypeUsage( art ) {
     }
   }
 }
+
+/**
+ * Member validator to check that certain annotations (@cds.valid { from, to, key }) are not
+ * assigned to calculated elements in an entity.
+ *
+ * TODO: Allow @cds.valid on persisted calculated elements (when they become available).
+ *
+ * @param {CSN.Element} member the element to be checked
+ * @param {string} _memberName the elements name
+ * @param {string} _prop which kind of member are we looking at -> only prop "elements"
+ * @param {CSN.Path} _path the path to the member
+ */
+function rejectAnnotationsOnCalcElement( member, _memberName, _prop, _path ) {
+  if (this.artifact.kind === 'entity' && !(this.artifact.query && this.artifact.projection)) {
+    if (member.value) {
+      for (const anno in member) {
+        if (anno.startsWith('@cds.valid.')) {
+          this.error('anno-unexpected-temporal', member.$path, { anno },
+                     'Unexpected $(ANNO) assigned to a calculated element');
+        }
+      }
+    }
+  }
+}
 module.exports = {
-  checkPrimaryKey, checkVirtualElement, checkManagedAssoc, checkRecursiveTypeUsage,
+  checkPrimaryKey,
+  checkVirtualElement,
+  checkManagedAssoc,
+  checkRecursiveTypeUsage,
+  rejectAnnotationsOnCalcElement,
 };

package/lib/checks/{emptyOrOnlyVirtual.js → hasPersistedElements.js}

@@ -1,8 +1,10 @@
 'use strict';
 
-const { isPersistedOnDatabase } = require('../model/csnUtils.js');
 // Only to be used with validator.js - a correct this value needs to be provided!
 // not relevant for odata - entities need to be checked at the end of the transformation
+
+const { isPersistedOnDatabase } = require('../model/csnUtils.js');
+
 /**
  * Ensure that empty/only virtual entities do not reach the db.
  *
@@ -11,22 +13,24 @@ const { isPersistedOnDatabase } = require('../model/csnUtils.js');
  * @param {string} prop Property being looped over
  * @param {CSN.Path} path Path to the artifact
  */
-function validateEmptyOrOnlyVirtual( artifact, artifactName, prop, path ) {
+function validateHasPersistedElements( artifact, artifactName, prop, path ) {
   if (artifact.kind === 'entity' && isPersistedOnDatabase(artifact)) {
     if (!artifact.elements || !hasRealElements(artifact.elements))
+      // TODO: Maybe check if there are only calc elements and adapt the message?
       this.error('def-missing-element', path, { '#': artifact.query ? 'view' : 'std' });
   }
 }
 
 /**
- * Check if the provided elements contain elements that will be created on the db.
+ * Check if the provided elements contain elements that will be created on the database.
+ * This includes virtual and calculated elements.
  *
  * @param {CSN.Elements} elements Elements to look through
  * @returns {boolean} True if something would be created on the db from these elements.
  */
 function hasRealElements( elements ) {
   for (const element of Object.values(elements)) {
-    if (!element.virtual) {
+    if (!element.virtual && !element.value) {
       if (element.elements) {
         if (hasRealElements(element.elements))
           return true;
@@ -41,4 +45,4 @@ function hasRealElements( elements ) {
 }
 
 
-module.exports = validateEmptyOrOnlyVirtual;
+module.exports = validateHasPersistedElements;

package/lib/checks/nonexpandableStructured.js

@@ -21,7 +21,7 @@ function nonexpandableStructuredInExpression( parent, name, expression ) {
       if (_art) {
         _art = resolveArtifactType.call(this, _art);
         // Paths of an expression may end on a structured element only if both operands in the expression end on a structured element
-        if ((_art?.elements || _art?.keys && (i === 0 || expression[i - 1] !== 'exists')) && !validStructuredElement && $scope !== '$self') { // TODO: Use $self to navigate to struct
+        if ((_art?.elements || _art?.keys && (i === 0 || expression[i - 1] !== 'exists')) && !validStructuredElement && ($scope !== '$self' || $scope === '$self' && ref.length > 1)) { // TODO: Use $self to navigate to struct
           this.error('ref-unexpected-structured',
                      name === 'on' ? [ ...parent.$path, name, i ] : expression[i].$path,
                      { '#': 'std', elemref: { ref } } );