@sap/cds-compiler 3.4.2 → 3.5.0

package/lib/compiler/.eslintrc.json

@@ -1,4 +1,7 @@
 {
   "root": true,
-  "extends": "../../.eslintrc-ydkjsi.json"
+  "extends": "../../.eslintrc-ydkjsi.json",
+  "rules": {
+    "cds-compiler/message-no-quotes": "warn"
+  }
 }

package/lib/compiler/assert-consistency.js

@@ -404,7 +404,6 @@ function assertConsistency( model, stage ) {
       // TODO: "yes" instead "none": val: true, optional literal/location
       val: {
         requires: [ 'literal', 'location' ],
-        // TODO: rename symbol to sym
         // TODO: struct and variant only for annotation assignments
         optional: [
           'val', 'sym', 'name', '$inferred', '$parens',
@@ -418,7 +417,6 @@ function assertConsistency( model, stage ) {
           'args',
           'func',
           'suffix',
-          'quantifier',
           '$inferred',
           '$parens',
           '_artifact',          // _artifact with "localized data"s 'coalesce'
@@ -441,7 +439,7 @@ function assertConsistency( model, stage ) {
       test: isVal,              // the following for array/struct value
       requires: [ 'location' ],
       optional: [
-        'literal', 'val', 'sym', 'struct', 'variant', 'path', 'name', '$duplicate', 'upTo',
+        'literal', 'val', 'sym', 'struct', 'variant', 'path', 'name', '$duplicates', 'upTo',
       ],
       // TODO: restrict path to #simplePath
     },
@@ -462,7 +460,10 @@ function assertConsistency( model, stage ) {
     join: { test: locationVal( isString ) },
     quantifier: { test: locationVal( isString ) },
     // preliminary -----------------------------------------------------------
-    doc: { kind: true, test: locationVal( isStringOrNull ) }, // doc comment
+    doc: {
+      kind: true,
+      test: locationVal( isStringOrNull ),
+    }, // doc comment
     '@': {
       kind: true,
       inherits: 'value',
@@ -888,7 +889,7 @@ function assertConsistency( model, stage ) {
     return function valWithLocation( node, parent, prop, spec, name ) {
       const valSchema = { val: Object.assign( {}, spec, { test: func } ) };
       const requires = [ 'val', 'location' ];
-      const optional = [ 'literal', '$inferred', '_pathHead' ];
+      const optional = [ 'literal', '$inferred', '$priority', '_pathHead' ];
       standard( node, parent, prop, { schema: valSchema, requires, optional }, name );
     };
   }
@@ -912,7 +913,7 @@ function assertConsistency( model, stage ) {
       isString(node, parent, prop, spec);
   }
 
-  function isOneOf(values) {
+  function isOneOf( values ) {
     return function isOneOfInner( node, parent, prop ) {
       if (!values.includes(node))
         throw new Error( `Unexpected value '${ node }', expected ${ JSON.stringify(values) }${ at( [ node, parent ], prop ) }` );
@@ -959,7 +960,7 @@ function assertConsistency( model, stage ) {
     }
   }
 
-  function isScope(node, parent, prop) {
+  function isScope( node, parent, prop ) {
     // artifact refs in CDL have scope:0 in XSN
     if (Number.isInteger(node))
       return;

package/lib/compiler/builtins.js

@@ -259,7 +259,7 @@ const quotedLiteralPatterns = {
  *
  * @returns {boolean} True if the date is valid.
  */
-function checkDate(year, month, day) {
+function checkDate( year, month, day ) {
   // Negative years are allowed
   year = Math.abs(Number.parseInt(year, 10));
   month = Number.parseInt(month, 10);
@@ -275,7 +275,7 @@ function checkDate(year, month, day) {
  *
  * @returns {boolean} True if the date is valid.
  */
-function checkTime(hour, minutes, seconds) {
+function checkTime( hour, minutes, seconds ) {
   hour = Number.parseInt(hour, 10);
   minutes = Number.parseInt(minutes, 10);
   seconds = seconds ? Number.parseInt(seconds, 10) : 0;
@@ -311,35 +311,35 @@ Object.keys(coreHana).forEach((type) => {
 });
 
 /** @param {string} typeName */
-function isIntegerTypeName(typeName) {
+function isIntegerTypeName( typeName ) {
   return typeCategories.integer.includes(typeName);
 }
 /** @param {string} typeName */
-function isDecimalTypeName(typeName) {
+function isDecimalTypeName( typeName ) {
   return typeCategories.decimal.includes(typeName);
 }
 /** @param {string} typeName */
-function isNumericTypeName(typeName) {
+function isNumericTypeName( typeName ) {
   return isIntegerTypeName(typeName) || isDecimalTypeName(typeName);
 }
 /** @param {string} typeName */
-function isStringTypeName(typeName) {
+function isStringTypeName( typeName ) {
   return typeCategories.string.includes(typeName);
 }
 /** @param {string} typeName */
-function isDateOrTimeTypeName(typeName) {
+function isDateOrTimeTypeName( typeName ) {
   return typeCategories.dateTime.includes(typeName);
 }
 /** @param {string} typeName */
-function isBooleanTypeName(typeName) {
+function isBooleanTypeName( typeName ) {
   return typeCategories.boolean.includes(typeName);
 }
 /** @param {string} typeName */
-function isBinaryTypeName(typeName) {
+function isBinaryTypeName( typeName ) {
   return typeCategories.binary.includes(typeName);
 }
 /** @param {string} typeName */
-function isGeoTypeName(typeName) {
+function isGeoTypeName( typeName ) {
   return typeCategories.geo.includes(typeName);
 }
 /**
@@ -347,7 +347,7 @@ function isGeoTypeName(typeName) {
  *
  * @param {string} typeName
  */
-function isRelationTypeName(typeName) {
+function isRelationTypeName( typeName ) {
   return typeCategories.relation.includes(typeName);
 }
 
@@ -357,7 +357,7 @@ function isRelationTypeName(typeName) {
  * @param {string} absolute
  * @returns {boolean}
  */
-function isInReservedNamespace(absolute) {
+function isInReservedNamespace( absolute ) {
   return absolute.startsWith( 'cds.') &&
     !absolute.match(/^cds\.foundation(\.|$)/) &&
     !absolute.match(/^cds\.outbox(\.|$)/) && // Requested by Node runtime
@@ -375,7 +375,7 @@ function isInReservedNamespace(absolute) {
  * @param {string} type
  * @returns {boolean}
  */
-function isBuiltinType(type) {
+function isBuiltinType( type ) {
   return typeof type === 'string' && isInReservedNamespace(type);
 }
 
@@ -451,7 +451,7 @@ function initBuiltins( model ) {
     for (const name in builtins) {
       const magic = builtins[name];
       // TODO: rename to $builtinFunction
-      const art = { kind: 'builtin', name: { element: name, id: name } };
+      const art = { kind: 'builtin', name: { id: name, absolute: name } };
       artifacts[name] = art;
 
       if (magic.$autoElement)

package/lib/compiler/checks.js

@@ -23,10 +23,12 @@ const { pathName } = require('./utils');
 
 function check( model ) {       // = XSN
   const {
-    error, warning, message,
+    error, warning, message, info,
   } = model.$messageFunctions;
   forEachDefinition( model, checkArtifact );
-  checkSapCommonLocale( model, model.$messageFunctions );
+  forEachGeneric( model, 'vocabularies', checkAnnotationDefinition );
+  checkSapCommonLocale( model );
+  checkSapCommonTextsAspects( model );
   return;
 
   function checkArtifact( art ) {
@@ -36,6 +38,11 @@ function check( model ) {       // = XSN
       art.$queries.forEach( checkQuery );
   }
 
+  function checkAnnotationDefinition( art ) {
+    checkEnumType( art );
+    // TODO: Should we check elements similar to definition-elements as well?
+  }
+
   function checkGenericConstruct( art ) {
     checkName( art );
     if (model.vocabularies) {
@@ -80,14 +87,15 @@ function check( model ) {       // = XSN
     }
   }
 
-  function checkLocalizedElement(elem) {
+  function checkLocalizedElement( elem ) {
     // if it is directly a localized element
     if (elem.localized && elem.localized.val) {
       const type = elem._effectiveType;
       // See discussion issue #6520: should we allow all scalar types?
       if (!type || !type.builtin || type.category !== 'string') {
-        warning(null, [ elem.type?.location, elem ], { keyword: 'localized' },
-                'Keyword $(KEYWORD) should only be used in combination with string types');
+        info('ref-expecting-localized-string', [ elem.type?.location, elem ],
+             { keyword: 'localized' },
+             'Expecting a string type in combination with keyword $(KEYWORD)');
       }
     }
     // "key" keyword at localized element in SELECT list.
@@ -151,7 +159,7 @@ function check( model ) {       // = XSN
    *
    * @param {XSN.Artifact} enumNode
    */
-  function checkEnum(enumNode) {
+  function checkEnum( enumNode ) {
     if (!enumNode.value)
       return;
 
@@ -167,7 +175,7 @@ function check( model ) {       // = XSN
     }
   }
 
-  function checkEnumType(enumNode) {
+  function checkEnumType( enumNode ) {
     // Either the type is an enum or an arrayed enum.  We are only interested in
     // the enum and don't care whether the enum is arrayed.
     enumNode = enumNode.enum ? enumNode : enumNode.items;
@@ -222,7 +230,7 @@ function check( model ) {       // = XSN
    *
    * @param {XSN.Definition} enumNode
    */
-  function checkEnumValue(enumNode) {
+  function checkEnumValue( enumNode ) {
     const type = enumNode.type && enumNode.type._artifact &&
                  enumNode.type._artifact._effectiveType;
     if (!enumNode.enum || !type || !type.builtin)
@@ -293,7 +301,7 @@ function check( model ) {       // = XSN
    *
    * @param {XSN.Artifact} element
    */
-  function checkLocalizedSubElement(element) {
+  function checkLocalizedSubElement( element ) {
     if (element._parent.kind !== 'element')
       return;
 
@@ -310,7 +318,7 @@ function check( model ) {       // = XSN
     return;
 
     // TODO: Recursive check
-    function isTypeLocalized(type) {
+    function isTypeLocalized( type ) {
       return (type && type.localized && type.localized.val);
     }
   }
@@ -321,7 +329,7 @@ function check( model ) {       // = XSN
    *
    * @param {any} element Element to check recursively
    */
-  function checkForUnmanagedAssociations(element, keyObj) {
+  function checkForUnmanagedAssociations( element, keyObj ) {
     if (element.targetAspect) {
       // TODO: bad location / message
       message('composition-as-key', [ keyObj.location, element ], {},
@@ -342,7 +350,7 @@ function check( model ) {       // = XSN
 
   // Check that min and max cardinalities of 'elem' in 'art' have legal values
   // TODO: move to define.js or parsers
-  function checkCardinality(elem) {
+  function checkCardinality( elem ) {
     if (!elem.cardinality)
       return;
 
@@ -352,13 +360,13 @@ function check( model ) {       // = XSN
         const { literal, val, location } = elem.cardinality[prop];
         if (!(literal === 'number' && val > 0 ||
               literal === 'string' && val === '*')) {
-          error('invalid-cardinality', [ location, elem ], { '#': prop, code: val }, {
+          error('invalid-cardinality', [ location, elem ], { '#': prop, code: val, newcode: '*' }, {
             // eslint-disable-next-line max-len
-            std: 'Value $(CODE) is invalid for maximum cardinality, expecting a positive number or ‘*’',
+            std: 'Value $(CODE) is invalid for maximum cardinality, expecting a positive number or $(NEWCODE)',
             // eslint-disable-next-line max-len
-            sourceMax: 'Value $(CODE) is invalid for maximum source cardinality, expecting a positive number or ‘*’',
+            sourceMax: 'Value $(CODE) is invalid for maximum source cardinality, expecting a positive number or $(NEWCODE)',
             // eslint-disable-next-line max-len
-            targetMax: 'Value $(CODE) is invalid for maximum target cardinality, expecting a positive number or ‘*’',
+            targetMax: 'Value $(CODE) is invalid for maximum target cardinality, expecting a positive number or $(NEWCODE)',
           });
         }
       }
@@ -444,7 +452,7 @@ function check( model ) {       // = XSN
 
   // Traverses 'node' recursively and applies 'checkExpression' to all expressions
   // found within paths (e.g. filters, parameters, ...)
-  function checkExpressionsInPaths(node) {
+  function checkExpressionsInPaths( node ) {
     foreachPath(node, (path) => {
       for (const pathStep of path) {
         if (pathStep.where)
@@ -458,7 +466,7 @@ function check( model ) {       // = XSN
     });
   }
 
-  function checkAssociation(elem) {
+  function checkAssociation( elem ) {
     // TODO: yes, a check similar to this could make it into the compiler)
     // when virtual element is part of association
     if (elem.foreignKeys) {
@@ -474,24 +482,30 @@ function check( model ) {       // = XSN
       checkAssociationCondition(elem, elem.on);
   }
 
-  function checkAssociationCondition(elem, onCond) {
+  function checkAssociationCondition( elem, onCond ) {
     if (Array.isArray(onCond)) // condition in brackets results an array
       onCond.forEach(Cond => checkAssociationCondition(elem, Cond));
     else
-      checkAssociationConditionArgs(elem, onCond.args, onCond.op);
+      checkAssociationConditionArgs(elem, onCond.args, getBinaryOp( onCond ));
   }
 
-  function checkAssociationConditionArgs(elem, args, op) {
+  function getBinaryOp( cond ) {
+    const { op, args } = cond;
+    return op?.val === 'ixpr' && args.length === 3 && args[1].literal === 'token' &&
+      args[1] || op;
+  }
+
+  function checkAssociationConditionArgs( elem, args, op ) {
     if (args)
       args.forEach(Arg => checkAssociationOnCondArg(elem, Arg, op));
   }
 
-  function checkAssociationOnCondArg(elem, arg, op) {
+  function checkAssociationOnCondArg( elem, arg, op ) {
     if (Array.isArray(arg)) {
-      arg.forEach(Arg => checkAssociationOnCondArg(elem, Arg, op));
+      arg.forEach(Arg => checkAssociationCondition(elem, Arg));
     }
     else {
-      checkAssociationConditionArgs(elem, arg.args, arg.op);
+      checkAssociationCondition(elem, arg);
       singleCheckUnmanagedAssocCondArgumentNoFollowUnmanagedAssoc(elem, arg, op);
     }
   }
@@ -503,7 +517,7 @@ function check( model ) {       // = XSN
   // integration into name resolution - did the first step.
   // It is also incomplete, as associations in structures are not checked.
   // Additionally, `$self.assoc` references are also not found.
-  function singleCheckUnmanagedAssocCondArgumentNoFollowUnmanagedAssoc(elem, arg, op) {
+  function singleCheckUnmanagedAssocCondArgumentNoFollowUnmanagedAssoc( elem, arg, op ) {
     if (!arg.path)
       return;
     const path0 = arg.path[0];
@@ -530,7 +544,7 @@ function check( model ) {       // = XSN
   }
 
   function checkAssociationArgumentStartingWithSelf( op, elem ) {
-    if (op && op.val === 'xpr') // no check for xpr
+    if (op?.val === 'xpr') // no check for xpr, would require re-structuring
       return;
     if (op && op.val !== '=')
       error(null, [ op.location, elem ], {}, '$self comparison is only allowed with \'=\'');
@@ -545,7 +559,7 @@ function check( model ) {       // = XSN
    *
    * @param {XSN.Artifact} artifact
    */
-  function checkTypeStructure(artifact) {
+  function checkTypeStructure( artifact ) {
     // Just a basic check. We do not check that the inner structure of `items`
     // is the same as the type but only that all are arrayed or structured.
     if (artifact.type && artifact.type._artifact) {
@@ -575,10 +589,10 @@ function check( model ) {       // = XSN
    * @param {Boolean} allowAssocTail
    * @returns {void}
    */
-  function checkExpression(xpr, allowAssocTail = false) {
+  function checkExpression( xpr, allowAssocTail = false ) {
     // Since the checks for tree-like and token-stream expressions differ,
     // check here what kind of expression we are looking at
-    if (xpr.op && xpr.op.val === 'xpr')
+    if (xpr.op?.val === 'xpr')
       return checkTokenStreamExpression(xpr, allowAssocTail);
     return checkTreeLikeExpression(xpr, allowAssocTail);
   }
@@ -590,7 +604,7 @@ function check( model ) {       // = XSN
    * @param {any} arg Argument to check (part of an expression)
    * @returns {Boolean}
    */
-  function isVirtualElement(arg) {
+  function isVirtualElement( arg ) {
     return arg.path &&
       arg._artifact && arg._artifact.virtual && arg._artifact.virtual.val === true &&
       arg._artifact.kind && arg._artifact.kind === 'element';
@@ -602,7 +616,7 @@ function check( model ) {       // = XSN
    * @param {any} xpr The expression to check
    * @returns {void}
    */
-  function checkTokenStreamExpression(xpr, allowAssocTail) {
+  function checkTokenStreamExpression( xpr, allowAssocTail ) {
     const args = Array.isArray(xpr.args) ? xpr.args : Object.values(xpr.args || {});
     // Check for illegal argument usage within the expression
     for (const arg of args) {
@@ -621,7 +635,7 @@ function check( model ) {       // = XSN
    * @param {any} xpr The expression to check
    * @returns {void}
    */
-  function checkTreeLikeExpression(xpr, allowAssocTail) {
+  function checkTreeLikeExpression( xpr, allowAssocTail ) {
     // No further checks regarding associations and $self required if this is a
     // backlink-like expression (a comparison of $self with an assoc)
     if (isBinaryDollarSelfComparisonWithAssoc(xpr))
@@ -655,7 +669,7 @@ function check( model ) {       // = XSN
     }
   }
   // Return true if 'arg' is an expression argument of type association or composition
-  function isAssociationOperand(arg) {
+  function isAssociationOperand( arg ) {
     if (!arg.path) {
       // Not a path, hence not an association (literal, expression, function, whatever ...)
       return false;
@@ -666,7 +680,7 @@ function check( model ) {       // = XSN
   }
 
   // Return true if 'arg' is an expression argument denoting "$self" || "$projection"
-  function isDollarSelfOrProjectionOperand(arg) {
+  function isDollarSelfOrProjectionOperand( arg ) {
     return arg.path && arg.path.length === 1 &&
       (arg.path[0].id === '$self' || arg.path[0].id === '$projection');
   }
@@ -677,7 +691,7 @@ function check( model ) {       // = XSN
    * @param {any} xpr The expression to check
    * @returns {Boolean}
    */
-  function isBinaryDollarSelfComparisonWithAssoc(xpr) {
+  function isBinaryDollarSelfComparisonWithAssoc( xpr ) {
     // Must be an expression with arguments
     if (!xpr.op || !xpr.args)
       return false;
@@ -735,7 +749,7 @@ function check( model ) {       // = XSN
   // Perform checks for annotation assignment 'anno', using corresponding annotation declaration,
   // made of 'annoDecl' (artifact or undefined) and 'elementDecl' (annotation or element
   // or undefined). Report errors on 'options.messages.
-  function checkAnnotationAssignment(anno, annoDecl, elementDecl, art) {
+  function checkAnnotationAssignment( anno, annoDecl, elementDecl, art ) {
     // Nothing to check if no actual annotation declaration was found
     if (!annoDecl || annoDecl.artifacts && !elementDecl)
       return;
@@ -779,7 +793,7 @@ function check( model ) {       // = XSN
   // Check that annotation assignment 'value' (having 'path or 'literal' and
   // 'val') is potentially assignable to element 'element'. Complain on 'loc'
   // if not
-  function checkValueAssignableTo(value, elementDecl, art) {
+  function checkValueAssignableTo( value, elementDecl, art ) {
     // FIXME: We currently do not have any element declaration that could match
     // a 'path' value, so we simply leave those alone
     if (value.path)
@@ -840,7 +854,7 @@ function check( model ) {       // = XSN
     else if (builtins.isRelationTypeName(type) || builtins.isGeoTypeName(type)) {
       warning(null, loc, { type }, 'Type $(TYPE) can\'t be assigned a value');
     }
-    else {
+    else if (!elementDecl._effectiveType.enum) {
       throw new CompilerAssertion(`Unknown primitive type name: ${ type }`);
     }
 
@@ -861,13 +875,23 @@ function check( model ) {       // = XSN
     }
     else if (expectedEnum) {
       // Enum symbol not provided but expected
-      if (!Object.keys(expectedEnum).some(symbol => expectedEnum[symbol].value.val === value.val)) {
+      const hasValidValue = Object.keys(expectedEnum)
+        .some(symbol => getEnumValue(expectedEnum[symbol]) === value.val);
+      if (!hasValidValue) {
         // ... and none of the valid enum symbols matches the value
         warning(null, loc, {}, 'An enum value is required here');
       }
     }
   }
 
+  function getEnumValue( enumSymbol ) {
+    if (enumSymbol.value)
+      return enumSymbol.value?.val;
+    if (enumSymbol._effectiveType)
+      return enumSymbol._effectiveType?.value?.val;
+    return null;
+  }
+
   // TODO: remove the following
 
   // Return the artifact (and possibly, its element) found by following 'path'
@@ -877,7 +901,7 @@ function check( model ) {       // = XSN
   // represented by the full path (or 'undefined' if not found).  Note that
   // only elements and artifacts are considered for path traversal (no actions,
   // functions, parameters etc.)
-  function resolvePathFrom(path, from, result = {}) {
+  function resolvePathFrom( path, from, result = {} ) {
     // Keep last encountered artifacts
     if (from && !from._main)
       result.artifact = from;
@@ -896,11 +920,64 @@ function check( model ) {       // = XSN
 
   // Return the absolute name of the final type of 'node'. May return 'undefined' for
   // anonymous types
-  function getFinalTypeNameOf(node) {
+  function getFinalTypeNameOf( node ) {
     let type = node._effectiveType;
     if (type.type)
       type = type.type._artifact;
-    return type && type.name && type.name.absolute;
+    return type?.name?.absolute;
+  }
+}
+
+/**
+ * Ensure that the sap.common.[Fiori]TextsAspect has proper types for
+ * e.g. `locale` and `ID_texts`.
+ *
+ * @param {XSN.Model} model
+ */
+function checkSapCommonTextsAspects( model ) {
+  checkSapCommonTextsAspectLocale( model, 'sap.common.TextsAspect' );
+  checkSapCommonTextsAspectLocale( model, 'sap.common.FioriTextsAspect' );
+
+  // Check ID_texts: Fiori requires it to be UUID.
+  const fioriTextsAspect = model.definitions['sap.common.FioriTextsAspect'];
+  const id = fioriTextsAspect?.elements?.ID_texts;
+  if (id) {
+    const idType = id._effectiveType;
+    if (!idType || idType.name?.absolute !== 'cds.UUID') {
+      const { error } = model.$messageFunctions;
+      error('def-invalid-element-type', [ id.type.location, id ], {
+        '#': 'std',
+        art: 'sap.common.FioriTextsAspect',
+        elemref: 'ID_texts',
+        type: 'cds.UUID',
+      });
+    }
+  }
+}
+
+/**
+ * Ensure that the `locale` element of sap.common.[Fiori]TextsAspects
+ * is a string type.  This is required by CAP runtimes to work properly.
+ *
+ * @param {XSN.Model} model
+ * @param {string} name Either sap.common.TextsAspects or sap.common.FioriTextsAspects
+ */
+function checkSapCommonTextsAspectLocale( model, name ) {
+  const locale = model.definitions[name]?.elements?.locale;
+  if (locale) {
+    // `locale` could also be `sap.common.Locale`, which must also be a string.
+    const type = locale._effectiveType;
+    if (type?.name?.absolute !== 'cds.String') {
+      const hasCommonLocale = !!model.definitions['sap.common.Locale'];
+      const { error } = model.$messageFunctions;
+      error('def-invalid-element-type', [ locale.type.location, locale ], {
+        '#': hasCommonLocale ? 'texts-aspect-locale' : 'std',
+        art: name,
+        elemref: 'locale',
+        type: 'cds.String',
+        othertype: 'sap.common.Locale',
+      });
+    }
   }
 }
 
@@ -909,15 +986,13 @@ function check( model ) {       // = XSN
  * be lifted later on.
  *
  * @param {XSN.Model} model
- * @param {object} messageFunctions
  */
-function checkSapCommonLocale( model, messageFunctions ) {
+function checkSapCommonLocale( model ) {
   const localeArt = model.definitions['sap.common.Locale'];
   if (localeArt) {
     const type = localeArt._effectiveType;
-    const isCdsString = type && type.name && type.name.absolute === 'cds.String';
-    if (!isCdsString) {
-      const { message } = messageFunctions;
+    if (type?.name?.absolute !== 'cds.String') {
+      const { message } = model.$messageFunctions;
       message('type-expected-builtin', [ localeArt.name.location, localeArt ],
               { name: 'sap.common.Locale' },
               'Expected $(NAME) to be a string type');
@@ -928,7 +1003,7 @@ function checkSapCommonLocale( model, messageFunctions ) {
 // For each property named 'path' in 'node' (recursively), call callback(path, node)
 //
 // TODO: remove - this is not a good way to traverse expressions
-function foreachPath(node, callback) {
+function foreachPath( node, callback ) {
   if (node === null || typeof node !== 'object') {
     // Primitive node
     return;

package/lib/compiler/define.js

@@ -132,6 +132,7 @@ const {
   pathName,
   splitIntoPath,
   annotationHasEllipsis,
+  isDirectComposition,
 } = require('./utils');
 const { compareLayer } = require('./moduleLayers');
 const { initBuiltins, isInReservedNamespace } = require('./builtins');
@@ -672,14 +673,17 @@ function define( model ) {
         setLink( col, '_block', parent._block );
         initAnnotations( col, parent._block );
         if (col.inline) { // `@anno elem.{ * }` does not work
-          if (col.doc)
-            warning( 'syntax-ignoring-anno', [ col.doc.location, col ], { '#': 'doc' } );
-
+          if (col.doc) {
+            warning( 'syntax-ignoring-anno', [ col.doc.location, col ],
+                     { '#': 'doc', code: '.{ ‹inline› }' } );
+          }
           // col.$annotations no available for CSN input, have to search.
           // Warning about first annotation should be enough to avoid spam.
           const firstAnno = Object.keys(col).find(key => key.startsWith('@'));
-          if (firstAnno)
-            warning( 'syntax-ignoring-anno', [ col[firstAnno].name.location, col ] );
+          if (firstAnno) {
+            warning( 'syntax-ignoring-anno', [ col[firstAnno].name.location, col ],
+                     { code: '.{ ‹inline› }' } );
+          }
         }
         // TODO: allow sub queries? at least in top-level expand without parallel ref
         if (columns)
@@ -738,7 +742,7 @@ function define( model ) {
    *
    * @param {object} exprOrPathElement starts w/ an expr but then subelem from .path or .where.args
    */
-  function approveExistsInChildren(exprOrPathElement) {
+  function approveExistsInChildren( exprOrPathElement ) {
     if (!exprOrPathElement) // may be null in case of parse error
       return;
     if (exprOrPathElement.$expected === 'exists')
@@ -834,7 +838,7 @@ function define( model ) {
         dictAddArray( p.$tableAliases, table.name.id, table );
       }
       if (table.name.id[0] === '$') {
-        warning( 'syntax-dollar-ident', [ table.name.location, table ], {
+        warning( 'name-invalid-dollar-alias', [ table.name.location, table ], {
           '#': (table.name.$inferred ? '$tableImplicit' : '$tableAlias'),
           name: '$',
           keyword: 'as',
@@ -921,7 +925,7 @@ function define( model ) {
             error( 'duplicate-definition', [ loc, query ], { name: dupName, '#': 'alias' } );
           } );
           if (mixin.name.id[0] === '$') {
-            warning( 'syntax-dollar-ident', [ mixin.name.location, mixin ],
+            warning( 'name-invalid-dollar-alias', [ mixin.name.location, mixin ],
                      { '#': 'mixin', name: '$' } );
           }
         }
@@ -929,11 +933,6 @@ function define( model ) {
     }
   }
 
-  function isDirectComposition( art ) {
-    const type = art.type && art.type.path;
-    return type && type[0] && type[0].id === 'cds.Composition';
-  }
-
   // Return whether the `target` is actually a `targetAspect`
   // TODO: really do that here and not in kick-start.js?
   function targetIsTargetAspect( elem ) {