@sap/cds-compiler 4.3.0 → 4.4.0

package/CHANGELOG.md

@@ -7,6 +7,42 @@
 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 4.4.0 - 2023-11-09
+
+### Added
+
+- compiler: International letters such as `ä` can now be used in CDS identifiers without quoting.
+  Unicode letters similar to JavaScript are allowed.
+- to.edm(x):
+  + Allow to render all complex types within a requested service as `OpenType=true` with option `--odata-open-type`.
+    Explicit `@open: false` annotations are not overwritten.
+  + Allow to annotate the generated draft artifacts but not generated foreign keys (as with any other managed association).
+- to.sql|hdi|hdbcds: Allow annotating the generated `.drafts` tables.
+
+### Changed
+
+- CDL parser: improve error recovery inside structured annotation values
+- Update OData vocabularies: 'Aggregation', 'Common', 'Core', 'Hierarchy', 'ODM', 'UI'.
+
+### Fixed
+
+- parser:
+  + `/**/` was incorrectly parsed as an unterminated doc-comment, leading to parse errors.
+  + Doc-comments consisting only of `*` were not correctly parsed.
+- compiler: do not propagate `default`s in a CSN of flavor `xtended`/`gensrc`.
+- to.hana: Fix various bugs in association to join translation. Support `$self` references
+  in filter expressions.
+- to.edm(x): Omit `EntitySet` attribute on `Edm.FunctionImport` and `Edm.ActionImport` that return
+  a singleton.
+- to.sql|hdi.migration: Improve handling of primary key changes - detect them and render corresponding drop-create.
+
+## Version 4.3.2 - 2023-10-25
+
+### Fixed
+
+- compiler: Fix auto-exposure of composition target entities inside anonymous composition target aspects.
+- to.hana: Fix a bug in association to join translation, expect ON condition operand to be a function without arguments.
+
 ## Version 4.3.0 - 2023-09-29
 
 ### Added

package/lib/api/main.js

@@ -37,6 +37,7 @@ const { ModelError } = require('../base/error');
 const { forEach, forEachKey } = require('../utils/objectUtils');
 const { checkRemovedDeprecatedFlags } = require('../base/model');
 const { csn2edm, csn2edmAll } = require('../edm/csn2edm');
+const { traceApi } = require('./trace');
 
 const relevantGeneralOptions = [ /* for future generic options */ ];
 const relevantOdataOptions = [ 'sqlMapping', 'odataFormat' ];
@@ -146,7 +147,7 @@ function odataInternal( csn, internalOptions ) {
  * @returns {oDataCSN} Return an oData-pre-processed CSN
  */
 function odata( csn, options = {} ) {
-  traceApi("Options passed into 'for.odata'", options);
+  traceApi('for.odata', options);
   const internalOptions = prepareOptions.for.odata(options);
   return odataInternal(csn, internalOptions);
 }
@@ -159,7 +160,7 @@ function odata( csn, options = {} ) {
  * @returns {object} { model: string, namespace: string }
  */
 function cdl( csn, options = {} ) {
-  traceApi("Options passed into 'to.cdl'", options);
+  traceApi('to.cdl', options);
   const internalOptions = prepareOptions.to.cdl(options);
   return toCdl.csnToCdl(csn, internalOptions);
 }
@@ -251,7 +252,7 @@ function forEffective( csn, options = {} ) {
  * @returns {SQL[]} Array of SQL statements, tables first, views second
  */
 function sql( csn, options = {} ) {
-  traceApi("Options passed into 'to.sql'", options);
+  traceApi('to.sql', options);
   const internalOptions = prepareOptions.to.sql(options);
   internalOptions.transformation = 'sql';
 
@@ -274,7 +275,7 @@ function sql( csn, options = {} ) {
  * @returns {HDIArtifacts} { <filename>:<content>, ...}
  */
 function hdi( csn, options = {} ) {
-  traceApi("Options passed into 'to.hdi'", options);
+  traceApi('to.hdi', options);
   const internalOptions = prepareOptions.to.hdi(options);
 
   // we need the CSN for view sorting
@@ -377,7 +378,7 @@ function remapName( key, csn, filter = () => true ) {
  *                                  - createsAndAlters: An array of SQL statements to ALTER/CREATE tables/views
  */
 function sqlMigration( csn, options, beforeImage ) {
-  traceApi("Options passed into 'to.sql.migration'", options);
+  traceApi('to.sql.migration', options);
   const internalOptions = prepareOptions.to.sql(options);
   const {
     error, warning, info, throwWithError, message,
@@ -398,6 +399,8 @@ function sqlMigration( csn, options, beforeImage ) {
       error, warning, info, throwWithError, message,
     }));
     Object.entries(diff.deletions).forEach(entry => diffFilterObj.deletion(entry, error));
+    diff.changedPrimaryKeys = diff.changedPrimaryKeys
+      .filter(an => diffFilterObj.changedPrimaryKeys(an));
   }
 
   const identifierUtils = sqlUtils.getIdentifierUtils(csn, internalOptions);
@@ -530,7 +533,7 @@ function sqlMigration( csn, options, beforeImage ) {
  * @returns {migration} The migration result
  */
 function hdiMigration( csn, options, beforeImage ) {
-  traceApi("Options passed into 'to.hdi.migration'", options);
+  traceApi('to.hdi.migration', options);
   const internalOptions = prepareOptions.to.hdi(options);
 
   // Prepare after-image.
@@ -615,7 +618,7 @@ sql.migration = sqlMigration;
  * @returns {HDBCDS} { <filename>:<content>, ...}
  */
 function hdbcds( csn, options = {} ) {
-  traceApi("Options passed into 'to.hdbcds'", options);
+  traceApi('to.hdbcds', options);
   const internalOptions = prepareOptions.to.hdbcds(options);
   internalOptions.transformation = 'hdbcds';
 
@@ -632,7 +635,7 @@ function hdbcds( csn, options = {} ) {
  * @returns {edm} The JSON representation of the service
  */
 function edm( csn, options = {} ) {
-  traceApi("Options passed into 'to.edm'", options);
+  traceApi('to.edm', options);
   // If not provided at all, set service to undefined to trigger validation
   const internalOptions = prepareOptions.to.edm(
     // eslint-disable-next-line comma-dangle
@@ -663,7 +666,7 @@ edm.all = edmall;
  * @returns {edms} { <service>:<JSON representation>, ...}
  */
 function edmall( csn, options = {} ) {
-  traceApi("Options passed into 'to.edm.all'", options);
+  traceApi('to.edm.all', options);
   const internalOptions = prepareOptions.to.edm(options);
   const { error } = messages.makeMessageFunction(csn, internalOptions, 'for.odata');
 
@@ -694,7 +697,7 @@ function edmall( csn, options = {} ) {
  * @returns {edmx} The XML representation of the service
  */
 function edmx( csn, options = {} ) {
-  traceApi("Options passed into 'to.edmx'", options);
+  traceApi('to.edmx', options);
   // If not provided at all, set service to undefined to trigger validation
   const internalOptions = prepareOptions.to.edmx(
     // eslint-disable-next-line comma-dangle
@@ -726,7 +729,7 @@ edmx.all = edmxall;
  * @returns {edmxs} { <service>:<XML representation>, ...}
  */
 function edmxall( csn, options = {} ) {
-  traceApi("Options passed into 'to.edmx.all'", options);
+  traceApi('to.edmx.all', options);
   const internalOptions = prepareOptions.to.edmx(options);
 
   const result = {};
@@ -843,19 +846,6 @@ function flattenResultStructure( toProcess ) {
   return result;
 }
 
-/**
- * Print args to stderr if CDSC_TRACE_API is set
- *
- * @param {...any} args to be logged to stderr
- */
-function traceApi( ...args ) {
-  if (process?.env?.CDSC_TRACE_API !== undefined) {
-    for (const arg of args) {
-      // eslint-disable-next-line no-console
-      console.error( `${ typeof arg === 'object' ? JSON.stringify(arg, null, 2) : arg }`);
-    }
-  }
-}
 
 module.exports = {
   odata: publishCsnProcessor(odata, 'for.odata'),

package/lib/api/options.js

@@ -42,6 +42,7 @@ const publicOptionsNewAPI = [
   'odataXServiceRefs',
   'odataV2PartialConstr',
   'odataVocabularies',
+  'odataOpenType',
   'service',
   'serviceNames',
   //

package/lib/api/trace.js

@@ -0,0 +1,38 @@
+
+'use strict';
+
+const shouldTraceApi = process?.env?.CDSC_TRACE_API;
+
+/**
+ * Placeholder for disabled tracing (no-op).
+ *
+ * @param {string} apiName API name
+ * @param {object} options Options passed to the API.
+ * @param {...any} [args] Arguments to be logged to stderr
+ */
+// eslint-disable-next-line no-unused-vars
+function noOp( apiName, options, ...args ) {
+  // no-op
+}
+
+/**
+ * Print args to stderr if CDSC_TRACE_API is set
+ *
+ * @param {string} apiName API name
+ * @param {object} options Options passed to the API.
+ * @param {...any} [args] Arguments to be logged to stderr
+ */
+function traceApi( apiName, options, ...args ) {
+  const optStr = typeof options === 'object' ? JSON.stringify(options, null, 2) : options;
+  const argsStr = args.map(val => JSON.stringify(val)).join(', ');
+  const rest = args.length > 0 ? ` | ${ argsStr }` : '';
+  // Local require: Only load on-demand, not when tracing is disabled.
+  // eslint-disable-next-line global-require
+  const { version } = require('../../package.json');
+  // eslint-disable-next-line no-console
+  console.error( `CDSC_TRACE_API | ${ version } | ${ apiName }(…) | options: ${ optStr }${ rest }`);
+}
+
+module.exports = {
+  traceApi: shouldTraceApi ? traceApi : noOp,
+};

package/lib/base/location.js

@@ -76,7 +76,35 @@ function emptyWeakLocation( filename ) {
  * @returns {CsnLocation}
  */
 function weakLocation( loc ) {
-  return {
+  return (!loc?.endLine) ? loc : {
+    __proto__: CsnLocation.prototype,
+    file: loc.file,
+    line: loc.line,
+    col: loc.col,
+    endLine: undefined,
+    endCol: undefined,
+  };
+}
+
+/**
+ * Return a location to be used for compiler-generated artifacts whose location is
+ * best derived from a reference (`type`, `includes`, `target`, `value`) or a name.
+ * Omit the end position to indicate that this is just an approximate location.
+ *
+ * If represented by a `path` (not always the case for a `name`), use the location
+ * of its last item.  Reason: think of an IDE functionality “Go to Definition” – only
+ * a double-click on the _last_ identifier token of the reference jumps to the artifact
+ * represented by the complete reference.
+ *
+ * @param {CsnLocation} loc
+ * @returns {CsnLocation}
+ */
+function weakRefLocation( ref ) {
+  if (!ref)
+    return ref;
+  const { path } = ref;
+  const loc = path?.length ? path[path.length - 1].location : ref.location;
+  return (!loc?.endLine) ? loc : {
     __proto__: CsnLocation.prototype,
     file: loc.file,
     line: loc.line,
@@ -86,6 +114,21 @@ function weakLocation( loc ) {
   };
 }
 
+/**
+ * @param {CsnLocation} loc
+ * @returns {CsnLocation}
+ */
+function weakEndLocation( loc ) {
+  return loc && {
+    __proto__: CsnLocation.prototype,
+    file: loc.file,
+    line: loc.endLine,
+    col: loc.endCol && loc.endCol - 1,
+    endline: undefined,
+    endCol: undefined,
+  };
+}
+
 /**
  * Returns a dummy location for built-in definitions.
  *
@@ -172,6 +215,8 @@ module.exports = {
   emptyLocation,
   emptyWeakLocation,
   weakLocation,
+  weakRefLocation,
+  weakEndLocation,
   builtinLocation,
   dictLocation,
   locationString,

package/lib/base/message-registry.js

@@ -57,11 +57,11 @@ const centralMessages = {
   'anno-invalid-sql-kind': { severity: 'Error', configurableFor: true  },  // @sql.prepend/append - configurable for "I know what I'm doing"
   'anno-invalid-sql-view': { severity: 'Error', configurableFor: true  },  // @sql.prepend/append - configurable for "I know what I'm doing"
   'anno-invalid-sql-view-element': { severity: 'Error', configurableFor: true },  // @sql.prepend/append - configurable for "I know what I'm doing"
-  'anno-undefined-action':  { severity: 'Warning' },
-  'anno-undefined-art':     { severity: 'Warning' }, // for annotate statement (for CDL path root)
-  'anno-undefined-def':     { severity: 'Warning' }, // for annotate statement (for CSN or CDL path cont)
-  'anno-undefined-element': { severity: 'Warning' },
-  'anno-undefined-param':   { severity: 'Warning' },
+  'ext-undefined-action':  { severity: 'Warning' },
+  'ext-undefined-art':     { severity: 'Warning' }, // for annotate statement (for CDL path root)
+  'ext-undefined-def':     { severity: 'Warning' }, // for annotate statement (for CSN or CDL path cont)
+  'ext-undefined-element': { severity: 'Warning' },
+  'ext-undefined-param':   { severity: 'Warning' },
   'anno-unexpected-ellipsis': { severity: 'Error', configurableFor: 'deprecated' },
   'anno-unexpected-localized-skip': { severity: 'Error', configurableFor: true },
 
@@ -105,7 +105,6 @@ const centralMessages = {
 
   'param-default': { severity: 'Error' }, // not supported yet
 
-  'query-undefined-element': { severity: 'Error' },
   'query-unexpected-assoc-hdbcds': { severity: 'Error' },
   'query-unexpected-structure-hdbcds': { severity: 'Error' },
   'query-ignoring-param-nullability': { severity: 'Info' },
@@ -122,10 +121,12 @@ const centralMessages = {
   'ref-undefined-def':    { severity: 'Error' },
   'ref-undefined-var':    { severity: 'Error' },
   'ref-undefined-element': { severity: 'Error' },
+  'anno-undefined-element': { severity: 'Warning' },
   'ref-unknown-var': { severity: 'Info', errorFor: [ 'to.hdbcds', 'to.sql', 'to.hdi', 'to.rename' ] },
   'ref-obsolete-parameters': { severity: 'Error', configurableFor: 'v4' },
            // does not hurt us, but makes it tedious to detect parameter refs
   'ref-undefined-param': { severity: 'Error' },
+  'anno-undefined-param': { severity: 'Warning' },
   'ref-rejected-on': { severity: 'Error' },
   'ref-expected-element': { severity: 'Error' },
 
@@ -159,7 +160,6 @@ const centralMessages = {
   'syntax-unsupported-masked': { severity: 'Error', configurableFor: 'deprecated' },
   'syntax-unexpected-sql-clause': { severity: 'Error' }, // TODO: configurableFor:'tests'?
 
-  'type-managed-composition': { severity: 'Error' },
   'type-unsupported-precision-change': { severity: 'Error' },
   'type-unsupported-key-change': { severity: 'Error', configurableFor: true },
 
@@ -537,6 +537,8 @@ const centralMessageTexts = {
     on: 'Unexpected $(ID) reference; is valid only if compared to be equal to an association of the target side',
     subQuery: 'Unexpected $(ID) reference in a sub query',
     setQuery: 'Unexpected $(ID) reference in a query on the right side of $(OP)',
+    exists: 'With $(NAME), path steps must not start with $(ID)',
+    'exists-filter': 'Unexpected $(ID) reference in filter of path $(ELEMREF) following “EXISTS” predicate',
   },
   'ref-undefined-def': {
     std: 'Artifact $(ART) has not been found',
@@ -544,16 +546,29 @@ const centralMessageTexts = {
     element: 'Artifact $(ART) has no element $(MEMBER)',
   },
   'ref-undefined-param': 'Entity $(ART) has no parameter $(ID)',
+  'anno-undefined-param': {
+    std: 'Entity $(ART) has no parameter $(ID)',
+    entity: 'Entity $(ART) has no parameter $(ID)',
+    action: 'Action $(ART) has no parameter $(ID)',
+  },
   'ref-undefined-art': 'No artifact has been found with name $(ART)',
   // TODO: proposal 'No definition found for $(NAME)',
   'ref-undefined-element': {
     std: 'Element $(ART) has not been found',
     element: 'Artifact $(ART) has no element $(MEMBER)',
     target: 'Target entity $(ART) has no element $(ID)',
-    aspect: 'Element $(ID) has not been found in the anonymous target aspect',
+    aspect: 'Element $(ID) has not been found in the anonymous target aspect', // TODO: still?
     query: 'The current query has no element $(ART)',
+    alias: 'Element $(ART) has not been found in the sub query for alias $(ALIAS)',
     virtual: 'Element $(ART) has not been found. Use $(CODE) to add virtual elements in queries'
   },
+  'anno-undefined-element': {
+    std: 'Element $(ART) has not been found',
+    element: 'Artifact $(ART) has no element $(MEMBER)',
+    target: 'Target entity $(ART) has no element $(ID)',
+    query: 'The current query has no element $(ART)',
+    alias: 'Element $(ART) has not been found in the sub query for alias $(ALIAS)',
+  },
   'ref-undefined-var': {
     std: 'Variable $(ID) has not been found',
     alias: 'Variable $(ID) has not been found. Use table alias $(ALIAS) to refer an element with the same name',
@@ -642,6 +657,9 @@ const centralMessageTexts = {
     select: 'Unexpected $(KEYWORD) for type references in queries',
     annotation: '$(KEYWORD) can\'t be used in annotation definitions',
   },
+  'type-unexpected-assoc': {
+    std: 'An unmanaged association can\'t be used as type',
+  },
 
   'type-missing-argument': 'Missing value for argument $(NAME) in reference to type $(ID)',
   'type-ignoring-argument': 'Too many arguments for type $(ART)',
@@ -672,20 +690,20 @@ const centralMessageTexts = {
   },
 
   'anno-builtin': 'Builtin types should not be annotated. Use custom type instead',
-  'anno-undefined-def': 'Artifact $(ART) has not been found', // TODO: ext-
-  'anno-undefined-art': 'No artifact has been found with name $(ART)',
-  'anno-undefined-element': {
+  'ext-undefined-def': 'Artifact $(ART) has not been found',
+  'ext-undefined-art': 'No artifact has been found with name $(ART)',
+  'ext-undefined-element': {
     std: 'Element $(NAME) has not been found',
     element: 'Artifact $(ART) has no element $(NAME)',
     enum: 'Artifact $(ART) has no enum $(NAME)',
     returns: 'Return value of $(ART) has no element $(NAME)',
     'enum-returns': 'Return value of $(ART) has no enum $(NAME)',
   },
-  'anno-undefined-action': {
+  'ext-undefined-action': {
     std: 'Action $(ART) has not been found',
     action: 'Artifact $(ART) has no action $(NAME)'
   },
-  'anno-undefined-param': {
+  'ext-undefined-param': {
     std: 'Parameter $(ART) has not been found',
     param: 'Artifact $(ART) has no parameter $(NAME)'
   },
@@ -793,10 +811,20 @@ const centralMessageTexts = {
   'ref-expecting-const': 'A constant expression or variable is expected here',
   'ref-expecting-foreign-key': 'Expecting foreign key access after managed association $(NAME) in filter expression of $(ID), but found $(ALIAS)',
   'ref-invalid-target': {
-    std: 'An entity, projection or view is expected here', // TODO: change text
+    std: 'Expecting an entity as target',
     composition: 'Expecting an entity or aspect as composition target',
     bare: 'Expecting the target aspect to have elements',
-    aspect: 'Expecting the name of an aspect in property $(PROP)', // only CSN input
+    aspect: 'Expecting an aspect in property $(PROP)', // `targetAspect` in CSN input
+    redirected: 'Expecting an entity as target; a target aspect can\'t be specified for redirections',
+    // a `target aspect alone` would be more correct, but confusing if in `target`
+    // property, which is the standard (extra text variants would be too much):
+    entity: 'Expecting an entity as target; a target aspect can\'t be specified for projection elements',
+    event: 'Expecting an entity as target; a target aspect can\'t be specified in an event',
+    select: 'Expecting an entity as target; a target aspect can\'t be specified in a query',
+    type: 'Expecting an entity as target; a target aspect can\'t be specified for a type',
+    param: 'Expecting an entity as target; a target aspect can\'t be specified for a parameter',
+    annotation: 'Expecting an entity as target; a target aspect can\'t be specified for an annotation',
+    sub: 'Expecting an entity as target; a target aspect can\'t be specified for a sub element',
   },
   'ref-invalid-include': {
     std: 'A type, entity, aspect or event with direct elements is expected here',
@@ -965,9 +993,12 @@ const centralMessageTexts = {
   'odata-spec-violation-type': {
     std: 'Expected element to have a type',
     incompatible: 'Unexpected EDM Type $(TYPE) for OData $(VERSION)',
+    incompatible_anno: 'Unexpected EDM Type $(TYPE) for OData $(VERSION) in $(ANNO)',
     facet: 'Unexpected EDM Type facet $(NAME) of type $(TYPE) for OData $(VERSION)',
+    facet_anno: 'Unexpected EDM Type facet $(NAME) of type $(TYPE) for OData $(VERSION) in $(ANNO)',
     external: 'Referenced type $(TYPE) marked as $(ANNO) can\'t be rendered as $(CODE) in service $(NAME) for OData $(VERSION)',
-    scale: 'Expected scale $(NUMBER) to be less than or equal to precision $(RAWVALUE)'
+    scale: 'Expected scale $(NUMBER) to be less than or equal to precision $(RAWVALUE)',
+    scale_anno: 'Expected scale $(NUMBER) to be less than or equal to precision $(RAWVALUE) in $(ANNO)'
   },
   'odata-spec-violation-property-name': 'Expected element name to be different from declaring $(META)',
   'odata-spec-violation-namespace': {
@@ -1050,6 +1081,27 @@ const centralMessageTexts = {
     'deprecated': '$(ANNO) is deprecated. $(DEPR)',
     'notapplied': '$(ANNO) is not applied (AppliesTo: $(RAWVALUES))',
   },
+  'odata-anno-xpr': {
+    'std': 'unused',
+    'notadynexpr': '$(OP) is not a renderable dynamic expression in $(ANNO)',
+    'use': 'Function $(OP) is not a renderable dynamic expression in $(ANNO), please use $(CODE) instead',
+    'canonfuncalias': 'Expected function name $(CODE) to be of the form $(META).$(OTHERMETA) for $(OP) in $(ANNO)',
+  }
+  ,
+  'odata-anno-xpr-type': {
+    'std': 'Expected one qualified type name for $(OP) in $(ANNO)'
+  },
+  'odata-anno-xpr-args': {
+    'std': 'Unexpected arguments for $(OP) in $(ANNO)',
+    'exactly': 'Expected exactly $(COUNT) argument(s) for $(OP) in $(ANNO)',
+    'atleast': 'Expected at least $(COUNT) argument(s) for $(OP) in $(ANNO)',
+    'atmost': 'Expected at most $(COUNT) argument(s) for $(OP) in $(ANNO)',
+    'wrongcount': 'Expected exactly one $(PROP) for $(OP) in $(ANNO)',
+    'wrongref': 'Unexpected arguments or filters in $(ELEMREF) in $(ANNO)',
+    'wrongval': 'Unexpected value for $(OP) in $(ANNO)',
+    'wrongval_meta': 'Expected value for $(OP) to be a $(META) in $(ANNO)',
+    'wrongval_meta_list': 'Expected value for $(OP) to be a $(META) or $(RAWVALUES) in $(ANNO)',
+  }
   // -----------------------------------------------------------------------------------
   // OData Message section ends here, no messages below this line
   // -----------------------------------------------------------------------------------

package/lib/base/messages.js

@@ -428,8 +428,9 @@ function makeMessageFunction( model, options, moduleName = null ) {
     }
 
     let semanticLocation = location[1] ? homeName( location[1], false ) : null;
-    if (location[2]) // optional suffix
-      semanticLocation += `/${ location[2] }`;
+    if (location[2]) { // optional suffix, e.g. annotation
+      semanticLocation += `/${ (typeof location[2] === 'string') ? location[2]: homeName(location[2]) }`;
+    }
 
     const definition = location[1] ? homeName( location[1], true ) : null;
 
@@ -676,6 +677,7 @@ const paramsTransform = {
   newcode: quote.single,
   kind: quote.single,
   meta: quote.angle,
+  othermeta: quote.angle,
   keyword,
   // more complex convenience:
   names: transformManyWith( quoted ),
@@ -1573,6 +1575,9 @@ function constructSemanticLocationFromCsnPath( model, options, csnPath ) {
         result += '/target';
       break;
     }
+    else if (step === 'targetAspect') {
+      // skip
+    }
     else if (step === 'xpr' || step === 'ref' || step === 'as' || step === 'value') {
       break; // don't go into xprs, refs, aliases, values, etc.
     }
@@ -1608,7 +1613,7 @@ function constructSemanticLocationFromCsnPath( model, options, csnPath ) {
     }
     else {
       if (options.testMode)
-        throw new CompilerAssertion(`semantic location: Missing segment: ${ csnPath[index] } for path ${ JSON.stringify( csnPath) }`);
+        throw new CompilerAssertion(`semantic location: Unhandled segment: ${ csnPath[index] } for path ${ JSON.stringify( csnPath) }`);
       break;
     }
     next();

package/lib/checks/.eslintrc.json

@@ -5,6 +5,7 @@
     "jsdoc"
   ],
   "rules": {
+    "cds-compiler/message-no-quotes": "off",
     "quotes": ["error", "single", {
       "avoidEscape": true,
       "allowTemplateLiterals": true

package/lib/checks/actionsFunctions.js

@@ -137,7 +137,7 @@ function checkActionOrFunction( art, artName, prop, path ) {
         // if (!(isMultiSchema && serviceOfType)) {
         this.error(null, currPath,
                    { type: typeName, kind: type.kind, service: serviceName },
-                   '$(TYPE) of kind $(KIND) is defined outside a service and can\'t be used in $(SERVICE)');
+                   'Referenced $(KIND) $(TYPE) can\'t be used in service $(SERVICE) because it is not defined in $(SERVICE)');
         // }
       }
     }

package/lib/checks/annotationsOData.js

@@ -24,8 +24,8 @@ function checkCoreMediaTypeAllowance( member ) {
     'cds.hana.BINARY': 1,
   };
   if (member['@Core.MediaType'] && member.type && !(this.csnUtils.getFinalTypeInfo(member.type)?.type in allowedCoreMediaTypes)) {
-    this.warning(null, member.$path, { names: [ 'Edm.String', 'Edm.Binary' ] },
-                 'Element annotated with “@Core.MediaType” should be of a type mapped to $(NAMES)');
+    this.warning(null, member.$path, { anno: '@Core.MediaType', names: [ 'Edm.String', 'Edm.Binary' ] },
+                 'Element annotated with $(ANNO) should be of a type mapped to $(NAMES)');
   }
 }
 

package/lib/checks/selectItems.js

@@ -45,11 +45,14 @@ function validateSelectItems( query ) {
   };
 
   const transformers = {
+    /*
     columns: aTCB,
     groupBy: aTCB,
-    orderBy: aTCB,
     having: aTCB,
     where: aTCB,
+    */
+    orderBy: aTCB, // filters in order by imply a join, not allowed
+    from: aTCB, // $self refs in from clause filters are not allowed
   };
 
   if (this.options.transformation === 'hdbcds') {

package/lib/compiler/assert-consistency.js

@@ -473,7 +473,7 @@ function assertConsistency( model, stage ) {
       optional: [
         'literal', 'val', 'sym', 'struct', 'variant', 'path', 'name', '$duplicates', 'upTo',
         // expressions as annotation values
-        '$tokenTexts', 'op', 'args', 'func',
+        '$tokenTexts', 'op', 'args', 'func', '_artifact', 'type',
       ],
       // TODO: restrict path to #simplePath
     },
@@ -679,6 +679,7 @@ function assertConsistency( model, stage ) {
         'keys',
         'localized', // e.g. compiler-generated elements for localized: `text` assoc, etc.
         'localized-entity', // `.texts` entity
+        'localized-origin', // `.texts` entity
         'nav', // only used for MASKED, TODO(v5): Remove
         'none', // only used in ensureColumnName(): Used in object representing empty alias
         'query', // inferred query properties, e.g. `key`
@@ -966,7 +967,7 @@ function assertConsistency( model, stage ) {
 
   function isOneOf( values ) {
     return function isOneOfInner( node, parent, prop ) {
-      if (!values.includes( node ))
+      if (!values.includes( node ) && node !== undefined)
         throw new InternalConsistencyError( `Unexpected value '${ node }', expected ${ JSON.stringify( values ) }${ at( [ node, parent ], prop ) }` );
     };
   }

package/lib/compiler/base.js

@@ -82,7 +82,7 @@ function getArtifactName( art ) {
   const { name } = art;
   if (!name)                    // no name
     return name;
-  if (!art.kind)                // annotation assignments
+  if (!art.kind)                // annotation assignments, $self param type
     return { ...art.name, absolute: art.name.id };
   if (art.kind === 'using')
     return { ...art.name, absolute: art.extern.id };

package/lib/compiler/builtins.js

@@ -62,6 +62,19 @@ const typeParameters = {
 // a.k.a "typeProperties"
 typeParameters.list = Object.keys( typeParameters.expectedLiteralsFor );
 
+/**
+ * Properties that are required next to `=` to make an annotation value an actual expression
+ * and not some foreign structure.
+ *
+ * @type {string[]}
+ */
+const xprInAnnoProperties = [
+  'ref', 'xpr', 'list', 'literal', 'val',
+  '#', 'func', 'args', 'SELECT', 'SET',
+  'cast',
+];
+
+
 // const hana = {
 //   BinaryFloat: {},
 //   LocalDate: {},
@@ -178,7 +191,7 @@ function compileArg( src ) {
 const magicVariables = {
   $user: {
     // id and locale are always available
-    elements: { id: {}, locale: {} },
+    elements: { id: {}, locale: {}, tenant: {} },
     // Allow $user.<any>
     $uncheckedElements: true,
     // Allow shortcut in CDL: `$user` becomes `$user.id` in CSN.
@@ -301,6 +314,15 @@ function checkDate( year, month, day ) {
   return !Number.isNaN( year ) && month > 0 && month < 13 && day > 0 && day < 32;
 }
 
+/**
+ * Return whether JSON object `val` is a representation for an annotation expression
+ */
+function isAnnotationExpression( val ) {
+  // TODO: we might allow `'=': true`, not just a string, for expressions, to be
+  // decided → just check truthy at the moment
+  return val['='] && xprInAnnoProperties.some( prop => val[prop] !== undefined );
+}
+
 /**
  * Check that the given time is within boundaries.
  * Checks according to ISO 8601.
@@ -535,10 +557,12 @@ function initBuiltins( model ) {
 
 module.exports = {
   typeParameters,
+  xprInAnnoProperties,
   functionsWithoutParens,
   specialFunctions,
   quotedLiteralPatterns,
   initBuiltins,
+  isAnnotationExpression,
   isInReservedNamespace,
   isBuiltinType,
   isIntegerTypeName,