@sap/cds-compiler 6.6.0 → 6.7.1

package/lib/compiler/extend.js

@@ -4,14 +4,8 @@
 
 const { weakRefLocation } = require('../base/location');
 const { searchName } = require('../base/messages');
-const {
-  forEachInOrder,
-  forEachDefinition,
-  forEachMember,
-  forEachGeneric,
-  isDeprecatedEnabled,
-} = require('../base/model');
-const { dictAdd, pushToDict } = require('../base/dictionaries');
+const { isDeprecatedEnabled } = require('../base/model');
+const { dictAdd, pushToDict, dictForEach } = require('../base/dictionaries');
 const { kindProperties, dictKinds } = require('./base');
 const {
   setLink,
@@ -26,9 +20,14 @@ const {
   initDollarSelf,
   initBoundSelfParam,
   dependsOnSilent,
-  storeExtension,
   pathName,
   annotationHasEllipsis,
+  forEachInOrder,
+  forEachDefinition,
+  forEachMember,
+  forEachGeneric,
+  isDirectComposition,
+  targetCantBeAspect,
 } = require('./utils');
 const layers = require('./moduleLayers');
 const { CompilerAssertion } = require('../base/error');
@@ -36,8 +35,9 @@ const { Location } = require('../base/location');
 const { typeParameters } = require('./builtins');
 
 const $location = Symbol.for( 'cds.$location' );
+const $inferred = Symbol.for( 'cds.$inferred' ); // TODO: no $inferred yet?
 
-// attach stupid location - TODO: remove in v6
+// attach stupid location - TODO: remove in v7
 const genLocation = new Location( '' );
 
 const draftElements = [
@@ -68,15 +68,14 @@ function extend( model ) {
     resolveTypeArgumentsUnchecked,
     resolveDefinitionName,
     attachAndEmitValidNames,
-    targetIsTargetAspect,
     checkRedefinition,
-    initSelectItems,
   } = model.$functions;
 
   Object.assign( model.$functions, {
     createRemainingAnnotateStatements,
     extendArtifactBefore,
     extendArtifactAfter,
+    extendArtifactAdd,
     extendForeignKeys,
     withLocalizedData,
     applyIncludes,              // TODO: re-check
@@ -85,20 +84,56 @@ function extend( model ) {
   const includesNonShadowedFirst
     = isDeprecatedEnabled( model.options, '_includesNonShadowedFirst' );
 
+  forEachGeneric( model, 'definitions', tagCompositionTargets );
+  dictForEach( model.$collectedExtensions, e => e._extensions.forEach( tagCompositionTargets ) );
+  // remark: tagging on extensions works _before_ running extendArtifactBefore() on each artifact
   sortModelSources();
-  const extensionsDict = Object.create( null ); // TODO TMP
-  forEachDefinition( model, tagIncludes ); // TODO TMP
 
+  // Set annotations on user-provided artifacts, but they are not propagated yet!
+  // Use them in the main compiler phase (and before) with extra care:
   forEachDefinition( model, extendArtifactBefore );
-  applyExtensions();            // old-style
   return;
 
-  // TMP:
-  function tagIncludes( art ) {
-    if (art.includes)
-      extensionsDict[art.name.id] = [];
+  // Tag composition targets: ---------------------------------------------------
+
+  function tagCompositionTargets( elem ) {
+    if (elem.$inferred)         // TODO: probably no $inferred yet
+      return;
+    if (elem.targetAspect?.elements)
+      elem = elem.targetAspect;
+    if (elem.elements) {
+      forEachGeneric( elem, 'elements', tagCompositionTargets );
+    }
+    else if (elem.columns) {    // `elem` is query or extension
+      elem.columns.forEach( tagCompositionTargets );
+    }
+    else if (elem.$queries) {
+      for (const query of elem.$queries) {
+        if (query.mixin)
+          forEachGeneric( query, 'mixin', tagCompositionTargets );
+        if (query.columns)
+          query.columns.forEach( tagCompositionTargets );
+        // Remark: no directly published expand/inline column yet
+      }
+    }
+    else if (elem.target && isDirectComposition( elem )) {
+      const name = resolveUncheckedPath( elem.target, 'target', elem );
+      if (!name)
+        return;
+      const target = model.definitions[name];
+      // move target aspect in `target` to `targetAspect` (in define.js, we only
+      // do it with anonymous aspect)
+      if (target?.kind in { aspect: 1, type: 1 } && // type is sloppy
+          target.elements && !target.elements[$inferred] &&
+          !targetCantBeAspect( elem, false, model.definitions )) { // tests `!elem.targetAspect`
+        elem.targetAspect = elem.target;
+        delete elem.target;
+      }
+      model.$compositionTargets[name] = true; // does not hurt if set on aspect
+    }
   }
 
+
   //-----------------------------------------------------------------------------
   // Extensions: general algorithm
   //-----------------------------------------------------------------------------
@@ -110,6 +145,9 @@ function extend( model ) {
    * if multiple exist according to the module layer.
    * TODO: update comment if extension algorithm is finished
    *
+   * Called at the beginning for each main artifact, and must not call
+   * resolvePath() then.  It is later called via effectiveType().
+   *
    * @param {XSN.Artifact} art
    */
   function extendArtifactBefore( art ) {
@@ -126,6 +164,9 @@ function extend( model ) {
         // for now, we do that at the end of createRemainingAnnotateStatements()
       }
     }
+    if (art.kind === 'entity' && art.includes && !art._entityIncludes)
+      setEntityIncludes( art, art );
+
     if (art._extensions) {
       // TODO: the following function can now be simplified
       // if (art.$inferred) console.log('CAI:', art.name, art.$inferred,art._extensions)
@@ -135,19 +176,39 @@ function extend( model ) {
       if (art.$inferred)
         setExpandStatusAnnotate( art, 'annotate' );
       if (Array.isArray( art._extensions )) {
-        checkExtensionsKind( art._extensions, art ); // TODO: check with builtins
+        checkExtensionsKind( art._extensions, art );
         transformArtifactExtensions( art );
       }
-      applyAllExtensions( art );
+      // console.log('EA:',require('../model/revealInternalProperties')
+      //             .ref(art),Object.keys(art._extensions))
+      for (const prop in art._extensions) {
+        if (Object.hasOwn( art._extensions, prop ) &&
+            // remark: if we change the array, consider whether to delete the artifact
+            ![ 'elements', 'actions', 'params', '$gen' ].includes( prop ))
+          applyPropertyExtensions( art, prop );
+      }
     }
   }
 
-  // TODO: assert that we have not yet transformed/used _extensions on sub elements
-  // TODO necessary(?): transformArtifactExtensions must ensure that each annotate
-  // is in either returns,items,elements,enum
+  /**
+   * Push down extensions on member properties like `elements` to the individual
+   * members (setting their `_extensions` property).
+   * Currently, definitions in `extend` members are ignored,
+   * because they are handled a-priori by the old-style extension mechanism.
+   *
+   * Outside this file: only called in effectiveType() and indirectly in
+   * tweak-assocs.js (for foreign keys and super-annotates).
+   */
   function extendArtifactAfter( art ) {
+    // TODO: assert that we have not yet transformed/used _extensions on sub elements
+    // TODO necessary(?): transformArtifactExtensions must ensure that each annotate
+    // is in either returns,items,elements,enum
+    if (art.builtin)            // builtin members handled via "super annotate"
+      return;
+    // If elements are added in the future via includes or extend, it should be done here
+
     const extensionsMap = art._extensions;
-    if (!extensionsMap || art.builtin) // builtin members handled via "super annotate"
+    if (!extensionsMap)         // builtin members handled via "super annotate"
       return;
     // type extensions after having “populated” the artifact ($typeArgs -> length,
     // …, TODO: do that there) and setting an _effectiveType:
@@ -165,38 +226,39 @@ function extend( model ) {
       delete art.$typeExts;
     }
 
-    if (art.kind === 'annotate' && !art.returns && extensionsMap.returns && !art._parent?.returns)
-      annotateCreate( art, '', art, 'returns' );
-
     moveDictExtensions( art, extensionsMap, 'actions' );
     moveDictExtensions( art, extensionsMap, 'params' );
-    moveReturnsExtensions( art, extensionsMap );
-
-    if (art.returns) {
-      ensureArtifactNotProcessed( art.returns );
-      pushToDict( art.returns, '_extensions', ...extensionsMap.elements || [] );
-      pushToDict( art.returns, '_extensions', ...extensionsMap.enum || [] );
-      if (art.kind !== 'annotate') {
-        extendHandleReturns( extensionsMap.elements, art );
-        extendHandleReturns( extensionsMap.enum, art );
-        return;
+    if (!extensionsMap.elements)
+      return;
+
+    // after populateArtifact, it is clear which properties the artifact has:
+    const artProp = art.kind === 'action' || art.kind === 'function'
+      ? 'returns'
+      : [ 'returns', 'targetAspect', 'items' ].find( p => art[p] );
+    if (artProp) {
+      const returnsDict = artProp === 'returns' && !art.returns &&
+        annotateFor( art, 'params', '' );  // create anno for non-existing returns
+      for (const ext of extensionsMap.elements) {
+        if (!ext.returns) {
+          pushToDict( returnsDict || art[artProp], '_extensions', ext );
+          if (artProp === 'returns')
+            extendHandleReturns( ext, art );
+        }
+        else {
+          pushToDict( returnsDict || art[artProp], '_extensions', ext.returns );
+          if (!art.returns)
+            checkReturnsExtension( ext, art );
+        }
       }
+      // TODO: what about `many many Type` (via CSN)?
     }
-    const sub = art.items || art.targetAspect?.elements && art.targetAspect;
-    if (sub) {
-      ensureArtifactNotProcessed( sub );
-      pushToDict( sub, '_extensions', ...extensionsMap.elements || [] );
-      pushToDict( sub, '_extensions', ...extensionsMap.enum || [] );
-    }
-    else {
-      let elementsProp = 'elements';
-      if (art.kind !== 'annotate')
-        elementsProp = art.enum && 'enum' || art.target && 'foreignKeys' || 'elements';
-
-      // keys are handled in tweak-assocs.js; don't push them down; see extendForeignKeys()
-      if (elementsProp !== 'foreignKeys')
-        moveDictExtensions( art, extensionsMap, elementsProp, 'elements' );
-      moveDictExtensions( art, extensionsMap, 'enum' );
+    else if (!art.target) { // TODO: foreign keys currently handled specially
+      for (const ext of extensionsMap.elements) {
+        if (ext.returns)
+          checkReturnsExtension( ext, art );
+      }
+      // if (art.elements || art.enum || art.kind === 'annotate')
+      moveDictExtensions( art, extensionsMap, (art.enum ? 'enum' : 'elements'), 'elements' );
     }
   }
 
@@ -281,6 +343,9 @@ function extend( model ) {
 
   // For extendArtifactBefore(): ------------------------------------------------
 
+  /**
+   * Complain about invalid `extend service` and `extend context`.
+   */
   function checkExtensionsKind( extensions, art ) {
     for (const ext of extensions) {
       const kind = ext.expectedKind?.val;
@@ -295,7 +360,7 @@ function extend( model ) {
             code: 'extend … with definitions',
             keyword: 'extend service',
           };
-          // TODO(v6): Discuss: make this an error?
+          // TODO v7: Discuss: make this an error?
           warning( 'ext-invalid-kind', [ loc, ext ], msgArgs, {
             std: 'Artifact $(ART) is not of kind $(KIND), use $(CODE) instead',
             annotate: 'There is no artifact $(ART), use $(CODE) instead',
@@ -308,26 +373,63 @@ function extend( model ) {
     }
   }
 
-  // TODO: if extensions has more than one of returns,items,elements,enum, delete all those props
+  /**
+   * Transform `art._extensions` from an array of extensions into an object
+   * `{ prop: relevantExtensions, … }` where `relevantExtensions` are the extensions
+   * which are relevant for the value of `art[prop]` after the application of extensions.
+   *
+   * Remark: it is not necessarily clear at this moment whether `art` has
+   * `elements`, `enums`, `items`, etc.
+   */
   function transformArtifactExtensions( art ) {
-    const hasOnlySubExtensions = art._outer; // items, anonymous aspects
-    const dict = Object.create( null );
+    // TODO: if extensions has more than one of returns,items,elements,enum, delete all those props
+    const dict = {};
     for (const ext of art._extensions) {
+      // `annotate SomeFunction with @action { r @elem };` would later be moved to
+      // `someFunction.returns._extensions` due to `elements` → @action not relevant then:
+      // (TODO: should we use some “already applied” flag instead?)
+      const isAutoItemsOrReturns = art._outer || // in items or targetAspect
+        art._parent?.returns === art && !ext._parent?.returns;
       for (const prop in ext) {
-        if (ext[prop] === undefined) // deleted property
+        if (!Object.hasOwn( ext, prop ) || ext[prop] === undefined) // deleted property
           continue;
         // TODO: do this check nicer (after complete move to new extensions mechanism)
-        if (prop.charAt(0) === '@' || prop === 'doc' ||
-            prop === 'includes' || prop === 'columns' ||
+        if (prop === 'includes') {
+          pushToDict( dict, prop, ext );
+          pushTo$add( dict, ext );
+        }
+        else if (prop.charAt(0) === '@' || prop === 'doc' || prop === 'columns' ||
             prop === 'length' || prop === 'scale' || prop === 'precision' || prop === 'srid') {
-          if (!hasOnlySubExtensions)
+          if (!isAutoItemsOrReturns)
             pushToDict( dict, prop, ext );
         }
-        else if (prop === 'elements' || prop === 'enum' || prop === 'actions' ||
-                 prop === 'params' || prop === 'returns') {
-          if (ext.kind === 'extend')
-            pushToDict( dict, 'includes', ext );
+        else if (prop === 'elements' || prop === 'enum') {
+          if (ext.returns) {                    // TODO: currently, an annotate can have both
+            // if this is a hard error, we could use syntax-unexpected-property#sibling
+            message( 'syntax-unexpected-with-returns',
+                     [ ext[prop][$location] || ext.location, ext ],
+                     { prop, siblingprop: 'returns' },
+                     // eslint-disable-next-line @stylistic/max-len
+                     'Property $(PROP) of an annotate statement is ignored when it also has a property $(SIBLINGPROP)' );
+          }
+          else {
+            pushToDict( dict, 'elements', ext ); // yes, enum → elements here
+            if (ext.kind === 'extend' && !isAutoItemsOrReturns)
+              pushTo$add( dict, ext );
+          }
+        }
+        else if (prop === 'returns') {
+          pushToDict( dict, 'elements', ext );
+          // create 'returns' for the super annotate, store in elements anyway
+          if (!art.returns && art.kind === 'annotate')
+            annotateCreate( art, '', art, 'returns' );
+          if (ext.kind === 'extend' && !isAutoItemsOrReturns)
+            pushTo$add( dict, ext );
+        }
+        else if (prop === 'actions' || prop === 'params') {
           pushToDict( dict, prop, ext );
+          if (ext.kind === 'extend' && prop === 'actions' && !isAutoItemsOrReturns)
+            pushTo$add( dict, ext );
         }
       }
     }
@@ -360,40 +462,49 @@ function extend( model ) {
     setLink( model, '_sortedSources', scheduled );
   }
 
-  function applyAllExtensions( art ) {
+  /**
+   * For all `prop → extensions` in `art._extensions`, apply the extensions.
+   * Currently only for annotations, the `doc` property, `columns` and type properties,
+   * not for `elements` and other members.
+   */
+  function applyPropertyExtensions( art, prop ) {
     const extensions = art._extensions;
-    for (const prop in extensions) {
-      // TODO: do the following `if` in a nicer way
-      if ([ 'elements', 'enum', 'actions', 'params', 'returns' ].includes( prop ))
-        continue;               // currently just annotates on sub elements - TODO: error here
-      // annotations, `doc`, `includes`, `columns`, `length`, ...
-      const scheduled = [];
-      // sort extensions according to layer (specified elements are bottom layer):
-      const layered = layeredExtensions( extensions[prop] );
-
-      let cont = true;
-      while (cont) {
-        const { highest, issue } = extensionsOfHighestLayers( layered );
-        // console.log( 'CA:', annoName, issue, extensions)
-        let index = highest.length;
-        cont = !!index;         // safety
-        while (--index >= 0) {
-          const ext = highest[index];
-          scheduled.push( ext );
-          if (extensionOverwrites( ext, prop )) {
-            cont = false;
-            break;
-          }
+    // annotations, `doc`, `includes`, `columns`, `length`, ...
+    const scheduled = [];
+    // sort extensions according to layer (specified elements are bottom layer):
+    const layered = layeredExtensions( extensions[prop] );
+
+    let cont = true;
+    while (cont) {
+      const { highest, issue } = extensionsOfHighestLayers( layered );
+      // console.log( 'CA:', annoName, issue, extensions)
+      let index = highest.length;
+      cont = !!index;         // safety
+      while (--index >= 0) {
+        const ext = highest[index];
+        scheduled.push( ext );
+        if (extensionOverwrites( ext, prop )) {
+          cont = false;
+          break;
         }
-        if (issue || index > 0)
-          reportDuplicateExtensions( highest, prop, issue, index, art );
       }
-      // Now apply the relevant extensions
-      scheduled.reverse();
-      for (const ext of scheduled)
-        applySingleExtension( art, ext, prop );
-      delete extensions[prop];
-    }
+      if (issue || index > 0)
+        reportDuplicateExtensions( highest, prop, issue, index, art );
+    }
+    // Now apply the relevant extensions
+    scheduled.reverse();
+    if (prop === 'includes' && !art.includes?.$original) {
+      const $original = art.includes ?? [];
+      art.includes = [ ...$original ];
+      art.includes.$original = $original;
+    }
+    if (prop === '$add') {
+      extensions[prop] = scheduled;
+      return;                   // the $add is applied in extendArtifactAdd()
+    }
+    for (const ext of scheduled)
+      applySingleExtension( art, ext, prop );
+    delete extensions[prop];
   }
 
   function extensionOverwrites( ext, prop ) {
@@ -405,9 +516,10 @@ function extend( model ) {
   // TODO: still a bit annotation assignment specific
   function reportDuplicateExtensions( extensions, prop, issue, index, art ) {
     // TODO: think about messages for these
-    if (prop === 'elements' || prop === 'enum' || prop === 'actions' || prop === 'columns' ||
-        prop === 'params' || prop === 'returns' || prop === 'includes' )
+    if (prop === 'elements' || prop === 'actions' || prop === 'columns' ||
+        prop === 'params' || prop === '$add' )
       return;                   // extensions currently handled extra
+    // TODO: columns?
     if (issue) {
       // eslint-disable-next-line no-nested-ternary
       let msg = (index < 0)
@@ -421,6 +533,7 @@ function extend( model ) {
           : 'ext-duplicate-extend-type-unrelated-layer';
         // not sure whether to repeat the extended artifact in the message (we
         // have the semantic location, after all)
+        // extend-repeated-intralayer / extend-unrelated-layer
       }
       const variant = prop === 'doc' ? 'doc' : 'std';
       for (const ext of extensions) {
@@ -447,14 +560,16 @@ function extend( model ) {
 
   function applySingleExtension( art, ext, prop ) {
     if (prop === 'includes') {
-      if (ext.kind === 'extend' && art.$inferred) {
-        error( 'extend-for-generated', [ ext.name.location, ext ], { art, keyword: 'extend' },
-               'You can\'t use $(KEYWORD) on the generated $(ART)' );
-      }
-      else if (art.kind !== 'annotate' && !art._outer) { // not with elem extension in targetAspect
-        const { id } = art.name;
-        const dict = extensionsDict[id] || (extensionsDict[id] = []);
-        dict.push( ext ); // TODO: change
+      if (art.kind !== 'annotate' && !art._outer) { // TODO: why this check?
+        // not with elem extension in targetAspect
+        art.includes.push( ...ext.includes );
+        // head of ref in in ext.includes must be set in _block of ext; for
+        // remaining path items, effectiveType() has `art` as user
+        // (alternatively, we could set some _user on `includes` items):
+        for (const ref of ext.includes)
+          resolveUncheckedPath( ref, 'include', ext );
+        if (art.kind === 'entity')
+          setEntityIncludes( ext, art );
         // console.log( 'ASI:',prop,art.name,ext,extensionsDict[id])
       }
       // art[prop] = (art[prop]) ? art[prop].concat( ext[prop] ) : ext[prop];
@@ -476,7 +591,7 @@ function extend( model ) {
         query.columns = [ { location: query.from.location, val: '*' }, ...ext.columns ];
       else
         query.columns.push( ...ext.columns );
-      initSelectItems( query, ext.columns, query, true );
+      ext.columns.forEach( col => changeParentLinks( col, query ) );
     }
     else if (typeParameters.list.includes( prop )) {
       const typeExts = art.$typeExts || (art.$typeExts = {});
@@ -488,6 +603,24 @@ function extend( model ) {
     }
   }
 
+  function changeParentLinks( art, queryOrMain ) {
+    // TODO: we might also change the implicit name (if name.id is a number,
+    // adding the previous column lenght - 1) for better error messages
+    const parent = art._parent;
+    if (!art._parent)
+      return;
+    if (parent.kind === 'extend')
+      art._parent = queryOrMain;
+    if (art._main.kind === 'extend') // TODO: probably always
+      art._main = queryOrMain._main;
+    if (art._columnParent?.kind === 'extend')
+      art._columnParent = queryOrMain;
+    const subColumns = art.expand || art.inline;
+    if (subColumns)
+      subColumns.forEach( a => changeParentLinks( a, queryOrMain ) );
+    forEachMember( art, a => changeParentLinks( a, queryOrMain ) );
+  }
+
   function applyAssignment( previousAnno, anno, art, annoName ) {
     const firstEllipsis = annotationHasEllipsis( anno );
     if (!firstEllipsis)
@@ -683,17 +816,16 @@ function extend( model ) {
   /**
    * If the target artifact has both precision and scale set, then extensions on it must also
    * provide both to avoid user errors for subsequent `extend` statements.
+   * There is already a syntax error [syntax-missing-type-property] for `scale` without `precision`.
    *
    * @param {XSN.Artifact} art
    * @param {object} exts
    */
   function checkPrecisionScaleExtension( art, exts ) {
     if (art.precision && art.scale) {
-      if ((exts.precision || exts.scale) && !(exts.precision && exts.scale)) {
-        const missing = exts.precision ? 'scale' : 'precision';
-        const prop = exts.precision ? 'precision' : 'scale';
-        error( 'ext-missing-type-property', [ exts[prop].location, exts[prop] ],
-               { art, prop, otherprop: missing } );
+      if (exts.precision && !exts.scale) {
+        error( 'ext-missing-type-property', [ exts.precision.location, exts.precision ],
+               { art, prop: 'precision', otherprop: 'scale' } );
       }
     }
   }
@@ -711,58 +843,22 @@ function extend( model ) {
     if (!extensions)
       return;
 
-    const artDict = art[artProp] || annotateFor( art, extProp ); // no auto-correction in annotate
-
     for (const ext of extensions) {
       let dictCheck = (art.kind !== 'annotate'); // no check in super annotate statement
-      forEachGeneric(ext, extProp, (elemExt, name) => {
+      forEachGeneric( ext, extProp, ( elemExt, name ) => {
         if (elemExt.kind !== 'annotate' && elemExt.kind !== 'extend') // TODO: specified elems
           return;             // definitions inside extend, already handled
         dictCheck = dictCheck && checkRemainingMemberExtensions( art, elemExt, artProp, name );
-        const elem = artDict[name] || annotateFor( art, extProp, name );
+        const elem = art[artProp]?.[name] || annotateFor( art, extProp, name );
         setLink( elemExt.name, '_artifact', (elem.kind !== 'annotate' ? elem : null ) );
+        // TODO: why null for annotate?
         ensureArtifactNotProcessed( elem );
-        if (elem.$duplicates !== true)
+        if (elem.$duplicates !== true) // TODO: re-check
           pushToDict( elem, '_extensions', elemExt );
       });
     }
   }
 
-  function moveReturnsExtensions( art, extensionsMap ) {
-    const extensions = extensionsMap.returns;
-    if (!extensions)
-      return;
-    const artReturns = art.returns;
-    let extReturns = artReturns;
-    const isAction = art.kind === 'action' || art.kind === 'function';
-
-    for (const ext of extensions) {
-      if (!artReturns && art.kind !== 'annotate') {
-        const msgId = ext.returns && hasSecurityAnno( ext.returns )
-          ? 'ext-unexpected-returns-sec'
-          : 'ext-unexpected-returns';
-        message( msgId, [ ext.returns.location, ext ], {
-          '#': (isAction ? art.kind : 'std'), keyword: 'returns',
-        }, {
-          std: 'Unexpected $(KEYWORD); only actions and functions have return parameters',
-          action: 'Unexpected $(KEYWORD) for action without return parameter',
-          // function without `returns` can happen via CSN input! TODO: check in parser
-          function: 'Unexpected $(KEYWORD) for function without return parameter',
-        } );
-        // Do not put completely wrong returns into a “super annotate” statement;
-        // this could induce consequential errors with [..., …]:
-        if (!isAction)
-          continue;             // do not put into 'extensions'
-        // add to 'extensions' for action/function without returns:
-        extReturns ??= annotateFor( art, 'params', '' );
-      }
-      if (extReturns) {
-        setLink( ext.name, '_artifact', (isAction ? artReturns : null ) );
-        pushToDict( extReturns, '_extensions', ext.returns );
-      }
-    }
-  }
-
   function annotateFor( art, prop, name ) {
     const base = annotateBase( art );
     if (name === '' && prop === 'params')
@@ -805,16 +901,33 @@ function extend( model ) {
     return annotate;
   }
 
-  function extendHandleReturns( extensions, art ) {
-    for (const ext of extensions || []) {
-      warning( 'ext-expecting-returns', [ ext.name.location, ext ], {
-        '#': art.kind, keyword: 'returns', code: 'annotate ‹name› with returns { … }',
-      }, {
-        std: 'Expected $(CODE)', // unused variant
-        action: 'Expected $(KEYWORD) when annotating action return structure, i.e. $(CODE)',
-        function: 'Expected $(KEYWORD) when annotating function return structure, i.e. $(CODE)',
-      } );
-    }
+  function checkReturnsExtension( ext, art ) {
+    const msgId = hasSecurityAnno( ext.returns )
+      ? 'ext-unexpected-returns-sec'
+      : 'ext-unexpected-returns';
+    message( msgId, [ ext.returns.location, ext ],
+             { '#': art.kind, keyword: 'returns' },
+             {
+               std: 'Unexpected $(KEYWORD); only actions and functions have return parameters',
+               action: 'Unexpected $(KEYWORD) for action without return parameter',
+               // function without `returns` can happen via CSN input! TODO: check in parser
+               function: 'Unexpected $(KEYWORD) for function without return parameter',
+             } );
+    // Do not put completely wrong returns into a “super annotate” statement;
+    // this could induce consequential errors with [..., …]:
+    return art.kind === 'action' || art.kind === 'function';
+  }
+
+  function extendHandleReturns( ext, art ) {
+    warning( 'ext-expecting-returns', [ ext.name.location, ext ], {
+      '#': art.kind, keyword: 'returns', code: 'annotate ‹name› with returns { … }',
+    }, {
+      std: 'Expected $(CODE)', // unused variant
+      action: 'Expected $(KEYWORD) when annotating action return structure, i.e. $(CODE)',
+      function: 'Expected $(KEYWORD) when annotating function return structure, i.e. $(CODE)',
+      // eslint-disable-next-line @stylistic/max-len
+      annotate: 'Expected $(KEYWORD) when annotating a return structure of an unknown action or function, i.e. $(CODE)',
+    } );
   }
 
   function checkRemainingMemberExtensions( parent, ext, prop, name ) {
@@ -915,7 +1028,7 @@ function extend( model ) {
     if (extensions && !annotate._main) {
       const art = model.definitions[annotate.name.id];
       for (const ext of extensions)
-        checkRemainingMainExtensions( art, ext );
+        checkRemainingMainExtensions( art, ext ); // induce messages for extension path
       if (art?.builtin && art.kind !== 'namespace') { // TODO: do not set `builtin` on cds, cds.hana
         setLink( annotate, '_extensions', art._extensions ); // for messages and member extensions
         // direct annotations on builtins or on the builtins for propagation, and
@@ -991,28 +1104,22 @@ function extend( model ) {
 
   // extend, mainly old-style ---------------------------------------------------
 
-  /**
-   * Apply the extensions inside the extensionsDict on the model.
-   *
-   * First try normally: extends with structure includes; with remaining cyclic
-   * includes, do so without includes.
-   */
-  function applyExtensions() {
-    let cyclicIncludeNames = false;
-    let extNames = Object.keys( extensionsDict ).sort();
-
-    while (extNames.length) {
-      const { length } = extNames;
-      for (const name of extNames) {
-        const art = model.definitions[name];
-        if (art && art.kind !== 'namespace' &&
-            extendArtifact( extensionsDict[name], art, cyclicIncludeNames ))
-          delete extensionsDict[name];
-      }
-      extNames = Object.keys( extensionsDict ); // no sort() required anymore
-      if (extNames.length >= length)
-        cyclicIncludeNames = Object.keys( extensionsDict ); // = no includes
+  function extendArtifactAdd( art ) {
+    const { includes } = art;
+    if (includes) {
+      if (includes.$original)              // if extensions with includes:
+        art.includes = includes.$original; // original includes have been stored
+      if (art.includes?.length)
+        applyIncludes( art, art );
+      art.includes = includes;
+      // early propagation of specific annotation assignments
+      // TODO: propagate in effectiveType() ?
+      propagateEarly( art, '@cds.autoexpose' );
+      propagateEarly( art, '@fiori.draft.enabled' );
     }
+    if (art._extensions?.$add)
+      extendArtifact( art._extensions.$add, art );
+    // TODO: for proper shadowing: first collect defined element & action names
   }
 
   /**
@@ -1028,40 +1135,13 @@ function extend( model ) {
    * @param {XSN.Definition} art
    * @param {String[]|false} [cyclicIncludeNames=false]
    */
-  function extendArtifact( extensions, art, cyclicIncludeNames = null ) {
-    if (!cyclicIncludeNames && !(canApplyIncludes( art, art ) &&
-        extensions.every( ext => canApplyIncludes( ext, art ) )))
-      return false;
-    if (cyclicIncludeNames) {
-      canApplyIncludes( art, art, cyclicIncludeNames );
-      extensions.forEach( ext => canApplyIncludes( ext, art, cyclicIncludeNames ) );
-    }
-    else if (!(canApplyIncludes( art, art ) &&
-               extensions.every( ext => canApplyIncludes( ext, art ) ))) {
-      // console.log( 'FALSE:',art.name, extensions.map( e => e.name ) )
-      return false;
-    }
-    if (!art.query) {
+  function extendArtifact( extensions, art ) {
+    if (!art.query && !art._main && !art._outer) { // TODO: remove _entities
       model._entities.push( art ); // add structure with includes in dep order
-      art.$entity = ++model.$entity;
-    }
-    if (art.includes) {
-      if (!cyclicIncludeNames) {
-        applyIncludes( art, art );
-      }
-      else {
-        // resolve artifacts to induce errors: either ref-invalid-include or ref-cyclic
-        for (const ref of art.includes)
-          resolvePath( ref, 'include', art );
-      }
     }
+    // TODO: complain if $inferred
     // checkExtensionsKind( extensions, art );
     extendMembers( extensions, art );
-    if (!cyclicIncludeNames && art.includes) {
-      // early propagation of specific annotation assignments
-      propagateEarly( art, '@cds.autoexpose' );
-      propagateEarly( art, '@fiori.draft.enabled' );
-    }
     // TODO: complain about element extensions inside projection
     return true;
   }
@@ -1069,32 +1149,29 @@ function extend( model ) {
   function extendMembers( extensions, art ) {
     // TODO: do the whole extension stuff lazily if the elements are requested
     const elemExtensions = [];
-    if (art._main)              // extensions already sorted for main artifacts
-      extensions.sort( layers.compareLayer );
+    // if (art._main)              // extensions already sorted for main artifacts
+    //   extensions.sort( layers.compareLayer );
     // TODO: use same sequence as in chooseAssignment() - better: use common code with that fn
     // console.log('EM:',art.name,extensions,art._extensions)
     for (const ext of extensions) { // those in extMap.includes
+      if (art.$inferred) {
+        error( 'extend-for-generated', [ ext.name.location, ext ], { art, keyword: 'extend' },
+               'You can\'t use $(KEYWORD) on the generated $(ART)' ); // or with inferred elements
+      }
+
+
       // console.log(message( 'id', [ext.location, ext], { art: ext.name._artifact },
       //                      'Info', 'EXT').toString())
-      if (ext.name._artifact === undefined) { // not already applied
-        setArtifactLink( ext.name, art );
-        if (ext.includes) {
-          // TODO: currently, re-compiling from gensrc does not give the exact
-          // element sequence - we need something like
-          //    includes = ['Base1',3,'Base2']
-          // where 3 means adding the next 3 elements before applying include 'Base2'
-          if (art.includes)
-            art.includes.push( ...ext.includes );
-          else
-            art.includes = [ ...ext.includes ];
-          applyIncludes( ext, art );
-        }
-        // console.log(ext,art)
-        checkAnnotate( ext, art );
-        // TODO: do we allow to add elements with array of {...}?  If yes, adapt
-        initMembers( ext, art, ext._block ); // might set _extend, _annotate
-        dependsOnSilent( art, ext ); // art depends silently on ext (inverse to normal dep!)
-      }
+      setArtifactLink( ext.name, art ); // TODO: probably already done
+      if (ext.includes)
+        applyIncludes( ext, art );
+
+      // console.log(ext,art)
+      checkAnnotate( ext, art );
+      // TODO: do we allow to add elements with array of {...}?  If yes, adapt
+      initMembers( ext, art, ext._block ); // might set _extend, _annotate
+      dependsOnSilent( art, ext ); // art depends silently on ext (inverse to normal dep!)
+
       for (const name in ext.elements) {
         const elem = ext.elements[name];
         if (elem.kind === 'element') { // i.e. not extend or annotate
@@ -1104,7 +1181,7 @@ function extend( model ) {
       }
     }
     if (elemExtensions.length > 1)
-      reportUnstableExtensions( elemExtensions );
+      reportUnstableExtensions( elemExtensions ); // TODO: still?
 
     // This whole function will be removed with a next change - no need to have nice code here:
     const dict = Object.create( null );
@@ -1128,8 +1205,6 @@ function extend( model ) {
       const member = validDict && validDict[name];
       if (!member)
         extendNothing( dict[name], 'elements', name, art, validDict );
-      else if (!(member.$duplicates))
-        extendMembers( dict[name], member );
     }
   }
 
@@ -1217,23 +1292,10 @@ function extend( model ) {
     const isQueryExtension = construct.kind === 'extend' && main.query;
     let obj = initItemsLinks( construct, block );
     initExprAnnoBlock( construct, block );
-    if (obj.target && targetIsTargetAspect( obj )) {
-      obj.targetAspect = obj.target;
-      delete obj.target;
-    }
     const { targetAspect } = obj;
-    if (targetAspect) {
-      if (obj.foreignKeys) {
-        error( 'type-unexpected-foreign-keys', [ obj.foreignKeys[$location], construct ] );
-        delete obj.foreignKeys; // continuation semantics: not specified
-      }
-      if (obj.on && !obj.target) {
-        error( 'type-unexpected-on-condition', [ obj.on.location, construct ] );
-        delete obj.on;          // continuation semantics: not specified
-      }
-      if (targetAspect.elements)
-        initAnonymousAspect();
-    }
+    if (targetAspect?.elements)
+      initAnonymousAspect();
+
     if (obj !== parent && obj.elements && parent.enum) { // applying the extension
       initElementsAsEnum();
     }
@@ -1258,6 +1320,8 @@ function extend( model ) {
     }
     return;
 
+    // We allow `extend MyEnum with {…}` and not just `extend MyEnum with enum {…}`
+    // for compatibility, with a warning.
     function initElementsAsEnum() {
       // in extensions, extended enums are represented as elements
       let hasElement = false;
@@ -1265,11 +1329,7 @@ function extend( model ) {
         const e = obj.elements[n];
         if (e.kind === 'extend')
           continue;
-        const noVal = e.value?.val === undefined && e.value?.sym === undefined;
-        // TODO: forbid #symbol as enum value
-        if (e.$syntax === 'element' || // `extend … with elements` or `extend with { element … }`
-            noVal && e.$syntax !== 'enum' || // no value in CDL input
-            e.virtual || e.key || e.masked || e.type || e.elements || e.items || e.stored) {
+        if (e.$syntax !== 'or-enum') { // parser might set $syntax: 'or-enum'
           // We do not want to complain separately about all element properties:
           error( 'ext-unexpected-element', [ e.location, construct ],
                  { name: e.name.id, code: 'extend … with enum' },
@@ -1279,13 +1339,9 @@ function extend( model ) {
           return;
         }
         e.kind = 'enum';
-        if (noVal || e.$syntax !== 'enum')
-          hasElement = true;    // warning with CDL input or `name: {}` in CSN input
+        hasElement = true;    // warning with CDL input or `name: {}` in CSN input
       }
       if (hasElement) {
-        // This message is similar to the one above.  In v6, we could probably
-        // turn this warning into an error, remove `$syntax: 'element',
-        // and use the above `ext-unexpected-element` only for CSN input.
         warning( 'ext-expecting-enum', [ obj.elements[$location], construct ],
                  { code: 'extend … with enum' }, 'Use $(CODE) when extending enums' );
       }
@@ -1329,8 +1385,6 @@ function extend( model ) {
     }
 
     function init( elem, name, prop ) {
-      if (!elem.kind)           // wrong CSN input
-        elem.kind = dictKinds[prop];
       if (!elem.name && !elem._outer) {
         const ref = elem.targetElement || elem.kind === 'element' && elem.value;
         if (ref && ref.path) {
@@ -1345,10 +1399,9 @@ function extend( model ) {
       if (!elem._block)
         setLink( elem, '_block', block );
       // if (!kindProperties[ elem.kind ]) console.log(elem.kind,elem.name)
-      if ((elem.kind === 'extend' || elem.kind === 'annotate')) {
-        storeExtension( elem, name, prop, parent );
+      if ((elem.kind === 'extend' || elem.kind === 'annotate'))
         return;
-      }
+
       if (isQueryExtension && elem.kind === 'element') {
         error( 'extend-query', [ elem.location, construct ], // TODO: searchName ?
                { code: 'extend projection' },
@@ -1359,19 +1412,21 @@ function extend( model ) {
       const existing = parent[prop]?.[name];
       const add = construct !== parent && (!existing || elem.$inferred !== 'include');
       // don't dump with `entity T {}; extend T with { extend e {}; e {}; e {} };`:
-      if (elem.$duplicates === true && add)
+      const { $duplicates } = elem;
+      if ($duplicates === true && add)
         elem.$duplicates = null;
       setMemberParent( elem, name, parent, add && prop );
-      checkRedefinition( elem );
+      if (!$duplicates)         // not already reported
+        checkRedefinition( elem );
       initMembers( elem, elem, elem._block );
       if (elem.kind === 'action' || elem.kind === 'function')
         initBoundSelfParam( elem.params, elem._main );
 
       // for a correct home path, setMemberParent needed to be called
 
-      if (!elem.value || elem.kind !== 'element' ||
-          elem.$syntax === 'enum' && parent.kind === 'extend') // ambiguous in parse-cdl
+      if (!elem.value || elem.kind !== 'element')
         return;
+      // remark: potential enum elements have already been turned into enums
       // -> it's a calculated element
       if (!elem.type && elem.value?.type) {  // top-level CAST( expr AS type )
         if (!elem.target)
@@ -1469,47 +1524,13 @@ function extend( model ) {
 
   // includes ----------------------------------------------------------------
 
-  /**
-   * Returns true, if `art.includes` can be applied on `target`.
-   * They can't be applied if any of the artifacts referenced in
-   * `art.includes` are yet to be extended.
-   * `art !== target` if `art` is an extension.
-   *
-   * @param {XSN.Definition} art
-   * @param {XSN.Artifact} target
-   * @param {string[]} [cyclicIncludeNames]
-   * @returns {boolean}
-   */
-  function canApplyIncludes( art, target, cyclicIncludeNames ) {
-    if (!art.includes)
-      return true;
-    for (const ref of art.includes) {
-      const name = resolveUncheckedPath( ref, 'include', art );
-      // console.log('CAI:',cyclicIncludeNames, name, ref.path, Object.keys(extensionsDict))
-      if (cyclicIncludeNames) {
-        if (!cyclicIncludeNames.includes( name ))
-          continue;
-        delete ref._artifact;
-      }
-      else if (name && name in extensionsDict) {
-        // one of the includes has itself extensions that need to be applied first
-        return false;
-      }
-      else if (ref._artifact) {
-        delete ref._artifact;
-      }
-    }
-    return true;
-  }
-
   /**
    * Apply all includes of `ext` on `ext`.  Checks that `art` allows includes.
    * If `ext === art`, then includes of the artifact itself are applied.
    * If `ext !== art`, applies includes on the extensions, not artifact.
-   * Sets `_ancestors` links on `art`.
-   *
-   * TODO: try to set `_ancestors` only to entities (but beware “intermediate”
-   * non-entities - TODO: make intermediate non-entities stop chain).
+
+   * Sets `_ancestors` links on `art` if it is an entity, collecting the entity
+   * includes with their ancestors.
    *
    * Examples:
    *   ext === art:  `entity E : F {}`  => add elements of F to E
@@ -1518,25 +1539,24 @@ function extend( model ) {
    * @param {XSN.Extension} ext
    * @param {XSN.Artifact} art
    */
+  function setEntityIncludes( ext, art ) {
+    setLink( art, '_entityIncludes', [] );
+    for (const ref of ext.includes) {
+      const name = resolveUncheckedPath( ref, 'include', ext );
+      const template = name && model.definitions[name];
+      if (template?.kind === 'entity')
+        art._entityIncludes.push( template );
+    }
+  }
+
   function applyIncludes( ext, art ) {
     if (kindProperties[art.kind].include !== true) {
       error( 'extend-unexpected-include', [ ext.includes[0]?.location, ext ],
              { meta: art.kind } );
       return;
     }
-
-    if (!art._ancestors && !art.query)
-      setLink( art, '_ancestors', [] ); // recursive array of includes
-    const shouldSetAncestors = art.kind === 'entity' && !art.query;
-    for (const ref of ext.includes) {
-      const template = resolvePath( ref, 'include', art );
-      // !template -> non-includable, e.g. scalar type, or cyclic
-      if (template?.kind === 'entity' && shouldSetAncestors) {
-        if (template._ancestors)
-          art._ancestors.push( ...template._ancestors );
-        art._ancestors.push( template );
-      }
-    }
+    // console.log( (ext===art?'D-INCL:':'E-INCL:'), art.kind, art.name.id,
+    //              ...ext.includes.map( r => r._artifact?.name.id ));
     if (!art.query && art.elements) // do not set art.elements and art.enums with query entity!
       includeMembers( ext, art, 'elements' );
     if (art.kind !== 'type') {
@@ -1567,6 +1587,7 @@ function extend( model ) {
     // Warning 'Overwrites definition from include "I" (at elem def)
     const parent = ext === art && art;
     const members = ext[prop];
+    // if (members)console.log( 'EXT:', prop, art.kind, art.name.id, ...Object.keys(members));
     if (members) {
       ext[prop] = Object.create( null );
       ext[prop][$location] = members[$location];
@@ -1609,7 +1630,8 @@ function extend( model ) {
             // TODO: If paths become invalid in the new artifact, should we mark
             //       all usages in the expressions? Possibly just the first one?
             // TODO: Unify with other code in extend.js
-            elem.value = Object.assign( { $inferred: 'include' }, copyExpr( origin.value ));
+            elem.value = Object.assign( { $inferred: 'include' },
+                                        copyExpr( origin.value, location, true ) );
             elem.$syntax = 'calc';
             createAndLinkCalcDepElement( elem );
             setLink( elem, '_calcOrigin', origin._calcOrigin || origin );
@@ -1640,17 +1662,21 @@ function extend( model ) {
    * contain elements `texts` and `localized` which are compiler-generated for
    * localized data.  Due to recompilation, we cannot just check the `$inferred`
    * property in the XSN, but need to apply an heuristics.
+   * (We could still use $inferred as speed-up if run without `testMode`.)
    *
    * It is as follows: the elements `texts` and `localized` in entity `‹E›` and
    * the entity `‹E›.texts` are considered compiler-generated for Localized Data if
    *
    *  - `‹E›.texts` has a key element `locale`
+   *    (TODO: currently weakend to “entity exists”)
    *  - `texts` of `‹E›` is an unmanaged composition to `‹E›.texts`
    *  - `localized` of `‹E›` is an unmanaged association to `‹E›.texts`
    */
   function withLocalizedData( { name, elements }, ext ) {
     const textsEntityName = `${ name.id }.texts`;
-    if (!model.definitions[textsEntityName]?.elements?.locale?.key?.val)
+    // if we test (again) for element `locale` - it might come from an extend or
+    // TextsAspect include, which might not have yet applied
+    if (!model.definitions[textsEntityName])
       return false;
     const { texts, localized } = elements ?? {};
     return texts?.target && localized?.target && texts.on && localized.on &&
@@ -1791,5 +1817,11 @@ function propagateEarly( art, prop ) {
   }
 }
 
+function pushTo$add( extensions, ext ) {
+  if (!extensions.$add)
+    extensions.$add = [ ext ];
+  else if (extensions.$add.at( -1 ) !== ext)
+    extensions.$add.push( ext );
+}
 
 module.exports = extend;