@sap/cds-compiler 6.6.2 → 6.7.1

package/lib/compiler/generate.js

@@ -2,10 +2,9 @@
 
 'use strict';
 
-const {
-  isDeprecatedEnabled,
-  forEachGeneric, forEachDefinition,
-} = require('../base/model');
+/* eslint-disable no-nested-ternary */
+
+const { isDeprecatedEnabled } = require('../base/model');
 const { dictAdd } = require('../base/dictionaries');
 const {
   setLink,
@@ -17,6 +16,7 @@ const {
   augmentPath,
   isDirectComposition,
   copyExpr,
+  forEachGeneric,
 } = require('./utils');
 const { weakLocation, weakRefLocation, weakEndLocation } = require('../base/location');
 
@@ -28,6 +28,7 @@ function generate( model ) {
   const {
     error, warning, info,
   } = model.$messageFunctions;
+  const Functions = model.$functions;
   const {
     resolvePath,
     resolveUncheckedPath,
@@ -35,14 +36,17 @@ function generate( model ) {
     extendArtifactBefore,
     applyIncludes,
   } = model.$functions;
-  model.$functions.hasTruthyProp = hasTruthyProp;
-
-  const addTextsLanguageAssoc = checkTextsLanguageAssocOption( model, options );
-  const useTextsAspect = checkTextsAspect();
-
-  Object.keys( model.definitions ).forEach( processArtifact );
-
-  compositionChildPersistence();
+  Object.assign( model.$functions, {
+    hasTruthyProp,
+    generateForEntity,
+    populateGeneratedEntity,
+    checkGenerateConditions,
+  } );
+
+  const commonLanguages = model.definitions['sap.common.Languages'];
+  const textsAspect = model.definitions['sap.common.TextsAspect'];
+  let enableLanguageAssoc = null; // → addLanguageAssoc()
+  let enableTextsAspect = null;   // → useTextsAspect()
   return;
 
   /**
@@ -50,33 +54,45 @@ function generate( model ) {
    *
    * @param {string} name
    */
-  function processArtifact( name ) {
-    const art = model.definitions[name];
-    if (!(art.$duplicates)) {
+  function generateForEntity( art ) {
+    // TODO: write dependency on base entity for final generateForEntity()
+    if (!art.$duplicates && art.elements) {
       processAspectComposition( art );
-      if (art.kind === 'entity' && !art.query && art.elements)
-        // check potential entity parse error
-        processLocalizedData( art );
+      processLocalizedData( art );
     }
   }
 
-  /**
-   * Copy `@cds.persistence.skip` and `@cds.persistence.skip` from parent to child
-   * for managed compositions.  This needs to be done after extensions, i.e. annotations,
-   * have been applied or `annotate E.comp` would not have an effect on `E.comp.subComp`.
-   */
-  function compositionChildPersistence() {
-    const processed = new WeakSet();
-    forEachDefinition( model, processCompositionPersistence );
-
-    function processCompositionPersistence( def ) {
-      if (def.$inferred === 'composition-entity' && !processed.has( def )) {
-        if (def._parent)
-          processCompositionPersistence( def._parent );
-        copyPersistenceAnnotations( def, def._parent );
-        processed.add( def );
-      }
+  function addLanguageAssoc( report = false ) {
+    if (!options.addTextsLanguageAssoc)
+      return false;
+    if (!report && enableLanguageAssoc != null)
+      return enableLanguageAssoc;
+
+    const codeElement = Functions.effectiveType( commonLanguages )?.elements?.code;
+    // eslint-disable no-nested-ternary
+    const err = (!commonLanguages || commonLanguages.$inferred )
+      ? 'missing'
+      : (commonLanguages.kind !== 'entity' || commonLanguages.query)
+        ? 'kind'
+        : (!codeElement || codeElement.$inferred)
+          ? 'code'
+          : null;               // TODO: better config of eslint @stylistic/indent
+    if (report && err) {
+      const loc = commonLanguages?.name?.location || null;
+      warning( 'api-ignoring-language-assoc', [ loc, commonLanguages ], {
+        '#': err,
+        option: 'addTextsLanguageAssoc',
+        art: 'sap.common.Languages',
+        name: 'code',
+      }, {
+        std: 'Ignoring option $(OPTION)',
+        missing: 'Ignoring option $(OPTION) because entity $(ART) is missing',
+        kind: 'Ignoring option $(OPTION) because entity $(ART) is no entity',
+        code: 'Ignoring option $(OPTION) because entity $(ART) is missing direct element $(NAME)',
+      } );
     }
+    enableLanguageAssoc = (err == null);
+    return enableLanguageAssoc;
   }
 
   /**
@@ -86,56 +102,46 @@ function generate( model ) {
    *
    * @return {boolean}
    */
-  function checkTextsAspect() {
-    const textsAspect = model.definitions['sap.common.TextsAspect'];
-    if (!textsAspect)
-      return false;
-
-    const specialElements = { locale: { key: true } };
+  function useTextsAspect( report = false ) {
+    if (!report && enableTextsAspect != null)
+      return enableTextsAspect;
+
+    const locale = Functions.effectiveType( textsAspect )?.elements?.locale;
+    const err = (!textsAspect || textsAspect.$inferred )
+      ? false
+      : (textsAspect.kind !== 'aspect' || !textsAspect.elements)
+        ? 'no-aspect'
+        : (!locale || locale.$inferred)
+          ? 'missing'
+          : (locale.key?.val ? null : 'key');  // TODO: better eslint @stylistic/indent
+    if (report && err) {
+      const loc = (err === 'key' ? locale : textsAspect)?.name?.location || null;
+      error( 'def-invalid-texts-aspect', [ loc, (err === 'key' ? locale : textsAspect) ],
+             { '#': err, art: textsAspect, name: 'locale' } );
+    }
+    enableTextsAspect = (err == null);
+    return enableTextsAspect;
+  }
 
-    if (textsAspect.kind !== 'aspect' || !textsAspect.elements) {
-      error( 'def-invalid-texts-aspect', [ textsAspect.name.location, textsAspect ],
-             { '#': 'no-aspect', art: textsAspect } );
-      return false;
-    }
+  function checkGenerateConditions() {
+    addLanguageAssoc( true );
+    if (!useTextsAspect( true ))
+      return;
 
-    let hasError = false;
-    if (addTextsLanguageAssoc && textsAspect.elements.language) {
+    if (enableLanguageAssoc && textsAspect.elements.language) {
       const lang = textsAspect.elements.language;
       error( 'def-unexpected-element', [ lang.name.location, lang ],
              { option: 'addTextsLanguageAssoc', art: textsAspect, name: 'language' },
-        // eslint-disable-next-line @stylistic/max-len
-             '$(ART) is not used because option $(OPTION) conflicts with existing element $(NAME); remove either option or element' );
-      hasError = true;
+             'Element $(NAME) of $(ART) is not used because option $(OPTION) is set' );
     }
 
-    for (const name in specialElements) {
-      const expected = specialElements[name];
-      const elem = textsAspect.elements[name];
-      if (!elem) {
-        error( 'def-invalid-texts-aspect', [ textsAspect.name.location, textsAspect ],
-               { '#': 'missing', art: textsAspect, name } );
-        hasError = true;
-      }
-      else if (expected.key !== undefined && !!elem.key?.val !== expected.key) {
-        const loc = elem.key?.location || elem.name?.location || textsAspect.name.location;
-        error( 'def-invalid-texts-aspect', [ loc, elem ],
-               { '#': expected.key ? 'key' : 'no-key', art: elem } );
-        hasError = true;
-      }
-    }
-
-    if (hasError) // avoid subsequent errors, if the special elements are already wrong
-      return false;
-
     for (const name in textsAspect.elements) {
       const elem = textsAspect.elements[name];
       const include = elem.$inferred === 'include';
-      if (!specialElements[name] && elem.key) {
+      if (elem.key && name !== 'locale') {
         const loc = include ? elem.location : elem.key.location;
         error( 'def-unexpected-key', [ loc, elem ],
                { '#': !include ? 'std' : 'include', art: textsAspect } );
-        hasError = true;
       }
       else if (hasTruthyProp( elem, 'localized' )) {
         // TODO: T:loc, i.e. "localized" from other type (needs resolver?)
@@ -143,17 +149,13 @@ function generate( model ) {
         const loc = elem.localized?.location || elem.location;
         error( 'def-unexpected-localized', [ loc, elem ],
                { '#': !include ? 'elements' : 'include', art: textsAspect } );
-        hasError = true;
       }
       else if (elem.targetAspect) {
         error( 'def-unexpected-composition', [ elem.targetAspect.location, elem ],
                { art: textsAspect },
                '$(ART) can\'t have composition of aspects' );
-        hasError = true;
       }
     }
-
-    return !hasError;
   }
 
   // localized texts entities ---------------------------------------------------
@@ -165,8 +167,13 @@ function generate( model ) {
    * @param {XSN.Artifact} art
    */
   function processLocalizedData( art ) {
+    // do not create texts entity for a texts entity (might be induced by erroneous
+    // sap.common.TextsAspect):
+    if (art.$inferred === 'localized-entity')
+      return;
+    // TODO: test with `annotate … with @fiori.draft.enabled`
     const fioriAnno = art['@fiori.draft.enabled'];
-    const fioriEnabled = fioriAnno && (fioriAnno.val === undefined || fioriAnno.val);
+    const fioriEnabled = fioriAnno && (fioriAnno.val === undefined || !!fioriAnno.val);
 
     const textsName = `${ art.name.id }.texts`;
     const textsEntity = model.definitions[textsName];
@@ -198,7 +205,7 @@ function generate( model ) {
     const protectedElements = [ 'locale', 'texts', 'localized' ];
     if (fioriEnabled)
       protectedElements.push( 'ID_texts' );
-    if (addTextsLanguageAssoc)
+    if (addLanguageAssoc())
       protectedElements.push( 'language' );
 
     for (const name in art.elements) {
@@ -286,19 +293,16 @@ function generate( model ) {
    */
   function createTextsEntity( base, absolute, textElems, fioriEnabled ) {
     const location = weakLocation( base.elements[$location] || base.location );
-    let art = {
+    const art = Functions.registerGeneratedEntity( {
       kind: 'entity',
       name: { id: absolute, location },
       location,
       elements: Object.create( null ),
       $inferred: 'localized-entity',
-    };
-    const gap = model.definitions[absolute];
-    if (gap)
-      art = Object.assign( gap, art );
-    else
-      model.definitions[absolute] = art;
+    } );
     setLink( art, '_block', model.$internal );
+
+    // console.log('Texts:',require('../model/revealInternalProperties').ref(art))
     extendArtifactBefore( art ); // having extensions here would be wrong
 
     if (!fioriEnabled) {
@@ -313,15 +317,22 @@ function generate( model ) {
         type: linkMainArtifact( location, 'cds.UUID' ),
         location,
       };
-      dictAdd( art.elements, 'ID_texts', textId );
+      art.elements.ID_texts = textId;
     }
+    // _service links and "consider as composition target" must be set already here
+    setLink( art, '_service', base._service );
+    model.$compositionTargets[absolute] = true;
+    setGenExtensions( art, { _base: base, _textElems: textElems, fioriEnabled } );
+  }
 
-    const enrich = useTextsAspect
+  function populateTextsEntity( art, base, textElems, fioriEnabled ) {
+    const { location } = art;
+    const enrich = useTextsAspect()
       ? enrichTextsEntityWithInclude
       : enrichTextsEntityWithDefaultElements;
-    enrich( art, base, absolute, fioriEnabled );
+    enrich( art, fioriEnabled );
 
-    if (addTextsLanguageAssoc) {
+    if (addLanguageAssoc()) {
       const language = {
         name: { location, id: 'language' },
         kind: 'element',
@@ -350,12 +361,12 @@ function generate( model ) {
     initMainArtifact( art );
     // do the kick-start relevant stuff: _service, there are no _ancestors,
     // _descendants would have been set already for a gap artifact
-    setLink( art, '_service', art._parent._service );
-    model.$compositionTargets[absolute] = true;
 
-    if (art.includes) {
+    if (art.includes) {   // i.e. sap.common.TextsAspect
+      // do not insert sap.common.TextsAspect elements before `locale`:
       // add elements `locale`, etc. which are required below.
-      applyIncludes( art, art ); // TODO: rethink - can we avoid this if only new extend?
+      art.includes.$original = []; // do not apply via extendArtifactAdd()
+      applyIncludes( art, art );   // apply now
     }
 
     if (fioriEnabled) {
@@ -376,6 +387,7 @@ function generate( model ) {
       setAnnotation( art, '@assert.unique.locale', art.location, assertUniqueValue, 'array' );
     }
 
+    // TODO: first copy persistence annos from cds.TextsAspect ?
     copyPersistenceAnnotations( art, base );
     return art;
   }
@@ -413,13 +425,10 @@ function generate( model ) {
    * Does NOT apply the include!
    *
    * @param {XSN.Artifact} art
-   * @param {XSN.Artifact} base
-   * @param {string} absolute
    * @param {boolean} fioriEnabled
    */
-  function enrichTextsEntityWithInclude( art, base, absolute, fioriEnabled ) {
+  function enrichTextsEntityWithInclude( art, fioriEnabled ) {
     const textsAspectName = 'sap.common.TextsAspect';
-    const textsAspect = model.definitions['sap.common.TextsAspect'];
     const { location } = art;
 
     art.includes = [ createInclude( textsAspectName, location ) ];
@@ -433,18 +442,16 @@ function generate( model ) {
       art.elements.locale.$inferred = 'localized';
     }
 
-    if (addTextsLanguageAssoc && art.elements.language)
+    if (addLanguageAssoc() && art.elements.language)
       art.elements.language = undefined; // TODO: Message? Ignore?
     // TODO: what is this necessary?  We do not create a text entity in this case
   }
 
   /**
    * @param {XSN.Artifact} art
-   * @param {XSN.Artifact} base
-   * @param {string} absolute
    * @param {boolean} fioriEnabled
    */
-  function enrichTextsEntityWithDefaultElements( art, base, absolute, fioriEnabled ) {
+  function enrichTextsEntityWithDefaultElements( art, fioriEnabled ) {
     // 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']?.kind === 'type';
@@ -590,11 +597,15 @@ function generate( model ) {
         return;
       let origin = elem;
       // included element do not have target aspect directly
+      // (remark: this will get far more complex with compositions of aspects
+      // in sub elements)
       while (origin && !origin.targetAspect && origin._origin)
         origin = origin._origin;
       let target = origin.targetAspect;
-      if (target?.path)
+      if (target?.path) {
         target = resolvePath( origin.targetAspect, 'targetAspect', origin );
+        Functions.effectiveType( target ); // should have been good!
+      }
       if (!target || !target.elements)
         return;
       const entityName = `${ base.name.id }.${ elem.name.id }`;
@@ -614,8 +625,6 @@ function generate( model ) {
         if (up_)
           setLink( up_, '_origin', entity.elements.up_ );
         model.$compositionTargets[entity.name.id] = true;
-        processAspectComposition( entity );
-        processLocalizedData( entity );
       }
     }
   }
@@ -637,22 +646,6 @@ function generate( model ) {
              'An aspect $(TARGET) can\'t be used as target in an entity without keys' );
       return false;
     }
-    // if (keys.up_) {  // only to be tested if we allow to provide a prefix, which could be ''
-    //   // Cannot be in an "inner aspect-compositions" as it would already be wrong before
-    //   // TODO: if anonymous type, use location of "up_" element
-    //   // FUTURE: add sub info with location of "up_" element
-    //   message( 'id', [location, elem], { target, name: 'up_' }, 'Error',
-    //      'An aspect $(TARGET) can't be used as target in an entity with a key named $(NAME)' );
-    //   return false;
-    // }
-    if (target.elements.up_) {
-      // TODO: for "inner aspect-compositions", signal already in type
-      // TODO: if anonymous type, use location of "up_" element
-      // FUTURE: if named type, add sub info with location of "up_" element
-      error( null, [ location, elem ], { target, name: 'up_' },
-             'An aspect $(TARGET) with an element named $(NAME) can\'t be used as target' );
-      return false;
-    }
     const place = model.definitions[entityName];
     if (place && place.kind !== 'namespace') {
       error( null, [ location, elem ], { art: entityName },
@@ -660,16 +653,6 @@ function generate( model ) {
              'Target entity $(ART) can\'t be created as there is another definition with this name' );
       return false;
     }
-    const names = Object.keys( target.elements )
-      .filter( n => n.startsWith( 'up__' ) && keyNames.includes( n.substring(4) ) );
-    if (names.length) {
-      // FUTURE: if named type, add sub info with location of "up_" element
-      error( null, [ location, elem ], { target: entityName, names }, {
-        std: 'Key elements $(NAMES) can\'t be added to $(TARGET) as these already exist',
-        one: 'Key element $(NAMES) can\'t be added to $(TARGET) as it already exist',
-      } );
-      return false;
-    }
 
     if (elem.type && !isDirectComposition( elem )) {
       // Only issue warning for direct usages, not for projections, includes, etc.
@@ -689,8 +672,10 @@ function generate( model ) {
   }
 
   function createTargetEntity( target, elem, keys, entityName, base ) {
+    // Remark: keys for v2 option deprecated.unmanagedUpInComponent
     const location = weakRefLocation( elem.targetAspect || elem.target || elem );
-    elem.on = {
+    // Since there is no user-written up_ element, use a weak location to the beginning of {…}.
+    elem.on = {                 // element on base entity
       location,
       op: { val: '=', location },
       args: [
@@ -700,43 +685,14 @@ function generate( model ) {
       $inferred: 'aspect-composition',
     };
 
-    let art = {
-      kind: 'entity',
-      name: {
-        id: entityName,
-        // for code navigation (e.g. via `extend`s): point to the element's name
-        location: weakLocation( elem.name.location ),
-      },
-      location,
-      elements: Object.create( null ),
-      $inferred: 'composition-entity',
-    };
-    const gap = model.definitions[entityName];
-    if (gap)
-      art = Object.assign( gap, art );
-    else
-      model.definitions[entityName] = art;
-
-    if (target.name) {          // named target aspect
-      if (!isDeprecatedEnabled( options, 'noCompositionIncludes' )) {
-        art.includes = [ createInclude( target.name.id, location ) ];
-        propagateEarly( art, '@cds.autoexpose' );
-        propagateEarly( art, '@fiori.draft.enabled' );
-      }
-      setLink( art, '_origin', target );
-      setLink( art, '_upperAspects', [ target, ...(elem._main._upperAspects || []) ] );
-    }
-    else {
-      setLink( art, '_origin', target );
-      // TODO: do we need to give the anonymous target aspect a kind and name?
-      setLink( art, '_upperAspects', elem._main._upperAspects || [] );
-    }
-
-    // Since there is no user-written up_ element, use a weak location to the beginning of {…}.
-    const up = { // elements.up_ = ...
+    const up_ = { // elements.up_ = ...
       name: { location, id: 'up_' },
       kind: 'element',
       location,
+      key: { location, val: true },
+      notNull: { location, val: true },
+      // managed associations must be explicitly set to not null
+      // even if target cardinality is 1..1
       $inferred: 'aspect-composition',
       type: linkMainArtifact( location, 'cds.Association' ),
       target: linkMainArtifact( location, base.name.id ),
@@ -746,40 +702,87 @@ function generate( model ) {
         location,
       },
     };
-
-    up.key = { location, val: true };
-    // managed associations must be explicitly set to not null
-    // even if target cardinality is 1..1
-    up.notNull = { location, val: true };
-
-    dictAdd( art.elements, 'up_', up );
-    // Only for named aspects, use a new location; otherwise use the origin's one.
-
-    // To keep the locations of non-inferred original elements, do not set $inferred:
-    const enforceLocation = target.name || elem.$inferred;
-    addProxyElements( art, target.elements, 'aspect-composition', enforceLocation && location );
-
+    const art = Functions.registerGeneratedEntity( {
+      kind: 'entity',
+      name: {
+        id: entityName,
+        // for code navigation (e.g. via `extend`s): point to the element's name
+        location: weakLocation( elem.name.location ),
+      },
+      location,
+      elements: { __proto__: null, up_ },
+      $inferred: 'composition-entity',
+    } );
+    // console.log('Composition:',require('../model/revealInternalProperties').ref(art))
     setLink( art, '_block', model.$internal );
-    initMainArtifact( art );
 
     // do the kick-start relevant stuff: _service, there are no _ancestors,
     // _descendants would have been set already for a gap artifact
-    setLink( art, '_service', art._parent._service );
+    setLink( art, '_service', base._service );
     model.$compositionTargets[entityName] = true;
 
     // Apply annotations to generated artifact, prepare (not apply!) element
     // annotations (remark: adding elements is not allowed for generated artifacts):
     extendArtifactBefore( art );
-    // Copy persistence annotations from aspect.
-    copyPersistenceAnnotations( art, target ); // after extendArtifactBefore()
+    setGenExtensions( art, { _composition: elem } );
+    setLink( art, '_origin', target ); // TODO: does this hurt?
+    return art;
+  }
+
+  function populateTargetEntity( art, elem ) {
+    const location = weakRefLocation( elem.targetAspect || elem.target || elem );
+    const targetAspect = art._origin;
+
+    Functions.effectiveType( targetAspect );
+    const { elements } = targetAspect;
 
-    if (!isDeprecatedEnabled( options, 'noCompositionIncludes' ) && art.includes)
-      applyIncludes( art, art ); // for actions
+    if (elements.up_) {
+      // TODO: for "inner aspect-compositions", signal already in type
+      // TODO: if anonymous type, use location of "up_" element
+      // FUTURE: if named type, add sub info with location of "up_" element
+      error( null, [ location, elem ], { target: targetAspect, name: 'up_' },
+             'An aspect $(TARGET) with an element named $(NAME) can\'t be used as target' );
+      delete elements.up_;    // continuation semantics: don't use up_ from aspect
+    }
+
+    if (targetAspect.name) {          // named target aspect
+      if (!isDeprecatedEnabled( options, 'noCompositionIncludes' )) {
+        art.includes = [ createInclude( targetAspect.name.id, location ) ];
+        art.includes.$origin = []; // included elements after up_
+        // TODO: propagate in effectiveType()
+        propagateEarly( art, '@cds.autoexpose' );
+        propagateEarly( art, '@fiori.draft.enabled' );
+      }
+      setLink( art, '_upperAspects', [ targetAspect, ...(elem._main._upperAspects || []) ] );
+    }
+    else {
+      // TODO: do we need to give the anonymous target aspect a kind and name?
+      setLink( art, '_upperAspects', elem._main._upperAspects || [] );
+      // TODO: _upperAspects can probably now be removed
+    }
+    Functions.effectiveType( elem );
+    // To keep the locations of non-inferred original elements, do not set $inferred:
+    const enforceLocation = targetAspect.name || elem.$inferred;
+    addProxyElements( art, elements, 'aspect-composition', enforceLocation && location );
+    initMainArtifact( art );
+
+    // Copy persistence annotations from aspect.
+    if (targetAspect.kind === 'aspect')              // proper aspect
+      copyPersistenceAnnotations( art, targetAspect ); // after extendArtifactBefore()
+    copyPersistenceAnnotations( art, elem._parent );
     return art;
   }
 
+  function populateGeneratedEntity( art ) {
+    const gen = art._extensions?.$gen;
+    if (gen?._composition)
+      populateTargetEntity( art, gen._composition );
+    else if (gen?._textElems)
+      populateTextsEntity( art, gen._base, gen._textElems, gen.fioriEnabled );
+  }
+
   function addProxyElements( proxyDict, elements, inferred, location, prefix = '', anno = '' ) {
-    // TODO: also use for includeMembers()? Both are similar. Combine?
+    // TODO: also use for includeMembers()? Both are similar. Combine!
     for (const name in elements) {
       const pname = `${ prefix }${ name }`;
       const origin = elements[name];
@@ -811,6 +814,8 @@ function generate( model ) {
    * Copy relevant annotations from
    * source to target if present on source but not target.
    *
+   * Persistence annos from target/text aspect have precedence.
+   *
    * @param {object} target
    * @param {object} source
    */
@@ -837,7 +842,7 @@ function generate( model ) {
   }
 
   function linkMainArtifact( location, absolute ) {
-    const r = { location, path: [ { id: absolute, location } ] };
+    const r = { location, path: [ { id: absolute, location } ], scope: 'global' };
     setArtifactLink( r, model.definitions[absolute] );
     return r;
   }
@@ -868,24 +873,6 @@ function augmentEqual( location, assocname, relations, prefix = '' ) {
   }
 }
 
-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;
-}
-
 
 /**
  * Propagate the given `prop` (e.g. annotation) early, i.e. copy it from all `.includes`
@@ -908,5 +895,20 @@ function propagateEarly( art, prop ) {
   }
 }
 
+function setGenExtensions( art, gen ) {
+  const $gen = {};
+  for (const prop of Object.keys( gen )) {
+    Object.defineProperty( $gen, prop, {
+      configurable: true,
+      enumerable: prop.charAt( 0 ) !== '_',
+      value: gen[prop],
+      writable: true,
+    } );
+  }
+  if (art._extensions)
+    art._extensions.$gen = $gen;
+  else
+    art._extensions = { $gen };
+}
 
 module.exports = generate;