@sap/cds-compiler 3.4.0 → 3.4.4

package/lib/compiler/checks.js

@@ -23,9 +23,10 @@ const { pathName } = require('./utils');
 
 function check( model ) {       // = XSN
   const {
-    error, warning, message,
+    error, warning, message, info,
   } = model.$messageFunctions;
   forEachDefinition( model, checkArtifact );
+  forEachGeneric( model, 'vocabularies', checkAnnotationDefinition );
   checkSapCommonLocale( model, model.$messageFunctions );
   return;
 
@@ -36,6 +37,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 +86,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 +158,7 @@ function check( model ) {       // = XSN
    *
    * @param {XSN.Artifact} enumNode
    */
-  function checkEnum(enumNode) {
+  function checkEnum( enumNode ) {
     if (!enumNode.value)
       return;
 
@@ -167,7 +174,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 +229,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 +300,7 @@ function check( model ) {       // = XSN
    *
    * @param {XSN.Artifact} element
    */
-  function checkLocalizedSubElement(element) {
+  function checkLocalizedSubElement( element ) {
     if (element._parent.kind !== 'element')
       return;
 
@@ -310,7 +317,7 @@ function check( model ) {       // = XSN
     return;
 
     // TODO: Recursive check
-    function isTypeLocalized(type) {
+    function isTypeLocalized( type ) {
       return (type && type.localized && type.localized.val);
     }
   }
@@ -321,7 +328,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 +349,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;
 
@@ -444,7 +451,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 +465,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,19 +481,19 @@ 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);
   }
 
-  function checkAssociationConditionArgs(elem, args, 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));
     }
@@ -503,7 +510,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];
@@ -545,7 +552,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,7 +582,7 @@ 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')
@@ -590,7 +597,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 +609,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 +628,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 +662,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 +673,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 +684,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 +742,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 +786,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 +847,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 +868,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 +894,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 +913,11 @@ 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;
   }
 }
 
@@ -928,7 +945,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

@@ -672,14 +672,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 +741,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')

package/lib/compiler/extend.js

@@ -53,10 +53,8 @@ function extend( model ) {
 
   applyExtensions();
 
-  const commonLanguagesEntity = options.addTextsLanguageAssoc &&
-    model.definitions['sap.common.Languages'];
-  const addTextsLanguageAssoc = !!(commonLanguagesEntity && commonLanguagesEntity.elements &&
-                                   commonLanguagesEntity.elements.code);
+  const addTextsLanguageAssoc = checkTextsLanguageAssocOption(model, options);
+
   Object.keys( model.definitions ).forEach( processArtifact );
 
   lateExtensions( false );
@@ -107,7 +105,7 @@ function extend( model ) {
     const processed = new WeakSet();
     forEachDefinition(model, processCompositionPersistence);
 
-    function processCompositionPersistence(def) {
+    function processCompositionPersistence( def ) {
       if (def.$inferred === 'composition-entity' && !processed.has(def)) {
         if (def._parent)
           processCompositionPersistence(def._parent);
@@ -207,7 +205,7 @@ function extend( model ) {
    * @param {XSN.Definition} art
    * @param {boolean|'gen'} [noIncludes=false]
    */
-  function extendArtifact( extensions, art, noIncludes = false) {
+  function extendArtifact( extensions, art, noIncludes = false ) {
     if (!noIncludes && !(canApplyIncludes( art, art ) &&
         extensions.every( ext => canApplyIncludes(ext, art) )))
       return false;
@@ -332,7 +330,7 @@ function extend( model ) {
    *
    * @param art
    */
-  function applyTypeExtensions(art) {
+  function applyTypeExtensions( art ) {
     /**
      * Contains the previous extension for each property that was applied
      * successfully.
@@ -620,15 +618,17 @@ function extend( model ) {
       return;
     }
 
-    if (!art._ancestors)
-      setLink( art, '_ancestors', [] ); // recursive array of includes
-    for (const ref of ext.includes) {
-      const template = ref._artifact;
-      // !template -> non-includable, e.g. scalar type, or cyclic
-      if (template) {
-        if (template._ancestors)
-          art._ancestors.push( ...template._ancestors );
-        art._ancestors.push( template );
+    if (!art.query) {
+      if (!art._ancestors)
+        setLink( art, '_ancestors', [] ); // recursive array of includes
+      for (const ref of ext.includes) {
+        const template = ref._artifact;
+        // !template -> non-includable, e.g. scalar type, or cyclic
+        if (template) {
+          if (template._ancestors)
+            art._ancestors.push( ...template._ancestors );
+          art._ancestors.push( template );
+        }
       }
     }
     includeMembers( ext, art, 'elements' );
@@ -740,7 +740,7 @@ function extend( model ) {
 
       if (isKey && isLocalized) { // key with localized is wrong - ignore localized
         const errpos = elem.localized || elem.type || elem.name;
-        warning( 'localized-key', [ errpos.location, elem ], { keyword: 'localized' },
+        warning( 'def-ignoring-localized-key', [ errpos.location, elem ], { keyword: 'localized' },
                  'Keyword $(KEYWORD) is ignored for primary keys' );
       }
     }
@@ -748,7 +748,7 @@ function extend( model ) {
       return false;
 
     if (!keys) {
-      warning( null, [ art.name.location, art ], {},
+      warning( 'def-expecting-key', [ art.name.location, art ], {},
                'No texts entity can be created when no key element exists' );
       return false;
     }
@@ -798,6 +798,48 @@ function extend( model ) {
    * @param {boolean} fioriEnabled
    */
   function createTextsEntity( base, absolute, textElems, fioriEnabled ) {
+    const art = createTextsEntityWithDefaultElements( base, absolute, textElems, fioriEnabled );
+
+    const { location } = base.name;
+    const { locale } = art.elements;
+
+    // assertUnique array value, first entry is 'locale'
+    const assertUniqueValue = [ {
+      path: [ { id: locale.name.id, location: locale.location } ],
+      location: locale.location,
+    } ];
+
+    for (const orig of textElems) {
+      const elem = linkToOrigin( orig, orig.name.id, art, 'elements' );
+      if (orig.key && orig.key.val) {
+        // elem.key = { val: fioriEnabled ? null : true, $inferred: 'localized', location };
+        // TODO: the previous would be better, but currently not supported in toCDL
+        if (!fioriEnabled) {
+          elem.key = { val: true, $inferred: 'localized', location };
+          // If the propagated elements remain key (that is not fiori.draft.enabled)
+          // they should be omitted from OData containment EDM
+          annotateWith( elem, '@odata.containment.ignore', location );
+        }
+        else {
+          // add the former key paths to the unique constraint
+          assertUniqueValue.push({
+            path: [ { id: orig.name.id, location: orig.location } ],
+            location: orig.location,
+          });
+        }
+      }
+      if (hasTruthyProp( orig, 'localized' )) { // use location of LOCALIZED keyword
+        const localized = orig.localized || orig.type || orig.name;
+        elem.localized = { val: null, $inferred: 'localized', location: localized.location };
+      }
+    }
+    if (fioriEnabled)
+      annotateWith( art, '@assert.unique.locale', art.location, assertUniqueValue, 'array' );
+
+    return art;
+  }
+
+  function createTextsEntityWithDefaultElements( base, absolute, textElems, fioriEnabled ) {
     const elements = Object.create(null);
     const { location } = base.name;
     const art = {
@@ -809,8 +851,7 @@ function extend( model ) {
     };
     // If there is a type `sap.common.Locale`, then use it as the type for the element `locale`.
     // If not, use the default `cds.String` with a length of 14.
-    const hasLocaleType = model.definitions['sap.common.Locale'] &&
-      model.definitions['sap.common.Locale'].kind === 'type';
+    const hasLocaleType = model.definitions['sap.common.Locale']?.kind === 'type';
     const locale = {
       name: { location, id: 'locale' },
       kind: 'element',
@@ -861,39 +902,6 @@ function extend( model ) {
     model.definitions[absolute] = art;
     initArtifact( art );
 
-    // assertUnique array value, first entry is 'locale'
-    const assertUniqueValue = [ {
-      path: [ { id: locale.name.id, location: locale.location } ],
-      location: locale.location,
-    } ];
-
-    for (const orig of textElems) {
-      const elem = linkToOrigin( orig, orig.name.id, art, 'elements' );
-      if (orig.key && orig.key.val) {
-        // elem.key = { val: fioriEnabled ? null : true, $inferred: 'localized', location };
-        // TODO: the previous would be better, but currently not supported in toCDL
-        if (!fioriEnabled) {
-          elem.key = { val: true, $inferred: 'localized', location };
-          // If the propagated elements remain key (that is not fiori.draft.enabled)
-          // they should be omitted from OData containment EDM
-          annotateWith( elem, '@odata.containment.ignore', location );
-        }
-        else {
-          // add the former key paths to the unique constraint
-          assertUniqueValue.push({
-            path: [ { id: orig.name.id, location: orig.location } ],
-            location: orig.location,
-          });
-        }
-      }
-      if (hasTruthyProp( orig, 'localized' )) { // use location of LOCALIZED keyword
-        const localized = orig.localized || orig.type || orig.name;
-        elem.localized = { val: null, $inferred: 'localized', location: localized.location };
-      }
-    }
-    if (fioriEnabled)
-      annotateWith( art, '@assert.unique.locale', art.location, assertUniqueValue, 'array' );
-
     return art;
   }
 
@@ -1266,7 +1274,7 @@ function compareAssignments( a, b ) {
  * @param {object} source
  * @param {CSN.Options} options
  */
-function copyPersistenceAnnotations(target, source, options) {
+function copyPersistenceAnnotations( target, source, options ) {
   if (!source)
     return;
 
@@ -1275,7 +1283,7 @@ function copyPersistenceAnnotations(target, source, options) {
     copy( '@cds.persistence.exists' );
   copy( '@cds.persistence.skip' );
 
-  function copy(anno) {
+  function copy( anno ) {
     if ( source[anno] && !target[anno] )
       target[anno] = { ...source[anno], $inferred: 'parent-origin' };
   }
@@ -1323,4 +1331,24 @@ function storeTypeExtension( ext, art ) {
   art._extendType.push( ext );
 }
 
+
+function checkTextsLanguageAssocOption( model, options ) {
+  const languages = model.definitions['sap.common.Languages'];
+  const commonLanguagesEntity = options.addTextsLanguageAssoc && languages?.elements?.code;
+
+  if (options.addTextsLanguageAssoc && !commonLanguagesEntity) {
+    const variant = !languages ? 'std' : 'code';
+    const loc = model.definitions['sap.common.Languages']?.name?.location || null;
+    model.$messageFunctions.info('api-ignoring-language-assoc', loc, {
+      '#': variant, option: 'addTextsLanguageAssoc', art: 'sap.common.Languages', name: 'code',
+    }, {
+      std: 'Ignoring option $(OPTION) because entity $(ART) is missing',
+      code: 'Ignoring option $(OPTION) because entity $(ART) is missing element $(NAME)',
+    });
+  }
+
+  return !!commonLanguagesEntity;
+}
+
+
 module.exports = extend;

package/lib/compiler/finalize-parse-cdl.js

@@ -67,7 +67,7 @@ function finalizeParseCdl( model ) {
    * @param {*} artifact
    * @param {XSN.Artifact} main
    */
-  function resolveTypesForParseCdl(artifact, main) {
+  function resolveTypesForParseCdl( artifact, main ) {
     if (!artifact || typeof artifact !== 'object')
       return;
 
@@ -160,7 +160,7 @@ function finalizeParseCdl( model ) {
    * @param {object} artWithType
    * @param {XSN.Artifact} user
    */
-  function resolveTypeUnchecked(artWithType, user) {
+  function resolveTypeUnchecked( artWithType, user ) {
     const root = artWithType.type.path && artWithType.type.path[0];
     if (!root) // parse error
       return;
@@ -202,7 +202,7 @@ function finalizeParseCdl( model ) {
     }
   }
 
-  function chooseAndReportDuplicateAnnotation(artifact, annoName) {
+  function chooseAndReportDuplicateAnnotation( artifact, annoName ) {
     for (const anno of artifact[annoName])
       message( 'anno-duplicate', [ anno.name.location, artifact ], { anno: annoName } );
 

package/lib/compiler/populate.js

@@ -45,6 +45,7 @@ const {
   dependsOn,
   traverseQueryPost,
   setExpandStatus,
+  setExpandStatusAnnotate,
 } = require('./utils');
 
 const $inferred = Symbol.for('cds.$inferred');
@@ -163,7 +164,6 @@ function populate( model ) {
     const chain = [];
     while (art && !('_effectiveType' in art) &&
            (art.type || art._origin || art.value?.path || art.value?.type) &&
-           // TODO: really stop at art.enum? See #8942
            !art.target && !art.enum && !art.elements && !art.items) {
       chain.push( art );
       setLink( art, '_effectiveType', 0 ); // initial setting in case of cycles
@@ -192,7 +192,6 @@ function populate( model ) {
       // collect the "latest" cardinality (calculate lazily if necessary)
       let cardinality = art.cardinality ||
           art._effectiveType && (() => getCardinality( art._effectiveType ));
-      let prev = art;
       for (const a of chain) {
         if (a.cardinality)
           cardinality = a.cardinality;
@@ -201,8 +200,10 @@ function populate( model ) {
             art.elements && expandElements( a, art ) ||
             art.items && expandItems( a, art ))
           art = a;
-        else if (art.enum && expandEnum( a, prev ))
-          prev = a;             // do not set art - effective type is base
+
+        else if (art.enum && expandEnum( a, art ))
+          art = a;
+
         setLink( a, '_effectiveType', art );
       }
     }
@@ -469,11 +470,21 @@ function populate( model ) {
               'Element $(ID) is missing in specified elements' );
       }
       else {
+        let wasAnnotated = false;
         for (const prop in selem) {
           // just annotation assignments and doc comments for the moment
-          if (prop.charAt(0) === '@' || prop === 'doc')
+          if (prop.charAt(0) === '@' || prop === 'doc') {
             ielem[prop] = selem[prop];
+            // required for gensrc mode of to-csn.js, otherwise the annotation
+            // may be lost during recompilation.
+            ielem[prop].$priority = 'annotate';
+            wasAnnotated = true;
+          }
         }
+
+        if (wasAnnotated)
+          setExpandStatusAnnotate(art, 'annotate');
+
         selem.$replacement = true;
         if (selem.elements) {
           setLink(ielem, 'elements$', selem.elements);