@sap/cds-compiler 3.6.2 → 3.8.0

package/lib/compiler/extend.js

@@ -9,21 +9,31 @@ const { searchName, weakLocation } = require('../base/messages');
 const {
   isDeprecatedEnabled,
   forEachGeneric, forEachInOrder, forEachDefinition,
+  forEachMember,
+  isBetaEnabled,
 } = require('../base/model');
-const { dictAdd } = require('../base/dictionaries');
+const { dictAdd, pushToDict } = require('../base/dictionaries');
 const { kindProperties, dictKinds } = require('./base');
 const {
   setLink,
   setArtifactLink,
-  annotateWith,
+  copyExpr,
+  setAnnotation,
+  setExpandStatusAnnotate,
   linkToOrigin,
   setMemberParent,
   dependsOnSilent,
   augmentPath,
-  splitIntoPath, isDirectComposition,
+  pathName,
+  splitIntoPath,
+  isDirectComposition,
+  annotationHasEllipsis,
 } = require('./utils');
 const layers = require('./moduleLayers');
-const { typeParameters } = require('./builtins');
+
+const $location = Symbol.for('cds.$location');
+
+const genLocation = { file: '' }; // attach stupid location - TODO: remove in v4
 
 function extend( model ) {
   const { options } = model;
@@ -34,23 +44,22 @@ function extend( model ) {
   const {
     resolvePath,
     resolveUncheckedPath,
-    checkAnnotate,
-    initAnnotations,
-    copyAnnotationsForExtensions,
+    resolveTypeArgumentsUnchecked,
     attachAndEmitValidNames,
-    checkDefinitions,
     initArtifact,
     initMembers,
-    extensionsDict,             // not a function - TODO
   } = model.$functions;
 
   Object.assign( model.$functions, {
     lateExtensions,
-    layeredAssignments,
-    assignmentsOfHighestLayers,
-    applyTypeExtensions,
+    chooseAnnotationsInArtifact,
+    extendArtifactAfter,
   } );
 
+  const extensionsDict = Object.create(null);
+  forEachDefinition( model, tagIncludes ); // TODO TMP
+
+  forEachDefinition( model, chooseAnnotationsInArtifact );
   applyExtensions();
 
   const addTextsLanguageAssoc = checkTextsLanguageAssocOption(model, options);
@@ -58,9 +67,8 @@ function extend( model ) {
 
   Object.keys( model.definitions ).forEach( processArtifact );
 
-  lateExtensions( false );
-
   compositionChildPersistence();
+  return;
 
   /**
    * Process "composition of" artifacts.
@@ -110,90 +118,442 @@ function extend( model ) {
       if (def.$inferred === 'composition-entity' && !processed.has(def)) {
         if (def._parent)
           processCompositionPersistence(def._parent);
-        copyPersistenceAnnotations(def, def._parent, options);
+        copyPersistenceAnnotations( def, def._parent );
         processed.add(def);
       }
     }
   }
 
+  // TMP:
+  function tagIncludes( art ) {
+    if (art.includes)
+      extensionsDict[art.name.absolute] = [];
+  }
+
+  //-----------------------------------------------------------------------------
+  // Extensions: general algorithm
+  //-----------------------------------------------------------------------------
+  // extendArtifactBefore, extendArtifactAfter, createRemainingAnnotateStatements
+
+  // 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
+  function extendArtifactAfter( art ) {
+    const extensionsMap = art._extensions;
+    if (!extensionsMap || art.builtin) // 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' );
+      delete art.$typeExts;
+    }
+    // TODO tmp: no proper XSN representation yet for annotate … with returns:
+    if (art.kind === 'annotate' && !art.returns &&
+        (extensionsMap.elements?.some( e => e.$syntax === 'returns' ) ||
+         extensionsMap.enum?.some( e => e.$syntax === 'returns' )))
+      annotateCreate( art, '', art, 'returns' );
+
+    moveDictExtensions( art, extensionsMap, 'params' );
+    // moveReturnsExtensions( art, extensionsMap );
+    const sub = art.returns || art.items || art.targetAspect?.elements && art.targetAspect;
+    if (sub) {
+      if (art.returns) {        // after having applied params!
+        extendHandleReturns( extensionsMap.elements, art );
+        extendHandleReturns( extensionsMap.enum, art );
+      }
+      // care about 'ext-unexpected-returns' in a later change if we have XSN returns
+      pushToDict( sub, '_extensions', ...extensionsMap.elements || [] );
+      pushToDict( sub, '_extensions', ...extensionsMap.enum || [] );
+    }
+    else {
+      moveDictExtensions( art, extensionsMap,
+                          (art.enum && art.kind !== 'annotate' ? 'enum' : 'elements'), 'elements' );
+      moveDictExtensions( art, extensionsMap, 'enum' );
+    }
+    moveDictExtensions( art, extensionsMap, 'actions' );
+  }
+
+  /**
+   * Create super annotate statements for remaining extensions
+   */
+  function lateExtensions() {   // -> createRemainingAnnotateStatements
+    model.extensions = Object.values( model.$lateExtensions );
+    // TODO: testMode sort?
+    model.extensions.forEach( createSuperAnnotate );
+  }
+
+  // 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 v4: 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 ],
+             // eslint-disable-next-line object-curly-newline
+             { '#': (scaleDiff ? 'scale' : 'number'), prop, number, otherprop: 'scale' } );
+    }
+    else {
+      art[prop] = ext[prop];
+      return extVal - artVal;
+    }
+    return 0;
+  }
+
+  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: setExpandStatusAnnotate
+    const extensions = extensionsMap[extProp];
+    if (!extensions)
+      return;
+    const artDict = art[artProp] || annotateFor( art, extProp ); // no auto-correction in annotate
+
+    for (const ext of extensions) {
+      const extDict = ext[extProp];
+      for (const name in extDict) {
+        let dictCheck = (art.kind !== 'annotate'); // no check in super annotate statement
+        const elemExt = extDict[name];
+        if (elemExt.kind !== 'annotate' && elemExt.kind !== 'extend') // TODO: specified elems
+          continue;             // definitions inside extend, already handled
+        dictCheck = dictCheck && checkRemainingMemberExtensions( art, elemExt, artProp, name );
+        const elem = artDict[name] || annotateFor( art, extProp, name );
+        setLink( elemExt.name, '_artifact', (elem.kind !== 'annotate' ? elem : null) );
+        pushToDict( elem, '_extensions', elemExt );
+      }
+    }
+  }
+
+  // function moveReturnsExtensions( art, extensionsMap ) {
+  //   const artReturns = art.returns;
+  //   const extensions = extensionsMap.returns;
+  //   // TODO: artItem is null
+  //   for (const ext of extensions)
+  //     pushToDict( artReturns, '_extensions', ext.returns );
+  // }
+
+  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)          // TOOD: think about anonymous target aspect
+      art = art._outer;
+    // if (art._annotateS)
+    //   return art._annotateS;
+    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 { absolute } = art.name;
+    return model.$lateExtensions[absolute] || annotateCreate( model.$lateExtensions, absolute );
+  }
+
+  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 );
+    }
+    else {
+      annotate.name.absolute = id; // TODO later (if all names are sparse): delete absolute
+    }
+    dict[prop || id] = annotate;
+    return annotate;
+  }
+
+  function extendHandleReturns( extensions, art ) {
+    for (const ext of extensions || []) {
+      if (ext.$syntax === 'returns') { // TODO tmp: no proper XSN representation
+        ext.$syntax = '$inside-returns';
+        delete ext.params;
+      }
+      else {
+        warning( 'ext-expected-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)',
+        } );
+      }
+    }
+  }
+
+  // const unexpected_props = {
+  //   elements: 'anno-unexpected-elements',
+  //   enum: 'anno-unexpected-elements', // TODO
+  //   params: 'anno-unexpected-params',
+  //   actions: 'anno-unexpected-actions',
+  // };
+  // const undefined_props = {
+  //   elements: 'anno-undefined-element',
+  //   enum: 'anno-undefined-element', // TODO
+  //   params: 'anno-undefined-param',
+  //   actions: 'anno-undefined-action',
+  // };
+
+  function checkRemainingMemberExtensions( parent, ext, prop, name ) {
+    // console.log('CRME:',prop,name,parent,ext)
+    const dict = parent[prop];
+    if (!dict) {
+      // 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 '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',
+                   });
+          break;
+        case 'params':
+          warning( 'anno-unexpected-params', [ location, ext._parent ], {},
+                   'Parameters only exist for actions or functions' );
+          break;
+        case 'actions':
+          warning( 'anno-unexpected-actions', [ location, ext._parent ], {},
+                   'Actions and functions only exist top-level and for entities' );
+          break;
+        default:
+          // assert
+      }
+      return false;
+    }
+    else if (!dict[name]) {
+      // TODO: make variant `returns` an auto-variant for ($ART) ?
+      const inReturns = parent._parent?.returns && parent._parent;
+      const art = inReturns || parent;
+      switch (prop) {
+        case 'elements':
+          notFound( 'anno-undefined-element', ext.name.location, ext,
+                    { '#': (inReturns ? 'returns' : 'element'), art, name },
+                    parent.elements );
+          break;
+        case 'enum':            // TODO: extra msg id?
+          notFound( 'anno-undefined-element', ext.name.location, ext,
+                    { '#': (inReturns ? 'enum-returns' : 'enum'), art, name },
+                    parent.enum );
+          break;
+        case 'params':
+          notFound( 'anno-undefined-param', ext.name.location, ext,
+                    { '#': 'param', art: parent, name },
+                    parent.params );
+          break;
+        case 'actions':
+          notFound( 'anno-undefined-action', ext.name.location, ext,
+                    { '#': 'action', art: parent, name },
+                    parent.actions );
+          break;
+        default:
+          // assert
+      }
+    }
+    return true;
+  }
+
+  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 { absolute } = annotate.name;
+      const isLocalized = absolute.startsWith( 'localized.' ); // TODO: && anno
+      const art = model.definitions[absolute];
+      for (const ext of extensions)
+        checkRemainingMainExtensions( art, ext, isLocalized );
+      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 extensions
+        annotate.location = extensions[0].location;
+        annotate.name.location = extensions[0].name.location;
+      }
+    }
+    chooseAnnotationsInArtifact( annotate );
+    extendArtifactAfter( annotate );
+    forEachMember( annotate, createSuperAnnotate );
+  }
+
+  function checkRemainingMainExtensions( art, ext, localized ) {
+    if (localized)              // TODO v4: ignore only for annotate
+      return;
+    if (!resolvePath( ext.name, ext.kind, ext )) // error for extend, info for annotate
+      return;
+    // else if (ext.kind === 'extend') { // TODO v4 - add error
+    // }
+    if (art?.kind === 'namespace') {
+      // TODO: not at all different to having no definition
+      info( 'anno-namespace', [ ext.name.location, ext ], {}, // TODO: better location?
+            'Namespaces can\'t be annotated' );
+    }
+    else if (art?.builtin) {
+      info( 'anno-builtin', [ ext.name.location, ext ], {}, // TODO: better location?
+            'Builtin types should not be annotated. Use custom type instead' );
+    }
+  }
+
+  // Issue messages for annotations on namespaces and builtins
+  // (TODO: really here?, probably split main artifacts vs returns)
+  // see also lateExtensions() 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.$syntax === 'returns' && art.kind !== 'action' && art.kind !== 'function' ) {
+        // `annotate ABC with returns {}` is handled just like `elements`. Warn if it is used
+        // for non-actions.  We can't only check for !art.returns, because `action A();` is valid.
+        // `art._block` ensures that `art` is a defined def.
+        return;
+        // warning('ext-unexpected-returns', [ construct.name.location, construct ],
+        //         { keyword: 'returns', meta: art.kind }, 'Unexpected $(KEYWORD) for $(META)');
+      }
+      else if (construct.$syntax !== 'returns' &&
+          (art.kind === 'action' || art.kind === 'function') && construct.elements) {
+        warning('ext-expected-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 ------------------------------------------------------------------
 
   /**
    * Apply the extensions inside the extensionsDict on the model.
    *
-   * Phase 1: context extends, 2: extends with structure includes, 3: extends
-   * without structure includes (in the case of cyclic includes)
-   *
-   * Before phase 1: all artifact extensions have been collected (even those
-   * inside extend context), only "empty" ones from structure includes are still unknown.
-   * After phase 1, all main artifacts are known, also "empty" extensions are known.
+   * First try normally: extends with structure includes; with remaining cyclic
+   * includes, do so without includes.
    */
   function applyExtensions() {
-    let phase = 1;              // TODO: basically remove phase 1
+    let noIncludes = false;
     let extNames = Object.keys( extensionsDict ).sort();
-    // Remark: The sort() makes sure that an extend for artifact C.E is applied
-    // after the extend for C has been applied (which could have defined C.E).
-    // Looping over model.definitions in Phase 1 would miss the `extend
-    // context` for a context C.C defined in an `extend context C`.
-    //
-    // TODO: no need to sort anymore
+
     while (extNames.length) {
       const { length } = extNames;
       for (const name of extNames) {
         const art = model.definitions[name];
-        if (!art || art.kind === 'namespace') {
-          model.$lateExtensions[name] = extensionsDict[name];
+        if (art && art.kind !== 'namespace' &&
+            extendArtifact( extensionsDict[name], art, noIncludes ))
           delete extensionsDict[name];
-        }
-        else if (art.$duplicates) { // cannot extend redefinitions
-          delete extensionsDict[name];
-        }
-        else if (phase === 1
-                 ? extendContext( name, art )
-                 : extendArtifact( extensionsDict[name], art, phase > 2 )) { // >2: no self-include
-          delete extensionsDict[name];
-        }
       }
       extNames = Object.keys( extensionsDict ); // no sort() required anymore
-      if (phase === 1)
-        phase = 2;
-      else if (extNames.length >= length)
-        phase = 3;
+      if (extNames.length >= length)
+        noIncludes = Object.keys( extensionsDict ); // = no includes
     }
   }
 
-  function extendContext( name, art ) {
-    // TODO: remove this function - add remains to define.js
-    // (ext.expectedKind == art.kind) already checked by parser except for context/service
-    if (!kindProperties[art.kind].artifacts) {
-      // no context or service => warn about context extensions
-      for (const ext of extensionsDict[name]) {
-        if (ext.expectedKind === 'context' || ext.expectedKind === 'service') {
-          const loc = ext.name.location;
-          // TODO: warning is enough
-          error( 'extend-with-artifacts', [ loc, ext ], { name, '#': ext.expectedKind, keyword: `EXTEND ${ ext.expectedKind }` }, {
-            std: 'Can\'t extend non-context / non-service $(NAME) with $(KEYWORD)',
-            service: 'Can\'t extend non-service $(NAME) with $(KEYWORD)',
-            context: 'Can\'t extend non-context $(NAME) with $(KEYWORD)',
+  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',
+          };
+          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'
       }
-      return false;
     }
-
-    for (const ext of extensionsDict[name]) {
-      setArtifactLink( ext.name, art );
-      checkDefinitions( ext, art, 'elements'); // error for elements etc
-      checkDefinitions( ext, art, 'enum');
-      checkDefinitions( ext, art, 'actions');
-      checkDefinitions( ext, art, 'params');
-      checkDefinitions( ext, art, 'columns');
-      if (ext.includes)
-        applyIncludes( ext, art ); // emits error if `includes` is set
-      checkAnnotate( ext, art );
-      copyAnnotationsForExtensions( ext, art );
-    }
-    return true;
   }
 
   /**
@@ -210,12 +570,23 @@ function extend( model ) {
     if (!noIncludes && !(canApplyIncludes( art, art ) &&
         extensions.every( ext => canApplyIncludes(ext, art) )))
       return false;
+    if (Array.isArray( noIncludes )) {
+      canApplyIncludes( art, art, noIncludes );
+      extensions.forEach( ext => canApplyIncludes( ext, art, noIncludes ) );
+    }
+    else if (!noIncludes &&
+             !(canApplyIncludes( art, art ) &&
+               extensions.every( ext => canApplyIncludes( ext, art) ))) {
+      // console.log( 'FALSE:',art.name, extensions.map( e => e.name ) )
+      return false;
+    }
     if (!art.query) {
       model._entities.push( art ); // add structure with includes in dep order
       art.$entity = ++model.$entity;
     }
     if (!noIncludes && art.includes)
       applyIncludes( art, art );
+    // checkExtensionsKind( extensions, art );
     extendMembers( extensions, art, noIncludes === 'gen' );
     if (!noIncludes && art.includes) {
       // early propagation of specific annotation assignments
@@ -229,12 +600,14 @@ function extend( model ) {
   function extendMembers( extensions, art, noExtend ) {
     // TODO: do the whole extension stuff lazily if the elements are requested
     const elemExtensions = [];
-    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
-    for (const ext of extensions) {
+    // console.log('EM:',art.name,extensions,art._extensions)
+    for (const ext of extensions) { // those in extMap.includes
       // console.log(message( 'id', [ext.location, ext], { art: ext.name._artifact },
       //                      'Info', 'EXT').toString())
-      if (!('_artifact' in ext.name)) { // not already applied
+      if (ext.name._artifact === undefined) { // not already applied
         setArtifactLink( ext.name, art );
         if (noExtend && ext.kind === 'extend') {
           error( 'extend-for-generated', [ ext.name.location, ext ], { art },
@@ -252,12 +625,10 @@ function extend( model ) {
             art.includes = [ ...ext.includes ];
           applyIncludes( ext, art );
         }
+        // console.log(ext,art)
         checkAnnotate( ext, art );
-        initAnnotations( ext, ext._block, ext.kind ); // TODO: do in define.js
-        copyAnnotationsForExtensions( ext, art );
         // TODO: do we allow to add elements with array of {...}?  If yes, adapt
         initMembers( ext, art, ext._block ); // might set _extend, _annotate
-        storeTypeExtension( ext, art );
         dependsOnSilent(art, ext); // art depends silently on ext (inverse to normal dep!)
       }
       for (const name in ext.elements) {
@@ -267,17 +638,24 @@ function extend( model ) {
           break;                // more than one elem in same EXTEND is fine
         }
       }
-
-      if (ext.columns)          // extend projection
-        extendColumns( ext, art );
     }
     if (elemExtensions.length > 1)
       reportUnstableExtensions( elemExtensions );
-    if (art._extendType && art._extendType.length > 0)
-      reportTypeExtensionsInSameLayer( art._extendType );
 
+    // This whole function will be removed with a next change - no need to have nice code here:
+    const extsTmp = { elements: Object.create(null), actions: Object.create(null) };
+    for (const e of extensions) {
+      for (const n in e.elements || []) {
+        if (e.elements[n].kind === 'extend')
+          pushToDict( extsTmp.elements, n, e.elements[n] );
+      }
+      for (const n in extensions.actions || []) {
+        if (e.actions[n].kind === 'extend')
+          pushToDict( extsTmp.actions, n, e.actions[n] );
+      }
+    }
     [ 'elements', 'actions' ].forEach( (prop) => {
-      const dict = art._extend && art._extend[prop];
+      const dict = extsTmp[prop];
       for (const name in dict) {
         let obj = art;
         if (obj.targetAspect)
@@ -371,129 +749,6 @@ function extend( model ) {
     return !hasError;
   }
 
-
-  /**
-   * Copy columns for EXTEND PROJECTION
-   *
-   * @param {XSN.Extension} ext
-   * @param {XSN.Artifact} art
-   */
-  function extendColumns( ext, art ) {
-    // TODO: consider reportUnstableExtensions
-
-    const { location } = ext.name;
-    const { query } = art;
-    if (!query) {
-      if (art.kind !== 'annotate')
-        error( 'extend-columns', [ location, ext ], { art } );
-      return;
-    }
-    if (!query.from || !query.from.path) {
-      error( 'extend-columns', [ location, ext ], { art } );
-    }
-    else {
-      if (!query.columns)
-        query.columns = [ { location, val: '*' } ];
-
-      for (const column of ext.columns) {
-        setLink( column, '_block', ext._block );
-        query.columns.push(column);
-      }
-    }
-  }
-
-  /**
-   * Similar to chooseAssignment for annotations, this function applies type extensions in order,
-   * such that hierarchies are respected.
-   * Order already set in `extendMembers()` using `compareLayers()`.
-   *
-   * @param art
-   */
-  function applyTypeExtensions( art ) {
-    /**
-     * Contains the previous extension for each property that was applied
-     * successfully.
-     */
-    const previousSuccess = Object.create(null);
-    const allowedBuiltinCategories = [ 'string', 'decimal', 'integer', 'binary' ];
-    const artType = art.type?._artifact;
-
-    for (const ext of art._extendType) {
-      if (art.$inferred) {
-        // Only report first extension for $inferred artifact. Reduces noise.
-        error('ref-expected-scalar-type', [ ext.name.location, ext ], { '#': 'inferred' } );
-        break;
-      }
-
-      const baseType = art._effectiveType; // may be an ENUM
-      if (!artType || (art.kind !== 'type' && art.kind !== 'element') || !baseType?.builtin) {
-        // Only report first extension for non-scalar base type. Reduces noise.
-        error('ref-expected-scalar-type', [ ext.name.location, ext ], { } );
-        break;
-      }
-      else if (!allowedBuiltinCategories.includes(baseType.category)) {
-        // Only report first extension for non-scalar type. Reduces noise.
-        error('ref-expected-scalar-type', [ ext.name.location, ext ],
-              { '#': 'unsupported', prop: baseType.category });
-        continue;
-      }
-
-      for (const prop of typeParameters.list) {
-        if (!ext[prop])
-          continue;
-
-        if (!baseType.parameters?.includes(prop)) {
-          // For `extend T with type (length:10)` where T does not expect a length.
-          error( 'type-unexpected-argument', [ ext[prop].location, ext ], {
-            '#': 'type', prop, art, type: baseType,
-          });
-          break; // one error for first property is enough
-        }
-        else if (!art[prop]) {
-          // Can only extend properties that exist directly on the artifact.
-          error('ext-invalid-type-property', [ ext[prop].location, ext ],
-                { prop, '#': 'new-prop' });
-          break; // one error for first property is enough
-        }
-        else if (art[prop].val === ext[prop].val) {
-          // Ignore extensions with same value
-        }
-        else if (art[prop].literal === 'string' || ext[prop].literal === 'string' ) {
-          // Users can't change from/to string value for property,
-          // e.g. `variable`/`floating` for Decimal
-          error( 'ext-invalid-type-property', [ ext[prop].location, ext ],
-                 { '#': 'string', prop } );
-        }
-        else if (art[prop].val > ext[prop].val) {
-          // TODO: Future: Sub-message that points to previous extension?
-          error( 'ext-invalid-type-property', [ ext[prop].location, ext ], {
-            prop,
-            value: ext[prop].val,
-            number: art[prop].val,
-            '#': previousSuccess[prop] ? 'ext-smaller' : 'smaller',
-          } );
-          break; // one error for first property is enough
-        }
-        else if (art[prop].val < ext[prop].val) {
-          art[prop] = ext[prop];
-          previousSuccess[prop] = ext;
-        }
-      }
-
-      // If `scale` is increased, but `precision` is not, data may be lost in a migration.
-      // e.g. `Decimal(4,2)` allows `12.34`. Increasing scale to 3 would make this value
-      // invalid and only allow `1.234`.
-      // TODO: Should we actually check that the increase is correct?
-      if (ext.scale && !ext.precision) {
-        error('ext-invalid-type-property', [ ext.scale.location, ext ], {
-          prop: 'scale',
-          otherprop: 'precision',
-          '#': 'scale',
-        });
-      }
-    }
-  }
-
   /**
    * Report 'Warning: Unstable element order due to repeated extensions'
    * except if all extensions are in the same file.
@@ -535,26 +790,6 @@ function extend( model ) {
     }
   }
 
-  /**
-   * Report type extensions in same layer, similar mechanism to chooseAssignment()
-   * for annotations.
-   *
-   * @param {XSN.Extension[]} extensions
-   */
-  function reportTypeExtensionsInSameLayer( extensions ) {
-    // Group assignments by layer
-    const extLayers = layeredAssignments( extensions );
-    // We only care about the highest layer
-    const { assignments, issue } = assignmentsOfHighestLayers( extLayers );
-
-    if (issue) {
-      const id = (issue === 'unrelated')
-        ? 'ext-duplicate-extend-type-unrelated-layer'
-        : 'ext-duplicate-extend-type';
-      for (const ext of assignments)
-        message( id, [ ext.name.location, ext ], { type: ext.name._artifact } );
-    }
-  }
 
   /**
    * @param {XSN.Extension[]} extensions
@@ -582,77 +817,6 @@ function extend( model ) {
     }
   }
 
-  /**
-   * @param {Function|false} [veryLate]
-   */
-  function lateExtensions( veryLate ) {
-    for (const name in model.$lateExtensions) {
-      const art = model.definitions[name];
-      const exts = model.$lateExtensions[name];
-      if (art && art.kind !== 'namespace') {
-        if (art.builtin) {
-          for (const ext of exts)
-            info( 'anno-builtin', [ ext.name.location, ext ] );
-        }
-        // created texts entity, auto-exposed entity
-        if (exts) {
-          extendArtifact( exts, art, 'gen' );
-          if (veryLate)
-            veryLate( art );
-          model.$lateExtensions[name] = null; // done
-        }
-      }
-      else if (veryLate) {
-        // Complain about unused extensions, i.e. those
-        // which do not point to a valid artifact
-        for (const ext of exts) {
-          delete ext.name.path[0]._artifact;      // get message for root
-          // TODO: make resolvePath('extend'/'annotate') ignore namespaces
-          // Don't try to apply annotations in the `localized.` namespace.
-          // That's done in `localized.js`.
-          if (!name.startsWith('localized.') &&
-            resolvePath( ext.name, ext.kind, ext )) { // should issue error/info
-            // should issue error for cds extensions (annotate ok)
-            if (art.kind === 'namespace') {
-              // TODO: Emit error if namespace is extended by non-definitions.
-              info( 'anno-namespace', [ ext.name.location, ext ], {},
-                    'Namespaces can\'t be annotated' );
-            }
-            // Builtin annotations would be represented as annotations in to-csn.js
-            else if (art.builtin) {
-              info( 'anno-builtin', [ ext.name.location, ext ] );
-            }
-          }
-          // TODO: warning for context/service extension on non-correct
-          if (ext.kind === 'annotate')
-            delete ext.name._artifact; // make it be considered by extendArtifact()
-        }
-        // create "super" ANNOTATE containing all non-applied ones
-        const first = exts[0];
-        const { location } = first.name;
-
-        /** @type {XSN.Definition} */
-        const annotationArtifact = {
-          kind: 'annotate',
-          name: { path: [ { id: name, location } ], absolute: name, location },
-          location: first.location,
-        };
-
-        if (!model.extensions)
-          model.extensions = [];
-
-        model.extensions.push(annotationArtifact);
-        extendArtifact( exts, annotationArtifact ); // also sets _artifact link in extensions
-        // if one of the annotate statement mentions 'returns', assume it
-        // TODO: with warning/info?
-        for (const ext of exts) {
-          if (ext.$syntax === 'returns')
-            annotationArtifact.$syntax = 'returns';
-        }
-      }
-    }
-  }
-
   // includes ----------------------------------------------------------------
 
   /**
@@ -665,14 +829,26 @@ function extend( model ) {
    * @param {XSN.Artifact} target
    * @returns {boolean}
    */
-  function canApplyIncludes( art, target ) {
-    if (art.includes) {
-      const isView = !!target.query;
-      for (const ref of art.includes) {
-        const template = resolvePath( ref, isView ? 'viewInclude' : 'include', art );
-        if (template && template.name.absolute in extensionsDict)
-          return false;
+  function canApplyIncludes( art, target, justResolveCyclic ) {
+    if (!art.includes)
+      return true;
+    const isView = !!target.query;
+    for (const ref of art.includes) {
+      const name = resolveUncheckedPath( ref, 'include', art );
+      // console.log('CAI:',justResolveCyclic, name, ref.path, Object.keys(extensionsDict))
+      if (justResolveCyclic) {
+        if (!justResolveCyclic.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;
+      }
+      resolvePath( ref, isView ? 'viewInclude' : 'include', art );
     }
     return true;
   }
@@ -710,7 +886,8 @@ function extend( model ) {
         }
       }
     }
-    includeMembers( ext, art, 'elements' );
+    if (!art.query)    // do not set art.elements and art.enums with query entity!
+      includeMembers( ext, art, 'elements' );
     includeMembers( ext, art, 'actions' );
   }
 
@@ -743,10 +920,18 @@ function extend( model ) {
             elem.masked = Object.assign( { $inferred: 'include' }, origin.masked );
           if (origin.key)
             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?
+            elem.value = Object.assign( { $inferred: 'include' }, copyExpr( origin.value ));
+            elem.$syntax = 'calc';
+            setLink( elem, '_calcOrigin', origin._calcOrigin || origin );
+          }
           // TODO: also complain if elem is just defined in art
         });
       }
     }
+    checkRedefinitionThroughIncludes( parent, prop );
     // TODO: expand elements having direct elements (if needed)
     if (members) {
       forEachInOrder( { [prop]: members }, prop, ( elem, name ) => {
@@ -755,6 +940,31 @@ function extend( model ) {
     }
   }
 
+  /**
+   * Report duplicates in parent[prop] that happen due to multiple includes having the
+   * same member.  Covers `entity G : E, G {};` but not `entity G : E {};  extend G with F;`.
+   *
+   * TODO(v4): Make this a hard error; see checkRedefinition(); maybe combine both;
+   */
+  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);
+        if (isBetaEnabled(options, 'v4preview')) {
+          error( 'duplicate-definition', [ parent.name.location, member ],
+                 { '#': `include-${ prop }`, name, sorted_arts: includes } );
+        }
+        else {
+          // Error accidentally removed in v2/v3, therefore only a warning.
+          warning( 'ref-duplicate-include-member', [ parent.name.location, member ],
+                   { '#': prop, name, sorted_arts: includes } );
+        }
+      }
+    });
+  }
+
   // localized texts entities
 
   /**
@@ -881,6 +1091,7 @@ function extend( model ) {
     const art = useTextsAspect
       ? createTextsEntityWithInclude( base, absolute, fioriEnabled )
       : createTextsEntityWithDefaultElements( base, absolute, fioriEnabled );
+    // both functions are rather similar...
 
     const { location } = base.name;
 
@@ -916,7 +1127,7 @@ function extend( model ) {
           elem.key = { val: true, $inferred: 'localized', location };
           // If the propagated elements remain key (that is not fiori.draft.enabled)
           // they should be omitted from OData containment EDM
-          annotateWith( elem, '@odata.containment.ignore', location );
+          setAnnotation( elem, '@odata.containment.ignore', location );
         }
         else {
           // add the former key paths to the unique constraint
@@ -953,10 +1164,10 @@ function extend( model ) {
         path: [ { id: locale.name.id, location: locale.location } ],
         location: locale.location,
       });
-      annotateWith( art, '@assert.unique.locale', art.location, assertUniqueValue, 'array' );
+      setAnnotation( art, '@assert.unique.locale', art.location, assertUniqueValue, 'array' );
     }
 
-    copyPersistenceAnnotations(art, base, options);
+    copyPersistenceAnnotations( art, base );
     return art;
   }
 
@@ -988,7 +1199,7 @@ function extend( model ) {
     if (!fioriEnabled) {
       // To be compatible, we switch off draft without @fiori.draft.enabled
       // TODO (next major version): remove?
-      annotateWith( art, '@odata.draft.enabled', art.location, false );
+      setAnnotation( art, '@odata.draft.enabled', art.location, false );
     }
     else {
       // @fiori.draft.enabled artifacts need default elements ID_texts and locale.
@@ -1009,9 +1220,11 @@ function extend( model ) {
 
     if (addTextsLanguageAssoc && art.elements.language)
       art.elements.language = undefined; // TODO: Message? Ignore?
+    // TODO: what is this necessary?  We do not create a text entity in this case
 
     setLink( art, '_block', model.$internal );
     model.definitions[absolute] = art;
+    chooseAnnotationsInArtifact( art ); // having extensions here would be wrong
     return art;
   }
 
@@ -1046,7 +1259,7 @@ function extend( model ) {
       locale.key = { val: true, location };
       // To be compatible, we switch off draft without @fiori.draft.enabled
       // TODO (next major version): remove?
-      annotateWith( art, '@odata.draft.enabled', art.location, false );
+      setAnnotation( art, '@odata.draft.enabled', art.location, false );
     }
     else {
       const textId = {
@@ -1058,11 +1271,11 @@ function extend( model ) {
       };
       dictAdd( art.elements, 'ID_texts', textId );
     }
-
     dictAdd( art.elements, 'locale', locale );
+
     setLink( art, '_block', model.$internal );
     model.definitions[absolute] = art;
-
+    chooseAnnotationsInArtifact( art ); // having extensions here would be wrong
     return art;
   }
 
@@ -1346,9 +1559,9 @@ function extend( model ) {
     model.definitions[entityName] = art;
     initArtifact( art );
 
+    chooseAnnotationsInArtifact( art ); // having extensions here would be wrong
     // Copy persistence annotations from aspect.
-    copyPersistenceAnnotations(art, target, options);
-
+    copyPersistenceAnnotations( art, target ); // after chooseAnnotation()
     return art;
   }
 
@@ -1364,57 +1577,361 @@ function extend( model ) {
       if (origin.key)
         proxy.key = Object.assign( { $inferred: 'include' }, origin.key );
       if (anno)
-        annotateWith( proxy, anno );
+        setAnnotation( proxy, anno );
       dictAdd( proxyDict.elements, pname, proxy );
     }
   }
+
+
+  // Phase 4 - annotations ---------------------------------------------------
+  // move to top
+
+  /**
+   * Goes through all (applied) annotations in the given artifact and chooses one
+   * if multiple exist according to the module layer.
+   * TODO: rename to extendArtifactBefore
+   *
+   * @param {XSN.Artifact} art
+   */
+  function chooseAnnotationsInArtifact( art ) {
+    // for main artifacts, move extensions from `$lateExtensions` model dictionary:
+    if (!art._main && !art._outer && art._extensions === undefined &&
+        art.kind !== 'namespace') {
+      // if (!art.name) console.log(art)
+      const { absolute } = art.name;
+      setLink( art, '_extensions', model.$lateExtensions[absolute]?._extensions || null );
+      if (art._extensions && !art.builtin) { // keep extensions for builtin in $lateExtensions
+        delete model.$lateExtensions[absolute];
+        // TODO: if the extension mechanism has been completed, we could uncomment:
+        // art._extensions.forEach( ext => resolvePath( ext.name, ext.kind, ext )); // for LSP
+        // (if we do it now, the old extend functionality might think “already applied”)
+      }
+    }
+    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)
+        setExpandStatusAnnotate( art, 'annotate' );
+      if (Array.isArray( art._extensions )) {
+        checkExtensionsKind( art._extensions, art ); // TODO: check with builtins
+        transformArtifactExtensions( art );
+      }
+      applyAllExtensions( art );
+    }
+  }
+
+  // TODO: if extensions has more than one of returns,items,elements,enum, delete all those props
+  function transformArtifactExtensions( art ) {
+    const hasOnlySubExtensions = art._outer; // items, anonymous aspects
+    const dict = Object.create(null);
+    for (const ext of art._extensions) {
+      for (const prop in ext) {
+        if (ext[prop] === undefined) // deleted propery
+          continue;
+        // TODO: do this check nicer (after complete move to new extensions mechanism)
+        if (prop.charAt(0) === '@' || prop === 'doc' ||
+            prop === 'includes' || prop === 'columns' ||
+            prop === 'length' || prop === 'scale' || prop === 'precision' || prop === 'srid') {
+          if (!hasOnlySubExtensions)
+            pushToDict( dict, prop, ext );
+        }
+        else if (prop === 'elements' || prop === 'enum' || prop === 'actions' ||
+                 prop === 'params' || prop === 'returns') {
+          if (ext.kind === 'extend')
+            pushToDict( dict, 'includes', ext );
+          pushToDict( dict, prop, ext );
+        }
+      }
+    }
+    art._extensions = dict;
+  }
+
+  function applyAllExtensions( art ) {
+    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;
+          }
+        }
+        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];
+    }
+  }
+
+  function extensionOverwrites( ext, prop ) {
+    return (prop.charAt(0) !== '@')
+      ? [ 'doc', 'length', 'precision', 'scale', 'srid' ].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 === 'enum' || prop === 'actions' || prop === 'columns' ||
+        prop === 'params' || prop === 'returns' || prop === 'includes' )
+      return;                   // extensions currently handled extra
+    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)
+      }
+      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 (ext.kind === 'extend' && art.$inferred) {
+        error( 'extend-for-generated', [ ext.name.location, ext ], { art },
+               'You can\'t use EXTEND on the generated $(ART)' );
+      }
+      else if (art.kind !== 'annotate' && !art._outer) { // not with elem extension in targetAspect
+        const { absolute } = art.name;
+        const dict = extensionsDict[absolute] || (extensionsDict[absolute] = []);
+        dict.push( ext ); // TODO: change
+        // console.log( 'ASI:',prop,art.name,ext,extensionsDict[absolute])
+      }
+      // art[prop] = (art[prop]) ? art[prop].concat( ext[prop] ) : ext[prop];
+    }
+    else if (prop === 'columns') {
+      const { query } = art;
+      if (!query?.from?.path)
+        error( 'extend-columns', [ ext.columns[$location], ext ], { art } );
+      else if (!query.columns)
+        query.columns = [ { location: query.from.location, val: '*' }, ...ext.columns ];
+      else
+        query.columns.push( ...ext.columns );
+    }
+    else if ([ 'length', 'precision', 'scale', 'srid' ].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 applyAssignment( previousAnno, anno, art, annoName ) {
+    const firstEllipsis = annotationHasEllipsis( anno );
+    if (!firstEllipsis)
+      return anno;
+    const hasBase = previousAnno?.literal === 'array';
+    if (!previousAnno) {
+      const loc = firstEllipsis.location || anno.name.location;
+      message( 'anno-unexpected-ellipsis', [ loc, art ], { code: '...' } );
+      previousAnno = { val: [] };
+    }
+    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 = { val: [] };
+    }
+    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.upTo && checkUpToSpec( item.upTo, art, annoName, true );
+        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 { val: result, literal: 'array' };
+  }
+  // function se(a) { return a.upTo ? [a.val,a.upTo.val] : a.val ; }
+
+  function checkUpToSpec( upToSpec, art, annoName, isFullUpTo ) {
+    const { literal } = upToSpec;
+    if (!isFullUpTo) {          // inside struct of UP TO
+      if (literal !== 'struct' && literal !== 'array' )
+        return true;
+    }
+    else if (literal === 'struct') {
+      return Object.values( upToSpec.struct ).every( v => checkUpToSpec( v, art, annoName ) );
+    }
+    else if (literal !== 'array' && literal !== 'boolean' && literal !== 'null') {
+      return true;
+    }
+    error( null, [ upToSpec.location, art ],
+           { anno: annoName, code: '... up to', '#': literal },
+           {
+             std: 'Unexpected $(CODE) value type in the assignment of $(ANNO)',
+             array: 'Unexpected array as $(CODE) value in the assignment of $(ANNO)',
+             // eslint-disable-next-line max-len
+             struct: 'Unexpected structure as $(CODE) structure property value in the assignment of $(ANNO)',
+             boolean: 'Unexpected boolean as $(CODE) value in the assignment of $(ANNO)',
+             null: 'Unexpected null as $(CODE) value in the assignment of $(ANNO)',
+           } );
+    return false;
+  }
+
+  function equalUpTo( previousItem, upToSpec ) {
+    if (!previousItem)
+      return false;
+    if ('val' in upToSpec) {
+      if (previousItem.val === upToSpec.val) // enum, struct and ref have no val
+        return true;
+      const typeUpTo = typeof upToSpec.val;
+      const typePrev = typeof previousItem.val;
+      if (typeUpTo === 'number')
+        return typePrev === 'string' && previousItem.val === upToSpec.val.toString();
+      if (typePrev === 'number')
+        return typeUpTo === 'string' && upToSpec.val === previousItem.val.toString();
+    }
+    else if (upToSpec.path) {
+      return previousItem.path && normalizeRef( previousItem ) === normalizeRef( upToSpec );
+    }
+    else if (upToSpec.sym) {
+      return previousItem.sym && previousItem.sym.id === upToSpec.sym.id;
+    }
+    else if (upToSpec.struct && previousItem.struct) {
+      return Object.entries( upToSpec.struct )
+        .every( ([ n, v ]) => equalUpTo( previousItem.struct[n], v ) );
+    }
+    return false;
+  }
+
+  function normalizeRef( node ) { // see to-csn.js
+    const ref = pathName( node.path );
+    return node.variant ? `${ ref }#${ node.variant.id }` : ref;
+  }
+
+  /**
+   * Copy the annotations `@cds.persistence.skip`/`@cds.persistence.exists` from
+   * source to target if present on source but not target.
+   *
+   * @param {object} target
+   * @param {object} source
+   */
+  function copyPersistenceAnnotations( target, source ) {
+    if (!source)
+      return;
+
+    const copyExists = !isDeprecatedEnabled( options, 'eagerPersistenceForGeneratedEntities' );
+    if (copyExists)
+      copy( '@cds.persistence.exists' );
+    copy( '@cds.persistence.skip' );
+
+    function copy( anno ) {
+      if ( source[anno] && !target[anno] )
+        target[anno] = { ...source[anno], $inferred: 'parent-origin' };
+    }
+  }
 }
 
 /**
- * Group assignments by their layers.  An assignment provided with a definition
+ * Group extensions by their layers.  A definition (for specified elements)
  * is considered to be provided in a layer named '', the lowest layer.
  *
- * TODO: make this usable for extend (elements), too =
- *       do not use $priority, make assignments on define do not have own _block
- *
- * @param {object[]} assignments Array of assignments, e.g. extensions.
- * @returns {Record<string, object>} key: layer name, value: {name, layer, assignments[]}`
+ * @param {object[]} extensions Array of extensions.
+ * @returns {Record<string, object>} key: layer name, value: {name, layer, extensions[]}`
  */
-function layeredAssignments( assignments ) {
+function layeredExtensions( extensions ) {
   const layered = Object.create(null);
-  for (const a of assignments) {
-    const layer = a.$priority !== false && layers.layer( a );
+  for (const ext of extensions) {
+    const layer = (ext.kind === 'annotate' || ext.kind === 'extend') && layers.layer( ext );
     // just consider layer if Extend/Annotate, not Define
     const name = (layer) ? layer.realname : '';
     const done = layered[name];
     if (done)
-      done.assignments.push( a );
+      done.extensions.push( ext );
     else
-      layered[name] = { name, layer, assignments: [ a ] };
-    // TODO: file - if set: unique in layer
+      layered[name] = { name, layer, extensions: [ ext ] };
   }
   return layered;
 }
 
 /**
- * Return assignments of the highest layers.
+ * Return extensions of the highest layers.
  * Also returns whether there could be an issue:
- * - false: there is just one assignment
- * - 'unrelated': there is just one assignment per layer
- * - true: there is at least one layer with two or more assignments
- * TODO: make this usable for extend (elements), too.
+ * - 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>} layeredAnnos Structure as returned by layeredAssignments()
+ * @param {Record<string, object>} layered Structure as returned by layeredExtensions()
  * @returns {{assignments, issue: boolean|string}}
  */
-function assignmentsOfHighestLayers( layeredAnnos ) {
-  const layerNames = Object.keys( layeredAnnos );
+function extensionsOfHighestLayers( layered ) {
+  const layerNames = Object.keys( layered );
   // console.log('HIB:',layerNames)
   if (layerNames.length <= 1) {
     const name = layerNames[0];
-    const { assignments } = layeredAnnos[name] || { assignments: [] };
-    delete layeredAnnos[name];
-    return { assignments, issue: assignments.length > 1 };
+    const highest = layered[name]?.extensions || [];
+    delete layered[name];
+    return { highest, issue: inMoreThanOneFile( highest ) };
   }
 
   // collect all layers which are lower than another layer
@@ -1422,28 +1939,41 @@ function assignmentsOfHighestLayers( layeredAnnos ) {
   allExtends[''] = {};        // the "Define" layer
   for (const name of layerNames) {
     if (name)                 // not the "Define" layer
-      Object.assign( allExtends, layeredAnnos[name].layer._layerExtends );
+      Object.assign( allExtends, layered[name].layer._layerExtends );
   }
   // console.log('HIE:',Object.keys(allExtends))
-  const assignments = [];
-  const highest = [];
+  const highest = [];           // extensions
+  const highestLayers = [];
   for (const name of layerNames) {
     if (!(name in allExtends)) {
-      const layer = layeredAnnos[name];
-      delete layeredAnnos[name];
-      highest.push( layer );
-      assignments.push( ...layer.assignments );
+      const layer = layered[name];
+      delete layered[name];
+      highestLayers.push( layer );
+      highest.push( ...layer.extensions );
     }
   }
-  assignments.sort( compareAssignments );
-  const good = highest.every( layer => layer.assignments.length === 1 );
+  highest.sort( compareExtensions );
+  const good = highestLayers.every( layer => !inMoreThanOneFile( layer.extensions ));
   // TODO: use layer.file instead
-  const issue = !good || highest.length > 1 && 'unrelated';
-  // console.log('HI:',highest.map(l=>l.name),issue,issue&&assignments)
-  return { assignments, issue };
+  const issue = !good || highestLayers.length > 1 && 'unrelated';
+  // console.log('HI:',highest.map(l=>l.name),issue,issue&&extensions)
+  return { highest, issue };
 }
 
-function compareAssignments( a, b ) {
+function inMoreThanOneFile( extensions ) {
+  if (extensions.length <= 1)
+    return false;
+  const file = extensions[0].location?.file;
+  return !file || extensions.slice(1).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._block );
   const fileB = layers.realname( b._block );
   if (fileA !== fileB)
@@ -1452,29 +1982,6 @@ function compareAssignments( a, b ) {
     (a?.location?.col || 0) - (b?.location?.col || 0);
 }
 
-/**
- * Copy the annotations `@cds.persistence.skip`/`@cds.persistence.exists` from
- * source to target if present on source but not target.
- *
- * @param {object} target
- * @param {object} source
- * @param {CSN.Options} options
- */
-function copyPersistenceAnnotations( target, source, options ) {
-  if (!source)
-    return;
-
-  const copyExists = !isDeprecatedEnabled( options, 'eagerPersistenceForGeneratedEntities' );
-  if (copyExists)
-    copy( '@cds.persistence.exists' );
-  copy( '@cds.persistence.skip' );
-
-  function copy( anno ) {
-    if ( source[anno] && !target[anno] )
-      target[anno] = { ...source[anno], $inferred: 'parent-origin' };
-  }
-}
-
 function augmentEqual( location, assocname, relations, prefix = '' ) {
   const args = relations.map( eq );
   return (args.length === 1)
@@ -1508,15 +2015,14 @@ function augmentEqual( location, assocname, relations, prefix = '' ) {
  * @param {XSN.Extension} ext
  * @param {object} art
  */
-function storeTypeExtension( ext, art ) {
-  // If there are no parameters to apply, don't store the extension.
-  if (!typeParameters.list.some( prop => ext[prop] !== undefined ))
-    return;
-  else if (!art._extendType)
-    setLink( art, '_extendType', [] );
-  art._extendType.push( ext );
-}
-
+// function storeTypeExtension( ext, art ) {
+//   // If there are no parameters to apply, don't store the extension.
+//   if (!typeParameters.list.some( prop => ext[prop] !== undefined ))
+//     return;
+//   else if (!art._extendType)
+//     setLink( art, '_extendType', [] );
+//   art._extendType.push( ext );
+// }
 
 function checkTextsLanguageAssocOption( model, options ) {
   const languages = model.definitions['sap.common.Languages'];