@sap/cds-dk 9.9.2 → 10.0.3

package/node_modules/@sap/cds-compiler/lib/compiler/extend.js

@@ -0,0 +1,1928 @@
+// Extend
+
+'use strict';
+
+const { weakRefLocation } = require('../base/location');
+const { searchName } = require('../base/messages');
+const { dictAdd, pushToDict, dictForEach } = require('./dictionaries');
+const { kindProperties, dictKinds } = require('./base');
+const {
+  setLink,
+  setArtifactLink,
+  copyExpr,
+  setExpandStatus,
+  linkToOrigin,
+  initItemsLinks,
+  setMemberParent,
+  createAndLinkCalcDepElement,
+  initExprAnnoBlock,
+  initBoundSelfParam,
+  dependsOnSilent,
+  pathName,
+  annotationHasEllipsis,
+  forEachInOrder,
+  forEachDefinition,
+  forEachMember,
+  forEachGeneric,
+  isDirectComposition,
+  targetCantBeAspect,
+} = require('./utils');
+const layers = require('./moduleLayers');
+const { CompilerAssertion } = require('../base/error');
+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 v7
+const genLocation = new Location( '' );
+
+const draftElements = [
+  'IsActiveEntity',
+  'HasActiveEntity',
+  'HasDraftEntity',
+  'DraftAdministrativeData',
+  'SiblingEntity',
+];
+const draftBoundActions = [
+  'draftPrepare',
+  'draftActivate',
+  'draftEdit',
+];
+
+function canBeDraftMember( name, parent, draftMembers ) {
+  return parent?.kind === 'entity' && parent._service && draftMembers.includes( name );
+}
+
+function extend( model ) {
+  // Get simplified "resolve" functionality and the message function:
+  const {
+    message, error, warning, info,
+  } = model.$messageFunctions;
+  const {
+    resolvePath,
+    resolveUncheckedPath,
+    resolveTypeArgumentsUnchecked,
+    resolveDefinitionName,
+    attachAndEmitValidNames,
+    checkRedefinition,
+  } = model.$functions;
+
+  Object.assign( model.$functions, {
+    createRemainingAnnotateStatements,
+    extendArtifactBefore,
+    extendArtifactAfter,
+    extendArtifactAdd,
+    extendForeignKeys,
+    withLocalizedData,
+    applyIncludes,              // TODO: re-check
+  } );
+
+  const includeCollisions = [];
+
+  forEachGeneric( model, 'definitions', tagCompositionTargets );
+  dictForEach( model.$collectedExtensions, e => e._extensions.forEach( tagCompositionTargets ) );
+  // remark: tagging on extensions works _before_ running extendArtifactBefore() on each artifact
+  sortModelSources();
+
+  // 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 );
+  return;
+
+  // 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
+  //-----------------------------------------------------------------------------
+  // extendArtifactBefore, extendArtifactAfter, createRemainingAnnotateStatements,
+  // extendForeignKeys
+
+  /**
+   * Goes through all (applied) annotations in the given artifact and chooses one
+   * 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 ) {
+    // for main artifacts, move extensions from `$collectedExtensions` model dictionary:
+    if (!art._main && !art._outer && art._extensions === undefined &&
+        art.name && // TODO: probably just a workaround, check with TODO in getOriginRaw()
+        art.kind !== 'namespace') {
+      const { id } = art.name;
+      setLink( art, '_extensions', model.$collectedExtensions[id]?._extensions || null );
+      if (art._extensions && !art.builtin) { // keep extensions for builtin in $collectedExtensions
+        delete model.$collectedExtensions[id];
+        // TODO: if the extension mechanism has been completed, we could uncomment:
+        // art._extensions.forEach( ext => resolvePath( ext.name, ext.kind, ext )); // for LSP
+        // 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)
+      // With extensions, member appears in CSN, affects directly the rendering of
+      // elements etc.  TODO: do that more specifically on the dicts (via symbol)
+      // Probably better: we could use the _extensions dict prop directly in to-csn
+      if (art.$inferred)
+        setExpandStatus( art, 'annotate' );
+      if (Array.isArray( art._extensions )) {
+        checkExtensionsKind( art._extensions, art );
+        transformArtifactExtensions( 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
+            // TODO: what is the `$gen`?  `$add` is handled...
+            ![ 'elements', 'actions', 'params', '$gen' ].includes( prop ))
+          applyPropertyExtensions( art, prop );
+      }
+    }
+  }
+
+  /**
+   * 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)         // builtin members handled via "super annotate"
+      return;
+    // type extensions after having “populated” the artifact ($typeArgs -> length,
+    // …, TODO: do that there) and setting an _effectiveType:
+    if (art.$typeExts) {
+      const { type } = art;     // if the type is not inferred, it is the origin...
+      if (type?._artifact && !type.$inferred) // ...and thus is resolved
+        resolveTypeArgumentsUnchecked( art, type._artifact, art );
+      const exts = art.$typeExts;
+      applyTypeExtensions( art, exts.length, 'length' );
+      const scaleDiff = applyTypeExtensions( art, exts.scale, 'scale' );
+      applyTypeExtensions( art, exts.precision, 'precision', scaleDiff );
+      applyTypeExtensions( art, exts.srid, 'srid' );
+      checkPrecisionScaleExtension( art, exts );
+
+      delete art.$typeExts;
+    }
+
+    moveDictExtensions( art, extensionsMap, 'actions' );
+    moveDictExtensions( art, extensionsMap, 'params' );
+    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)?
+    }
+    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'), false );
+    }
+  }
+
+  /**
+   * Apply foreign key extensions.  Because foreign keys are handled late in the compiler
+   * (in tweak-assocs.js), we can't apply them in effectiveType(), yet.
+   * Instead, we postpone applying them until all foreign keys were generated.
+   *
+   * @param art
+   */
+  function extendForeignKeys( art ) {
+    // See extendArtifactAfter() for targetAspect/items handling.
+    if (!art._extensions || art.items || art.targetAspect?.elements)
+      return;
+
+    // push down foreign keys
+    moveDictExtensions( art, art._extensions, 'foreignKeys', 'elements' );
+    if (!art.foreignKeys)
+      return;
+
+    forEachGeneric(art, 'foreignKeys', (key) => {
+      if (!key._effectiveType)
+        throw new CompilerAssertion('foreign key should have been processed');
+      extendArtifactBefore( key );
+      extendArtifactAfter( key );
+    });
+  }
+
+  /**
+   * Applying extensions is handled in extendArtifactAfter(). And only afterward,
+   * an effective sequence number is set.  Meaning that if a sub artifact already
+   * has a sequence number, then extensions would be lost.
+   *
+   * A special case are foreign keys, see extendForeignKeys().
+   */
+  function ensureArtifactNotProcessed( art ) {
+    if (!model.options.testMode)
+      return;
+
+    if (art.kind !== 'key' && art.$effectiveSeqNo !== 0 && art.$effectiveSeqNo !== undefined) {
+      // if the artifact already has a sequence number, then
+      // extendArtifactAfter() was already called -> annotations would be lost.
+      throw new CompilerAssertion('artifact already processed; extensions would be lost');
+    }
+  }
+
+  /**
+   * Create super annotate statements for remaining extensions
+   */
+  function createRemainingAnnotateStatements() {
+    model.extensions = Object.values( model.$collectedExtensions );
+    // TODO: testMode sort?
+    model.extensions.forEach( createSuperAnnotate );
+    // set _artifact links for “main extensions” late as it would disturb the
+    // still existing old extend mechanism, see extendArtifactBefore(),
+    // needed for LSP and friends:
+    Object.values( model.sources ).forEach( setArtifactLinkForExtensions );
+    Object.values( model.definitions ).forEach( setArtifactLinkForExtensions );
+  }
+
+  // TODO: delete again - if not, what about extensions in contexts/services?
+  //       Check test.lsp-api.js! Links in extensions are needed.
+  function setArtifactLinkForExtensions( source ) {
+    if (!source.extensions)
+      return;
+    for (const ext of source.extensions) {
+      if (!ext.name?.id)
+        continue;
+
+      const { name } = ext;
+      const { path } = name;
+      if (name._artifact === undefined) {
+        resolvePath( name, ext.kind, ext ); // induce error & for LSP
+      }
+      else if (model.options.lspMode && path?.[0]._artifact === undefined) {
+        // we don't use resolvePath(…,'extend'), as that would add a dependency
+        resolveDefinitionName( ext );
+        setArtifactLink( path[path.length - 1], name._artifact );
+      }
+    }
+  }
+
+  // For extendArtifactBefore(): ------------------------------------------------
+
+  /**
+   * Complain about invalid `extend service` and `extend context`.
+   */
+  function checkExtensionsKind( extensions, art ) {
+    for (const ext of extensions) {
+      const kind = ext.expectedKind?.val;
+      if (kind && kind !== art.kind) {
+        const loc = ext.expectedKind.location;
+        if (kind === 'context' || kind === 'service') {
+          // We have no real artifact during the construction of a super-annotate statement:
+          const msgArgs = {
+            '#': (art.kind === 'service' || art.kind === 'annotate') ? art.kind : 'std',
+            art,
+            kind,
+            code: 'extend … with definitions',
+            keyword: 'extend service',
+          };
+          // 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',
+            // do not mention 'extend context', that is not in CAPire
+            service: 'Artifact $(ART) is not of kind $(KIND), use $(CODE) or $(KEYWORD) instead',
+          } );
+        }
+        // TODO: Use similar checks for EXTEND ENTITY etc - 'ext-ignoring-kind'
+      }
+    }
+  }
+
+  /**
+   * 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 ) {
+    // 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 (!Object.hasOwn( ext, prop ) || ext[prop] === undefined) // deleted property
+          continue;
+        // TODO: do this check nicer (after complete move to new extensions mechanism)
+        if (prop === 'includes') {
+          pushToDict( dict, prop, ext );
+          pushTo$add( dict, ext );
+        }
+        else if (prop.charAt(0) === '@' || prop === 'doc' || prop === 'columns' ||
+                 prop === 'groupBy' || prop === 'where' || prop === 'having' ||
+                 prop === 'orderBy' || prop === 'limit' || prop === 'length' ||
+                 prop === 'scale' || prop === 'precision' || prop === 'srid') {
+          if (!isAutoItemsOrReturns)
+            pushToDict( dict, prop, 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 );
+          if (hasSecurityAnno( ext.returns ))
+            checkReturnsExtension( ext, 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 );
+        }
+      }
+    }
+    art._extensions = dict;
+  }
+
+  /**
+   * Sort sources according to the reversed layered extension order without
+   * reporting any messages.
+   *
+   * The order of the CSN property `$sources` (from XSN `_sortedSources`) is
+   * defined as follows: for _any_ model
+   *
+   *  - add `type $Sources: String @(Names: []);` to one of the source files
+   *  - add `annotate $Sources with @Names: [..., ‹sourceName›]` to each source
+   *    file where ‹sourceName› is the file name of the source
+   *  - then the array value of `‹csn›.$sources` is the reverse of the array value
+   *    of `‹csn›.definitions.$Sources.@Names`
+   */
+  function sortModelSources() {
+    const scheduled = [];
+    const layered = layeredExtensions( Object.values( model.sources ) );
+    for (;;) {
+      const { highest } = extensionsOfHighestLayers( layered );
+      if (!highest.length)
+        break;
+      highest.reverse();
+      scheduled.push( ...highest );
+    }
+    setLink( model, '_sortedSources', scheduled );
+  }
+
+  /**
+   * 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;
+    // 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();
+    art.$postponeInclude ??= 0; // add elems of includes before direct ones
+    if (prop === 'includes' && !art.includes?.$original) {
+      const $original = art.includes ?? [];
+      art.includes = [ ...$original ];
+      art.includes.$original = $original;
+      // console.log('APE:',art.name.id,art.includes.map( r => r._artifact?.name.id ))
+    }
+    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 ) {
+    return (prop.charAt(0) !== '@')
+      ? (prop === 'doc' || typeParameters.list.includes(prop))
+      : !annotationHasEllipsis( ext[prop] );
+  }
+
+  // TODO: still a bit annotation assignment specific
+  function reportDuplicateExtensions( extensions, prop, issue, index, art ) {
+    // TODO: think about messages for these
+    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)
+        ? 'anno-unstable-array'
+        : (issue === true)
+          ? 'anno-duplicate'
+          : 'anno-duplicate-unrelated-layer';
+      if (prop.charAt(0) !== '@' && prop !== 'doc') {
+        msg = (issue === true)
+          ? 'ext-duplicate-extend-type'
+          : '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) {
+        const anno = ext[prop];
+        if (anno && !anno.$errorReported) {
+          message( msg, [ anno.name?.location || anno.location, ext ],
+                   { '#': variant, anno: prop, type: art } );
+        }
+      }
+    }
+    else if (index > 0) {     // more than one set (not just ...)
+      const variant = prop === 'doc' ? 'doc' : 'std';
+      const msgid = (prop.charAt(0) === '@' || prop === 'doc')
+        ? 'anno-duplicate-same-file' // TODO: always ext-duplicate-…
+        : 'ext-duplicate-same-file';
+      while (index >= 0) {    // do not report for trailing [...]
+        const ext = extensions[index--];
+        const anno = ext[prop];
+        warning( msgid, [ anno.name?.location || anno.location, ext ],
+                 { '#': variant, prop, anno: prop } );
+      }
+    }
+  }
+
+  function applySingleExtension( art, ext, prop ) {
+    if (prop === 'includes') {
+      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];
+    }
+    else if (prop === 'columns') {
+      const { query } = art;
+      for (const col of ext.columns)
+        col.$extended = 'columns';
+
+      if (art.kind === 'annotate' && art.$inferred === '')
+        return; // internal super-annotate for unknown artifacts
+
+      if (!query?.from?.path) {
+        const variant = (query?.from || query)?.op?.val || 'std';
+        error( 'extend-columns', [ ext.columns[$location], ext ], { '#': variant, art } );
+        return;
+      }
+      if (!query.columns)
+        query.columns = [ { location: query.from.location, val: '*' }, ...ext.columns ];
+      else
+        query.columns.push( ...ext.columns );
+      ext.columns.forEach( col => changeParentLinks( col, query ) );
+    }
+    else if (prop === 'groupBy' || prop === 'where' || prop === 'having' ||
+             prop === 'orderBy' || prop === 'limit') {
+      applyQueryClause( prop, ext, art );
+    }
+    else if (typeParameters.list.includes( prop )) {
+      const typeExts = art.$typeExts || (art.$typeExts = {});
+      typeExts[prop] = ext;
+    }
+    else {
+      const result = applyAssignment( art[prop], ext[prop], ext, prop );
+      art[prop] = (result.name) ? result : Object.assign( {}, art[prop], result );
+    }
+  }
+
+  function applyQueryClause( prop, ext, art ) {
+    const { query } = art;
+    const clause = ext[prop];
+    const isArray = Array.isArray( clause );
+
+    if (prop !== 'limit') {
+      const items = isArray ? clause : [ clause ];
+      for (const item of items) {
+        item.$extended = prop;
+        setLink( item, '_block', ext._block );
+        setLink( item, '_outer', query );
+      }
+    }
+    if (!query?.from?.path) {
+      const variant = (query?.from || query)?.op?.val || 'std';
+      const loc = isArray ? clause[$location] : clause.location;
+      error( `extend-${ prop.toLowerCase() }`, [ loc, ext ], { '#': variant, art } );
+      return;
+    }
+    if (isArray) {
+      if (!query[prop])
+        query[prop] = [];
+      query[prop].push( ...clause );
+    }
+    else {
+      if (query[prop]) {
+        error( 'ext-unexpected-sql-clause', [ clause.location, ext ], { art, keyword: prop } );
+        return;
+      }
+      query[prop] = clause;
+    }
+  }
+
+  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)
+      return anno;
+    const hasBase = previousAnno?.literal === 'array';
+    if (!previousAnno) {
+      const { location } = anno.name;
+      if (annoName !== '@extension.code') {
+        // Remark: we could allow that for all annotations which are not propagated
+        message( 'anno-unexpected-ellipsis', [ firstEllipsis.location || location, art ],
+                 { code: '...' } );
+      }
+      previousAnno = {
+        kind: '$annotation',
+        val: [],
+        literal: 'array',
+        name: anno.name,
+        location,
+      };
+    }
+    else if (previousAnno.literal !== 'array') {
+      // TODO: If we introduce sub-messages, point to the non-array base value.
+      error( 'anno-mismatched-ellipsis', [ anno.name.location, art ], { code: '...' } );
+      previousAnno = {
+        kind: '$annotation',
+        val: [],
+        literal: 'array',
+        name: previousAnno.name,
+        location: previousAnno.location,
+      };
+    }
+    const previousValue = previousAnno.val;
+    let prevPos = 0;
+    const result = [];
+    for (const item of anno.val) {
+      const ell = item && item.literal === 'token' && item.val === '...';
+      if (!ell) {
+        result.push( item );
+      }
+      else {
+        let upToSpec = !item.$errorReported && item.upTo;
+        while (prevPos < previousValue.length) {
+          const prevItem = previousValue[prevPos++];
+          result.push( prevItem );
+          if (upToSpec && prevItem && equalUpTo( prevItem, item.upTo )) {
+            upToSpec = false;
+            break;
+          }
+        }
+        if (upToSpec && hasBase) {
+          // non-matched UP TO; if there is no base to apply to, there is already an error.
+          warning( null, [ item.upTo.location, art ], { anno: annoName, code: '... up to' },
+                   'The $(CODE) value does not match any item in the base annotation $(ANNO)' );
+        }
+      }
+    }
+    // console.log('TP:',previousValue.map(se),anno.val.map(se),'->',result.map(se))
+    return {
+      kind: '$annotation',
+      val: result,
+      literal: 'array',
+      name: previousAnno.name,
+      location: previousAnno.location,
+    };
+  }
+
+  // For the `up to` specification, see ../../test3/Annotations/EllipsisUpTo/
+
+  function equalUpTo( previousItem, upToSpec ) {
+    if (!previousItem)
+      return false;
+
+    if (upToSpec.sym)           // enum symbol (literal: 'enum')
+      return previousItem.sym?.id === upToSpec.sym.id;
+    if (upToSpec.val !== undefined) {        // not struct, ref or non-val expression
+      if (previousItem.val === upToSpec.val) // enum, struct and ref have no val
+        return true;
+      const upToVal = upToSpec.val;
+      const prevVal = previousItem.val;
+      // eslint-disable-next-line eqeqeq
+      return prevVal == upToVal &&
+        ( typeof upToVal === 'number' && stringCouldHaveBeenCdlNumber( prevVal ) ||
+          typeof prevVal === 'number' && stringCouldHaveBeenCdlNumber( upToVal ) );
+    }
+
+    if (upToSpec.path) {
+      // console.log(upToSpec.location+'',normalizeRef( upToSpec ),previousItem.struct?.['='])
+      return (previousItem.path)
+        ? normalizeRef( upToSpec ) === normalizeRef( previousItem )
+        : normalizeRef( upToSpec ) === previousItem.struct?.['=']?.val &&
+          (!upToSpec.$tokenTexts || Object.keys( previousItem.struct ).length === 1);
+    }
+    if (!upToSpec.struct)
+      return false;
+
+    const { struct } = previousItem;
+    if (struct) {
+      const entries = Object.entries( upToSpec.struct );
+      // {} does not match { "=": "ref" }, but { prop: … } and { "=": "ref", more: … }
+      return (entries.length)
+        ? entries.every( ([ n, v ]) => equalUpTo( previousItem.struct[n], v ) )
+        : !struct['='] || Object.keys( struct ).length > 1;
+    }
+    return previousItem.path && Object.keys( upToSpec.struct ).length === 1 &&
+      normalizeRef( previousItem ) === upToSpec.struct['=']?.val;
+  }
+
+  // We only compare a string by number if the string is not empty, and could have
+  // been produced for a CDL number by (a previous version of) the compiler,
+  // i.e. having used a decimal dot, or using the scientific notation:
+  function stringCouldHaveBeenCdlNumber( val ) { // also consider previous compiler versions
+    return val && typeof val === 'string' && /[.eE]/.test( val );
+    // We do not use `!Number.isSafeInteger( Number.parseFloat( text||'0' )`
+    // because it is unlikely that people have written a non-integer like this,
+    // more likely is meant a digit-sequence as string
+  }
+
+  function normalizeRef( node ) { // see to-csn.js
+    const ref = pathName( node.path );
+    // TODO XSN 7.1: get rid of name.variant (induces a wrong structure anyway)
+    return node.variant ? `${ ref }#${ pathName( node.variant.path ) }` : ref;
+  }
+
+  // For extendArtifactAfter(): -------------------------------------------------
+
+  // Remarks on messages: we allow the type extensions only if the artifact
+  // originally had that property → any check of the kind “type prop can only be
+  // used with FooBar” is independent from `extend … with type`.  Function
+  // checkTypeArguments() in resolve.js reports 'type-unexpected-argument', but
+  // that is currently incomplete.
+  //
+  // We then report (in the future), use the first message of:
+  // - the usual messages if a type argument is wrong, independently from `extend`
+  // - 'ext-unexpected-type-argument' (TODO) if the artifact does not have the prop
+  // - 'ext-invalid-type-argument' if the value is wrong for extend (no overwrite)
+  //
+  // TODO v6: do not allow `extend … with (precision: …)` alone if original def also has `scale`
+  function applyTypeExtensions( art, ext, prop, scaleDiff ) {
+    // console.log('ATE:',art?.[prop],ext?.[prop],scaleDiff)
+    if (!ext?.[prop])
+      return 0;
+    if (!art[prop]) {
+      const isBuiltin = art._effectiveType?.builtin;
+      if (isBuiltin && !allowsTypeArgument( art, prop )) {
+        // Let checkTypeArguments() in resolve.js report a message, is incomplete
+        // though, i.e. can only safely be used for scalars at the moment.  But we
+        // will improve that function and not try to do extra things here.
+        art[prop] = ext[prop];  // enable checkTypeArguments() doing its job
+        return 0;
+      }
+      // TODO: think about 'ext-unexpected-type-argument'
+      error( 'ext-invalid-type-property', [ ext[prop].location, ext ],
+             { '#': (isBuiltin ? 'indirect' : 'new-prop'), prop } );
+      return 0;
+    }
+    const artVal = art[prop].val;
+    const extVal = ext[prop].val;
+    if (prop === 'srid') {
+      error( 'ext-invalid-type-property', [ ext[prop].location, ext ], { '#': 'prop', prop } );
+    }
+    else if (typeof artVal !== 'number' || typeof extVal !== 'number' ) {
+      // Users can't change from/to string value for property,
+      // e.g. `variable`/`floating` for Decimal
+      // TODO: Shouldn't the text distinguish between orig string and extension string?
+      // Not sure whether to talk about strings if we have a keyword in CDL
+      error( 'ext-invalid-type-property', [ ext[prop].location, ext ], { '#': 'string', prop } );
+    }
+    else if (extVal < artVal + (scaleDiff || 0)) {
+      const number = artVal + (scaleDiff || 0);
+      error( 'ext-invalid-type-property', [ ext[prop].location, ext ], {
+        '#': (scaleDiff ? 'scale' : 'number'), prop, number, otherprop: 'scale',
+      } );
+    }
+    else {
+      art[prop] = ext[prop];
+      return extVal - artVal;
+    }
+    return 0;
+  }
+
+  /**
+   * 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) {
+        error( 'ext-missing-type-property', [ exts.precision.location, exts.precision ],
+               { art, prop: 'precision', otherprop: 'scale' } );
+      }
+    }
+  }
+
+  function allowsTypeArgument( art, prop ) {
+    const { parameters } = art._effectiveType;
+    if (!parameters)
+      return false;
+    return parameters.includes( prop ) || parameters[0]?.name === prop;
+  }
+
+  function moveDictExtensions( art, extensionsMap, artProp, extProp = artProp ) {
+    // TODO: setExpandStatus
+    const extensions = extensionsMap[extProp || 'elements'];
+    if (!extensions)
+      return;
+
+    for (const ext of extensions) {
+      forEachGeneric( ext, extProp || (ext.enum ? 'enum' : 'elements'), ( elemExt, name ) => {
+        if (elemExt.kind !== 'annotate' && elemExt.kind !== 'extend') // TODO: specified elems
+          return;             // definitions inside extend, already handled
+        checkRemainingMemberExtensions( art, elemExt, artProp, name );
+        const elem = art[artProp]?.[name] || annotateFor( art, extProp || 'elements', name );
+        setLink( elemExt.name, '_artifact', (elem.kind !== 'annotate' ? elem : null ) );
+        // TODO: why null for annotate?
+        ensureArtifactNotProcessed( elem );
+        if (elem.$duplicates !== true) // TODO: re-check
+          pushToDict( elem, '_extensions', elemExt );
+      });
+    }
+  }
+
+  function annotateFor( art, prop, name ) {
+    const base = annotateBase( art );
+    if (name === '' && prop === 'params')
+      return base.returns || annotateCreate( base, name, base, 'returns' );
+    const dict = base[prop] || (base[prop] = Object.create( null ));
+    if (name == null)
+      return dict;
+    return dict[name] || annotateCreate( dict, name, base );
+  }
+
+  function annotateBase( art ) {
+    while (art._outer)          // TODO: think about anonymous target aspect
+      art = art._outer;
+    if (art.kind === 'annotate')
+      return art;
+
+    // TODO: more to do if annotate can have `returns` property
+    if (art.kind === 'select')
+      art = art._parent;
+    if (art._main)
+      return annotateFor( art._parent, kindProperties[art.kind].dict, art.name.id );
+
+    const { id } = art.name;
+    return model.$collectedExtensions[id] ||
+           annotateCreate( model.$collectedExtensions, id );
+  }
+
+  function annotateCreate( dict, id, parent, prop ) {
+    const annotate = {
+      kind: 'annotate',
+      name: { id, location: genLocation },
+      $inferred: '',
+      location: genLocation,
+    };
+    if (parent) {
+      setLink( annotate, '_parent', parent );
+      setLink( annotate, '_main', parent._main || parent );
+    }
+    dict[prop || id] = annotate;
+    return annotate;
+  }
+
+  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' } );
+    // 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 ) {
+    // console.log('CRME:',prop,name,parent,ext)
+
+    // TODO: just use `ext-undefined-element` etc also when no elements are there
+    // at all (but use an extra text variant and the `{…}` location).  Reason: we
+    // might allow to add new actions, and an `annotate` on an undefined action
+    // should not lead to another message id.  We would use and extra message id
+    // if we consider this an error or such sub annotates are then ignored
+    // (i.e. not put into the "super annotate").
+    const dict = parent[prop];
+    const securityRelevant = hasSecurityAnno( ext ) ? '-sec' : '';
+    const inSuperAnnotate = (parent.kind === 'annotate');
+    if (!dict && !securityRelevant) {
+      if (inSuperAnnotate)      // no check in super annotate statement
+        return;
+      // TODO: check - for each name? - better locations
+      const location = ext._parent?.[prop]?.[$location] || ext.name.location;
+      // Remark: no `elements` dict location with `annotate Main:elem`
+      switch (prop) {
+        // TODO: change texts, somehow similar to checkDefinitions() ?
+        case 'foreignKeys':
+        case 'elements':
+        case 'enum':            // TODO: extra?
+          warning( 'anno-unexpected-elements', [ location, ext._parent ],
+                   { '#': (parent._effectiveType?.kind === 'entity') ? 'entity' : 'std' }, {
+                     std: 'Elements only exist in entities, types or typed constructs',
+                     entity: 'Elements of entity types can\'t be annotated',
+                     // TODO: extra msg for 'entity'? → this is some other
+                     // situation, somehow similar when trying to annotate elements
+                     // of target entity
+                   } );
+          break;
+        case 'params':
+          warning( 'anno-unexpected-params', [ location, ext._parent ], {},
+                   'Parameters only exist for actions or functions' );
+          break;
+        case 'actions':
+          if (canBeDraftMember( name, parent, draftBoundActions ))
+            return;
+          // TODO: use extra text variant and location of dictionary - no
+          notFound( 'ext-undefined-action', ext.name.location, ext,
+                    { '#': 'action', art: parent, name } );
+          break;
+        default:
+          if (model.options.testMode)
+            throw new CompilerAssertion(`Missing case for prop: ${ prop }`);
+      }
+    }
+    else if (!dict?.[name]) {
+      if (inSuperAnnotate && !securityRelevant)
+        return;       // there was already a warning for the parent
+      // TODO: make variant `returns` an auto-variant for ($ART) ?
+      const inReturns = parent._parent?.returns;
+      switch (prop) {
+        case 'elements':
+          if (canBeDraftMember( name, parent, draftElements ))
+            break;
+          notFound( `ext-undefined-element${ securityRelevant }`, ext.name.location, ext,
+                    { '#': (inReturns ? 'returns' : 'element'), name },
+                    parent.elements );
+          break;
+        case 'enum':            // TODO: extra msg id?
+          notFound( `ext-undefined-element${ securityRelevant }`, ext.name.location, ext,
+                    { '#': (inReturns ? 'enum-returns' : 'enum'), name },
+                    parent.enum );
+          break;
+        case 'foreignKeys':
+          notFound( `ext-undefined-key${ securityRelevant }`, ext.name.location, ext,
+                    { name }, parent.foreignKeys );
+          break;
+        case 'params':
+          notFound( `ext-undefined-param${ securityRelevant }`, ext.name.location, ext,
+                    { '#': 'param', name },
+                    parent.params );
+          break;
+        case 'actions':
+          if (canBeDraftMember( name, parent, draftBoundActions ))
+            break;
+          notFound( `ext-undefined-action${ securityRelevant }`, ext.name.location, ext,
+                    { '#': 'action', name },
+                    parent.actions );
+          break;
+        default:
+          if (model.options.testMode)
+            throw new CompilerAssertion(`Missing case for prop: ${ prop }`);
+      }
+    }
+  }
+
+  function notFound( msgId, location, address, args, validDict ) {
+    const msg = message( msgId, [ location, address ], args );
+    attachAndEmitValidNames( msg, validDict );
+  }
+
+  // For createRemainingAnnotateStatements(): -----------------------------------
+
+  function createSuperAnnotate( annotate ) {
+    const extensions = annotate._extensions;
+    if (extensions && !annotate._main) {
+      const art = model.definitions[annotate.name.id];
+      for (const ext of extensions)
+        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
+        // also shallow-copied to $collectedExtensions for to-csn
+        for (const prop in art) {
+          if (prop.charAt(0) === '@' || prop === 'doc')
+            annotate[prop] = art[prop];
+        }
+      }
+    }
+    if (extensions?.length === 1) { // i.e. no proper location if from more than one extension
+      annotate.location = extensions[0].location;
+      annotate.name.location = extensions[0].name.location;
+    }
+    extendArtifactBefore( annotate );
+    extendArtifactAfter( annotate );
+    forEachMember( annotate, createSuperAnnotate );
+  }
+
+  function hasSecurityAnno( ext ) {
+    return ext['@restrict'] || ext['@requires'] ||
+      Object.keys( ext ).some( prop => prop.startsWith( '@ams.' ) );
+  }
+
+  function checkRemainingMainExtensions( art, ext ) {
+    const refCtx = extensionRefContext( ext );
+    if (resolvePath( ext.name, refCtx, ext ) && art?.builtin) {
+      if (ext.kind === 'extend') {
+        // extending built-ins with elements/enums already gives an error
+        warning( 'ext-unexpected-builtin', [ ext.name.location, ext ], {}, // error v8?
+                 'Built-in types should not be extended' ); // keep the text general
+        const typeProp = typeParameters.list.find( p => ext[p] );
+        if (typeProp) {
+          const location = ext.$typeArgs?.[$location] || ext[typeProp].location;
+          message( 'ext-unexpected-type-property', [ location, ext ], {}, // error v7
+                   'Built-in types can\'t be extended with type properties' );
+          // see also 'ext-invalid-type-property'
+        }
+      }
+      else {
+        info( 'anno-builtin', [ ext.name.location, ext ], {} ); // TODO: better location?
+      }
+      // TODO: remove built-ins as CC candidates via accept property of ./shared.js
+    }
+  }
+
+  function extensionRefContext( ext ) {
+    if (ext.kind === 'annotate') {
+      if (hasSecurityAnno( ext ))
+        return 'annotate-sec';
+    }
+    else if (ext.artifacts ||   // extend … with definitions
+             ext._block.$frontend === 'json' && !ext.elements && !ext.actions) {
+      // TODO: not for `extend context` and `extend service` → !ext.expectedKind
+      // TODO v7: also fully with CSN input
+      if (!ext.doc && !Object.keys( ext ).some( a => a.charAt(0) === '@') )
+        return 'annotate';      // TODO: or an extra refCtx ?
+    }
+    return ext.kind;
+  }
+
+  // Issue messages for annotations on namespaces and builtins
+  // (TODO: really here?, probably split main artifacts vs returns)
+  // see also createRemainingAnnotateStatements() where similar messages are reported
+  function checkAnnotate( construct, art ) {
+    // TODO: Handle extend statements properly: Different message for empty extend?
+
+    // --> without art._block, art not found
+    if (construct.kind === 'annotate' && art._block?.$frontend === 'cdl') {
+      if (construct.returns && art.kind !== 'action' && art.kind !== 'function' ) {
+        // See moveReturnsExtensions()
+      }
+      else if (!construct.returns &&
+          (art.kind === 'action' || art.kind === 'function') && construct.elements) {
+        warning( 'ext-expecting-returns', [ construct.name.location, construct ], {
+          '#': 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)',
+        } );
+      }
+    }
+  }
+
+  // extend, mainly old-style ---------------------------------------------------
+
+  function addedElements( art ) {
+    return Object.values( art.elements )
+      .reduce( ( acc, elem ) => (elem.kind === 'extend' ? acc : acc + 1), 0 );
+  }
+
+  /**
+   * Extend artifact with additional elements and actions: via includes and/or
+   * extensions.  This happens _after_ `populateArtifact`, i.e. after eventually
+   * having inferred the elements/... from an "origin".
+   */
+  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 ); // apply includes provided with definition
+      else if (art.elements)       // next include only after elements so far
+        art.$postponeInclude += addedElements( 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 ); // apply extensions
+    checkRedefinitionThroughIncludes( art, 'elements' );
+    checkRedefinitionThroughIncludes( art, 'actions' );
+  }
+
+  /**
+   * Extend artifact `art` by `extensions`.  `cyclicIncludeNames` can have values:
+   * - falsy: try to apply include, then perform extend and annotate
+   * - an array of include names with cyclic dependencies: includes are not applied,
+   *   extend and annotate is performed
+   *   remark: we could have applied includes without cycle
+   *
+   * Returns true if extend and annotate are performed.
+   *
+   * @param {XSN.Extension[]} extensions
+   * @param {XSN.Definition} art
+   * @param {String[]|false} [cyclicIncludeNames=false]
+   */
+  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
+    }
+    // TODO: complain if $inferred
+    // checkExtensionsKind( extensions, art );
+    extendMembers( extensions, art );
+    reportIncludeCollisions( art );
+    // TODO: complain about element extensions inside projection
+    return true;
+  }
+
+  function reportIncludeCollisions( art ) {
+    const grouped = Object.create( null );
+    for (const {
+      prop, name, existing, elem,
+    } of includeCollisions) {
+      const key = `${ prop }:${ name }`;
+      if (!grouped[key])
+        grouped[key] = { prop, name, collisions: new Set( [ existing ] ) };
+      grouped[key].collisions.add( elem );
+    }
+    for (const key in grouped) {
+      const { prop, name, collisions } = grouped[key];
+      const member = art[prop]?.[name];
+      if (member?.$inferred === 'include') {
+        const arts = [ ...collisions ].map( m => m._origin._main );
+        message( 'ext-duplicate-include', [ art.name.location, member ],
+                 { '#': prop, name, sorted_arts: arts } );
+      }
+    }
+    includeCollisions.length = 0;
+  }
+
+  function extendMembers( extensions, art ) {
+    // only called in extendArtifact()
+    // 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 );
+    // 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 === 'include') {
+        error( 'ref-expected-direct-structure', [ ext.name.location, ext ],
+               { '#': 'elements', art } );
+      }
+      else 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())
+      setArtifactLink( ext.name, art ); // TODO: probably already done
+      if (ext.includes)
+        applyIncludes( ext, art ); // moves included elem to extension(! TODO: recheck)
+      else if (ext.elements)
+        art.$postponeInclude += addedElements( ext );
+
+      // 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
+          elemExtensions.push( elem );
+          break;                // more than one elem in same EXTEND is fine
+        }
+      }
+    }
+    if (elemExtensions.length > 1)
+      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 );
+    // actions cannot be extended anyway. TODO: there should be a message
+    // (possible with CSN input), but that was missing before this change, too.
+    for (const e of extensions) {
+      if (!e.elements)
+        continue;
+      for (const n in e.elements) {
+        if (e.elements[n].kind === 'extend')
+          pushToDict( dict, n, e.elements[n] );
+      }
+    }
+    for (const name in dict) {
+      let obj = art;
+      if (obj.targetAspect)
+        obj = obj.targetAspect;
+      while (obj.items)
+        obj = obj.items;
+      const validDict = obj.elements || obj.enum;
+      const member = validDict && validDict[name];
+      if (!member)
+        extendNothing( dict[name], 'elements', name, art, validDict );
+    }
+  }
+
+  /**
+   * Report 'Warning: Unstable element order due to repeated extensions'
+   * except if all extensions are in the same file.
+   *
+   * @param {XSN.Extension[]} extensions
+   */
+  function reportUnstableExtensions( extensions ) {
+    // No message if all extensions are in the same file:
+    const file = layers.realname( extensions[0] );
+    if (extensions.every( ( ext, i ) => !i || file === layers.realname( ext ) ))
+      return;
+    // Similar to chooseAssignment(), TODO there: also extra intralayer message
+    // as this is a modeling error
+    let lastExt = null;
+    let open = [];              // the "highest" layers
+    for (const ext of extensions) {
+      const extLayer = layers.layer( ext ) ||
+          { realname: '', _layerExtends: Object.create( null ) };
+      if (!open.length) {
+        lastExt = ext;
+        open = [ extLayer.realname ];
+      }
+      else if (extLayer.realname === open[open.length - 1]) { // in same layer
+        if (lastExt) {
+          message( 'extend-repeated-intralayer', [ lastExt.location, lastExt ] );
+          lastExt = null;
+        }
+        message( 'extend-repeated-intralayer', [ ext.location, ext ] );
+      }
+      else {
+        if (lastExt && (open.length > 1 || !extLayer._layerExtends[open[0]])) {
+          // report for lastExt if that is unrelated to other open exts or current ext
+          message( 'extend-unrelated-layer', [ lastExt.location, lastExt ], {},
+                   'Unstable element order due to other extension in unrelated layer' );
+        }
+        lastExt = ext;
+        open = open.filter( name => !extLayer._layerExtends[name] );
+        open.push( extLayer.realname );
+      }
+    }
+  }
+
+
+  /**
+   * @param {XSN.Extension[]} extensions
+   * @param {string} prop
+   * @param {string} name
+   * @param {XSN.Artifact} art
+   * @param {object} validDict
+   */
+  function extendNothing( extensions, prop, name, art, validDict ) {
+    // TODO: probably too much magic in the creation of artName…
+    const extMain = { ...(art._main || art) };
+    const artName = searchName( art, name, dictKinds[prop] );
+    setLink( artName, '_main', extMain );
+    for (const ext of extensions) {
+      // TODO: use shared functionality with notFound in resolver.js
+      const { location } = ext.name;
+      extMain.kind = ext.kind;
+      const msg = error( 'extend-undefined', [ location, artName ], { art: artName }, {
+        std: 'Unknown $(ART) - nothing to extend',
+        element: 'Artifact $(ART) has no element or enum $(MEMBER) - nothing to extend',
+        action: 'Artifact $(ART) has no action $(MEMBER) - nothing to extend',
+      } );
+      attachAndEmitValidNames( msg, validDict );
+    }
+  }
+
+  // TODO TMP: copied from ./define.js: -----------------------------------------
+
+  /**
+   * Set property `_parent` for all elements in `parent` to `parent` and do so
+   * recursively for all sub elements.
+   *
+   * If `construct !== parent`, also copy elements to `parent`.
+   *
+   * (Only) if called recursively: `construct === parent`
+   *
+   * TODO: separate extension!
+   */
+  function initMembers( construct, parent, block ) {
+    // only called by extendMembers() and recursively
+    // TODO: split extend from init
+    const obj = initItemsLinks( construct, block );
+    initExprAnnoBlock( construct, block, error );
+    if (parent.targetAspect?.elements)
+      parent = parent.targetAspect;
+    const main = parent._main || parent;
+    const isQueryExtension = construct.kind === 'extend' && main.query;
+
+    if (obj !== parent && obj.elements && parent.enum) { // applying the extension
+      initElementsAsEnum();
+      if (parent.enum[$inferred])
+        setExpandStatus( parent, 'extend' );
+    }
+    else {
+      if (checkDefinitions( construct, parent, 'elements', obj.elements || false ))
+        forEachInOrder( obj, 'elements', init );
+      if (checkDefinitions( construct, parent, 'enum', obj.enum || false ))
+        forEachGeneric( obj, 'enum', init );
+    }
+
+    if (obj.foreignKeys)
+      forEachInOrder( obj, 'foreignKeys', init );
+    if (checkDefinitions( construct, parent, 'actions' ))
+      forEachGeneric( construct, 'actions', init );
+    if (checkDefinitions( construct, parent, 'params' ))
+      forEachInOrder( construct, 'params', init );
+    const { returns } = construct;
+    if (returns) {
+      const { kind } = construct;
+      returns.kind = (kind === 'extend' || kind === 'annotate') ? kind : 'param';
+      init( returns, '' );      // '' is special name for returns parameter
+    }
+    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;
+      for (const n in obj.elements) {
+        const e = obj.elements[n];
+        if (e.kind === 'extend')
+          continue;
+        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' },
+                 // eslint-disable-next-line @stylistic/max-len
+                 'Unexpected elements like $(NAME) in an extension for an enum. Additionally, use $(CODE) when extending enums' );
+          // Don't emit 'ext-expecting-enum' if this error is emitted.
+          return;
+        }
+        e.kind = 'enum';
+        hasElement = true;    // warning with CDL input or `name: {}` in CSN input
+      }
+      if (!parent.type || parent.type.$inferred || (parent._main || parent).query) {
+        error( 'extend-type', [ obj.elements[$location], construct ], {},
+               'Only structures or enum types can be extended with elements/enums' );
+      }
+      else if (hasElement) {
+        warning( 'ext-expecting-enum', [ obj.elements[$location], construct ],
+                 { code: 'extend … with enum' }, 'Use $(CODE) when extending enums' );
+      }
+      forEachGeneric( { enum: obj.elements }, 'enum', init );
+    }
+
+    function init( elem, name, prop ) {
+      if (!elem.name && !elem._outer) {
+        const ref = elem.targetElement || elem.kind === 'element' && elem.value;
+        if (ref && ref.path) {
+          elem.name = Object.assign( { $inferred: 'as' },
+                                     ref.path[ref.path.length - 1] );
+        }
+        else {                  // RETURNS, parser robustness
+          elem.name = { id: name, location: elem.location };
+        }
+      }
+
+      if (!elem._block)
+        setLink( elem, '_block', block );
+      // if (!kindProperties[ elem.kind ]) console.log(elem.kind,elem.name)
+      if ((elem.kind === 'extend' || elem.kind === 'annotate'))
+        return;
+
+      if (isQueryExtension && elem.kind === 'element') {
+        error( 'extend-query', [ elem.location, construct ], // TODO: searchName ?
+               { code: 'extend … with columns' },
+               'Use $(CODE) to add select items to the query entity' );
+        return;
+      }
+
+      const existing = parent[prop]?.[name];
+      const shadowsIncludeMember = construct !== parent &&
+        elem.$inferred !== 'include' &&
+        existing?.$inferred === 'include';
+      const add = construct !== parent && (!existing || elem.$inferred !== 'include');
+      if (!add && existing?.$inferred === 'include' && elem.$inferred === 'include') {
+        includeCollisions.push( {
+          prop, name, existing, elem,
+        } );
+      }
+      // don't dump with `entity T {}; extend T with { extend e {}; e {}; e {} };`:
+      const { $duplicates } = elem;
+      if ($duplicates === true && add)
+        elem.$duplicates = null;
+      if (add && elem.$inferred === 'include' && Array.isArray( $duplicates ))
+        elem.$duplicates = null;
+      if (shadowsIncludeMember) {
+        parent[prop][name] = elem;
+        setMemberParent( elem, name, parent );
+      }
+      else {
+        setMemberParent( elem, name, parent, add && prop );
+        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 (parent[prop]?.[$inferred])
+        setExpandStatus( parent, 'extend' );
+
+      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)
+          elem.type = { ...elem.value.type, $inferred: 'cast' };
+      }
+      elem.$syntax = 'calc';
+      // TODO: it is not just "syntax" - maybe better test for `$calcDepElement`?
+      createAndLinkCalcDepElement( elem );
+
+      // Special case (hack) for calculated elements that use composition+filter:
+      // See "Notes on `$enclosed`" in `ExposingAssocWithFilter.md` for details.
+      if (elem.target && elem.value.path?.[elem.value.path.length - 1]?.where) {
+        delete elem.type;
+        delete elem.on;
+        delete elem.target;
+      }
+    }
+  }
+
+  // TODO: is only necessary for extensions - make special for extend/annotate
+  function checkDefinitions( construct, parent, prop, dict = construct[prop] ) {
+    // TODO: do differently, see also annotateMembers() in resolver
+    // To have been checked by parsers:
+    // - artifacts (CDL-only anyway) only inside [extend] context|service
+    if (!dict)
+      return false;
+    const feature = kindProperties[parent.kind ?? 'element'][prop];
+    if (feature &&
+        (feature === true || construct.kind !== 'extend' || feature( prop, parent )))
+      return true;
+    const location = dict[$location];
+
+    // TODO: a bit inconsistent = not a simple switch on `prop`…
+    if (prop === 'actions') {
+      if (Object.keys( dict ).length) {
+        error( 'def-unexpected-actions', [ location, construct ], {}, // TODO: ext-
+               'Actions and functions only exist top-level and for entities' ); // or aspects
+      }
+      else {
+        warning( 'ext-ignoring-actions', [ location, construct ], {},
+                 'Actions and functions only exist top-level and for entities' );
+        return false;
+      }
+    }
+    else if (parent.kind === 'action' || parent.kind === 'function') {
+      error( 'ext-unexpected-action', [ construct.location, construct ], { '#': parent.kind }, {
+        std: 'Actions and functions can\'t be extended, only annotated', // TODO: → ext-unsupported
+        action: 'Actions can\'t be extended, only annotated',
+        function: 'Functions can\'t be extended, only annotated',
+      } );
+    }
+    else if (prop === 'params') {
+      if (!feature) {
+        // Note: This error can't be triggered at the moment.  But as we likely want to
+        //       allow extensions with params in the future, we keep the code.
+        error( 'def-unexpected-params', [ location, construct ], {},
+               'Parameters only exist for entities, actions or functions' );
+      }
+      else {
+        // remark: we could allow this
+        error( 'extend-with-params', [ location, construct ], {},
+               'Extending artifacts with parameters is not supported' );
+      }
+    }
+    else if (feature) {         // allowed in principle, but not with extend
+      if (!Object.keys( dict ).length) {
+        warning( 'ext-ignoring-elements', [ location, construct ], {},
+                 'Only structures with directly specified elements can be extended by elements' );
+        return false;
+      }
+      else if (parent.$inferred === 'include') { // special case for better error message
+        const variant = (construct.enum || construct.elements) ? 'elements' : 'std';
+        error( 'ref-expected-direct-structure', [ location, construct ],
+               { '#': variant, art: parent } );
+      }
+      else if (prop !== 'enum' || !parent.enum ||
+               !parent.type || parent.type.$inferred || (parent._main || parent).query) {
+        error( 'extend-type', [ location, construct ], {},
+               'Only structures or enum types can be extended with elements/enums' );
+      }
+      else {
+        return true;
+      }
+    }
+    else if (prop === 'elements') {
+      error( 'def-unexpected-elements', [ location, construct ], {},
+             'Elements only exist in entities, types or typed constructs' );
+    }
+    else if (prop === 'columns') {
+      error( 'extend-columns', [ location, construct ], { art: construct } );
+    }
+    else { // if (prop === 'enum') {
+      error( 'def-unexpected-enum', [ location, construct ], {},
+             'Enum symbols can only be defined for types or typed constructs' );
+    }
+    return construct === parent;
+  }
+
+
+  // includes ----------------------------------------------------------------
+
+  /**
+   * 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` if it is an entity, collecting the entity
+   * includes with their ancestors.
+   *
+   * Examples:
+   *   ext === art:  `entity E : F {}`  => add elements of F to E
+   *   ext !== art:  `extend E with F`  => add elements of F to extension on E
+   *
+   * @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;
+    }
+    // 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') {
+      includeMembers( ext, art, 'actions' );
+    }
+    else {
+      for (const ref of ext.includes) {
+        const template = ref._artifact; // already resolved
+        if (template?.actions && Object.keys( template.actions ).length) {
+          warning( 'ref-ignoring-actions', [ ref.location, ext ], { art: template },
+                   'The actions of $(ART) are not added to the type' );
+        }
+      }
+    }
+  }
+
+  /**
+   * Add all members (e.g. elements or actions) of `ext.includes` to `ext[prop]`.
+   * If `art` is `ext`, set the parent link accordingly.
+   *
+   * @param {XSN.Extension} ext
+   * @param {XSN.Artifact} art
+   * @param {string} prop 'elements' or 'actions'
+   */
+  function includeMembers( ext, art, prop ) {
+    // TODO two kind of messages:
+    // Error 'More than one include defines element "A"' (at include ref)
+    // Warning 'Overwrites definition from include "I" (at elem def)
+    const propagateKeys = art.kind !== 'type' || model.options.v6KeyPropagation;
+    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];
+    }
+    let elementsAdded = 0;
+    let hasNewElement = false;
+    for (const ref of ext.includes) {
+      // Elements of include are added after previously provided elements:
+      if (prop === 'elements') {
+        if (ref.$postponeInclude == null) {
+          if (ref._artifact?.elements)
+            ref.$postponeInclude = art.$postponeInclude || 0;
+        }
+        else if (ref.$postponeInclude > 0 && members) {
+          let added = elementsAdded;
+          let postpone = ref.$postponeInclude;
+          elementsAdded += postpone;
+          forEachInOrder( { [prop]: members }, prop, ( elem, name ) => {
+            // The element could have been added in the previous loop (includes) to keep
+            // the element order.
+            if (--added < 0 && --postpone >= 0 && ext[prop][name] !== elem )
+              dictAdd( ext[prop], name, elem );
+          } );
+        }
+        if (ref.$postponeInclude != null) // not reset after bare aspect
+          art.$postponeInclude = 0; // elements of next include directly after this one
+      }
+      const template = ref._artifact; // already resolved
+      if (template) {           // be robust
+        if (template[prop] && !ext[prop])
+          ext[prop] = Object.create( null );
+        const location = weakRefLocation( ref );
+
+        // prevent recompilation issue when localized entity is included in aspect or
+        // entity without keys (via shadowing):
+        const checkForLocalized = prop === 'elements' &&
+          template.kind === 'entity' && !template.query &&
+          withLocalizedData( template, ext );
+
+        // eslint-disable-next-line no-loop-func
+        forEachInOrder( template, prop, ( origin, name ) => {
+          if (checkForLocalized && (name === 'texts' || name === 'localized'))
+            return;
+          if (members && members[name]) {
+            if (!ext[prop][name])
+              dictAdd( ext[prop], name, members[name] ); // to keep order
+            return;
+          }
+          hasNewElement = true;
+          const elem = linkToOrigin( origin, name, parent, prop, location );
+          setLink( elem, '_block', origin._block );
+          if (!parent) // not yet set for EXTEND foo WITH bar => linkToOrigin() did not add it
+            dictAdd( ext[prop], name, elem );
+          elem.$inferred = 'include';
+          if (origin.key && propagateKeys)
+            elem.key = Object.assign( { $inferred: 'include' }, origin.key );
+          if (origin.value && origin.$syntax === 'calc') {
+            // 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, location, true ) );
+            elem.$syntax = 'calc';
+            createAndLinkCalcDepElement( elem );
+            setLink( elem, '_calcOrigin', origin._calcOrigin || origin );
+          }
+          // TODO: also complain if elem is just defined in art
+        } );
+      }
+    }
+    if (!hasNewElement && members) {
+      ext[prop] = members;
+      if (prop === 'elements')
+        art.$postponeInclude += addedElements( ext );
+    }
+    else if (members) {
+      let added = elementsAdded;
+      // TODO: expand elements having direct elements (if needed)
+      forEachInOrder( { [prop]: members }, prop, ( elem, name ) => {
+        // The element could have been added in the previous loop (includes) to keep
+        // the element order.
+        if (--added < 0 && ext[prop][name] !== elem ) {
+          dictAdd( ext[prop], name, elem );
+          if (prop === 'elements' && elem.kind !== 'extend')
+            ++art.$postponeInclude;
+        }
+      } );
+    }
+  }
+
+  /**
+   * Return true if include (with `name` and `elements`) in `ext` highly likely
+   * 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 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 &&
+      resolveUncheckedPath( texts.target, 'target', ext ) === textsEntityName &&
+      resolveUncheckedPath( localized.target, 'target', ext ) === textsEntityName &&
+      resolveUncheckedPath( texts.type, 'type', ext ) === 'cds.Composition' &&
+      resolveUncheckedPath( localized.type, 'type', ext ) === 'cds.Association';
+  }
+
+  /**
+   * Report duplicates in parent[prop] that happen due to multiple includes having the
+   * same member.  Run after includes and extends so shadowing members have already
+   * replaced any include-derived survivors in-place.
+   */
+  function checkRedefinitionThroughIncludes( parent, prop ) {
+    if (!parent[prop])
+      return;
+    forEachInOrder( parent, prop, ( member, name ) => {
+      if (member.$inferred === 'include' && Array.isArray( member.$duplicates )) {
+        const includes = [ member, ...member.$duplicates ].map( dup => dup._origin._main );
+        error( 'duplicate-definition', [ parent.name.location, member ],
+               { '#': `include-${ prop }`, name, sorted_arts: includes } );
+      }
+    } );
+  }
+}
+
+/**
+ * Group extensions by their layers.  A definition (for specified elements)
+ * is considered to be provided in a layer named '', the lowest layer.
+ *
+ * @param {object[]} extensions Array of extensions.
+ * @returns {Record<string, object>} key: layer name, value: {name, layer, extensions[]}`
+ */
+function layeredExtensions( extensions ) {
+  const layered = Object.create( null );
+  for (const ext of extensions) {
+    const layer = (ext.kind === 'annotate' || ext.kind === 'extend' || ext.kind === 'source') &&
+                  layers.layer( ext );
+    // just consider layer if Extend/Annotate, not Define
+    const name = (layer) ? layer.realname : '';
+    const done = layered[name];
+    if (done)
+      done.extensions.push( ext );
+    else
+      layered[name] = { name, layer, extensions: [ ext ] };
+  }
+  return layered;
+}
+
+/**
+ * Return extensions of the highest layers.
+ * Also returns whether there could be an issue:
+ * - false: there are just extensions in one file,
+ * - 'unrelated': there is just one extension per layer
+ * - true: there is at least one layer with two or more extensions, and
+ *   at least two files are involved
+ *
+ * @param {Record<string, object>} layered Structure as returned by layeredExtensions()
+ * @returns {{highest, issue: boolean|string}}
+ */
+function extensionsOfHighestLayers( layered ) {
+  const layerNames = Object.keys( layered );
+  // console.log('HIB:',layerNames)
+  if (layerNames.length <= 1) {
+    const name = layerNames[0];
+    const highest = layered[name]?.extensions || [];
+    highest.sort( compareExtensions );
+    delete layered[name];
+    return { highest, issue: inMoreThanOneFile( highest ) };
+  }
+
+  // collect all layers which are lower than another layer
+  const allExtends = Object.create( null );
+  allExtends[''] = {};        // the "Define" layer
+  for (const name of layerNames) {
+    if (name)                 // not the "Define" layer
+      Object.assign( allExtends, layered[name].layer._layerExtends );
+  }
+  // console.log('HIE:',Object.keys(allExtends))
+  const highest = [];           // extensions
+  const highestLayers = [];
+  for (const name of layerNames) {
+    if (!(name in allExtends)) {
+      const layer = layered[name];
+      delete layered[name];
+      highestLayers.push( layer );
+      highest.push( ...layer.extensions );
+    }
+  }
+  highest.sort( compareExtensions );
+  const good = highestLayers.every( layer => !inMoreThanOneFile( layer.extensions ) );
+  // TODO: use layer.file instead
+  const issue = !good || highestLayers.length > 1 && 'unrelated';
+  // console.log('HI:',highest.map(l=>l.name),issue,issue&&extensions)
+  return { highest, issue };
+}
+
+function inMoreThanOneFile( extensions ) {
+  if (extensions.length <= 1)
+    return false;
+  const file = extensions[0].location?.file;
+  return !file || extensions.some( e => e.location?.file !== file );
+}
+
+/**
+ * Compare two extensions which are not comparable via layering:
+ * - via the fs.realpath of the file (not layer!) of the extensions, then
+ * - via the line, then column of the extensions.
+ * Returns <0 if `a`<`b`, >1 if `a`>`b`, i.e. can be used for ascending sort.
+ */
+function compareExtensions( a, b ) {
+  const fileA = layers.realname( a );
+  const fileB = layers.realname( b );
+  if (fileA !== fileB)
+    return (fileA > fileB) ? 1 : -1;
+  return (a?.location?.line || 0) - (b?.location?.line || 0) ||
+    (a?.location?.col || 0) - (b?.location?.col || 0);
+}
+
+
+/**
+ * Propagate the given `prop` (e.g. annotation) early, i.e. copy it from all `.includes`
+ * if they have the property.
+ *
+ * @param {XSN.Definition} art
+ * @param {string} prop
+ */
+function propagateEarly( art, prop ) {
+  if (art[prop])
+    return;
+  for (const ref of art.includes) {
+    const aspect = ref._artifact;
+    if (aspect) {
+      const anno = aspect[prop];
+      if (anno && (anno.val !== null || !art[prop]))
+        art[prop] = Object.assign( { $inferred: 'include' }, anno );
+    }
+  }
+}
+
+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;