@sap/cds-compiler 3.7.2 → 3.8.0

package/lib/compiler/extend.js

@@ -9,14 +9,17 @@ const { searchName, weakLocation } = require('../base/messages');
 const {
   isDeprecatedEnabled,
   forEachGeneric, forEachInOrder, forEachDefinition,
+  forEachMember,
+  isBetaEnabled,
 } = require('../base/model');
-const { dictAdd, dictAddArray } = require('../base/dictionaries');
+const { dictAdd, pushToDict } = require('../base/dictionaries');
 const { kindProperties, dictKinds } = require('./base');
 const {
   setLink,
   setArtifactLink,
   copyExpr,
-  annotateWith,
+  setAnnotation,
+  setExpandStatusAnnotate,
   linkToOrigin,
   setMemberParent,
   dependsOnSilent,
@@ -27,8 +30,10 @@ const {
   annotationHasEllipsis,
 } = require('./utils');
 const layers = require('./moduleLayers');
-const { typeParameters } = require('./builtins');
-const { CompilerAssertion } = require('../base/error');
+
+const $location = Symbol.for('cds.$location');
+
+const genLocation = { file: '' }; // attach stupid location - TODO: remove in v4
 
 function extend( model ) {
   const { options } = model;
@@ -39,23 +44,22 @@ function extend( model ) {
   const {
     resolvePath,
     resolveUncheckedPath,
-    initAnnotations,
-    checkAnnotate,
+    resolveTypeArgumentsUnchecked,
     attachAndEmitValidNames,
-    checkDefinitions,
     initArtifact,
     initMembers,
-    extensionsDict,             // not a function - TODO
   } = model.$functions;
 
   Object.assign( model.$functions, {
     lateExtensions,
-    applyTypeExtensions,
     chooseAnnotationsInArtifact,
-    extensionFor,
-    copyAnnotationsForExtensions,
+    extendArtifactAfter,
   } );
 
+  const extensionsDict = Object.create(null);
+  forEachDefinition( model, tagIncludes ); // TODO TMP
+
+  forEachDefinition( model, chooseAnnotationsInArtifact );
   applyExtensions();
 
   const addTextsLanguageAssoc = checkTextsLanguageAssocOption(model, options);
@@ -63,9 +67,8 @@ function extend( model ) {
 
   Object.keys( model.definitions ).forEach( processArtifact );
 
-  lateExtensions( false );
-
   compositionChildPersistence();
+  return;
 
   /**
    * Process "composition of" artifacts.
@@ -115,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];
-          delete extensionsDict[name];
-        }
-        else if (art.$duplicates) { // cannot extend redefinitions
+        if (art && art.kind !== 'namespace' &&
+            extendArtifact( extensionsDict[name], art, noIncludes ))
           delete extensionsDict[name];
-        }
-        else if (phase === 1
-                 ? extendContext( name, art )
-                 : extendArtifact( extensionsDict[name], art, Array.isArray( phase ) && phase )) {
-          delete extensionsDict[name];
-        }
       }
       extNames = Object.keys( extensionsDict ); // no sort() required anymore
-      if (phase === 1)
-        phase = 2;
-      else if (extNames.length >= length)
-        phase = Object.keys( extensionsDict ); // = no includes
+      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;
   }
 
   /**
@@ -231,6 +586,7 @@ function extend( model ) {
     }
     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
@@ -244,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 },
@@ -267,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) {
@@ -282,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)
@@ -386,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 -- TODO: not here!
-      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.
@@ -550,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 || assignments.length > 1) { // TODO: allow in same file?
-      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
@@ -597,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 ----------------------------------------------------------------
 
   /**
@@ -693,6 +842,7 @@ function extend( model ) {
         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) {
@@ -775,6 +925,7 @@ function extend( model ) {
             //       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
         });
@@ -801,8 +952,15 @@ function extend( model ) {
     forEachInOrder(parent, prop, ( member, name ) => {
       if (member.$inferred === 'include' && Array.isArray(member.$duplicates)) {
         const includes = [ member, ...member.$duplicates ].map(dup => dup._origin._main);
-        warning( 'ref-duplicate-include-member', [ parent.name.location, member ],
-                 { '#': prop, name, sorted_arts: includes } );
+        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 } );
+        }
       }
     });
   }
@@ -933,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;
 
@@ -968,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
@@ -1005,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;
   }
 
@@ -1040,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.
@@ -1061,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;
   }
 
@@ -1098,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 = {
@@ -1110,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;
   }
 
@@ -1398,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;
   }
 
@@ -1416,138 +1577,204 @@ 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 ---------------------------------------------------
-
-  function extensionFor( art ) {
-    if (art.kind === 'annotate')
-      return art;
-    if (art._extension)
-      return art._extension;
-
-    // $extension means: already applied
-    const ext = {
-      kind: art.kind,           // set kind for setMemberParent()
-      $extension: 'exists',
-      location: art.location,    // location( extension to existing art ) = location(art)
-    };
-    const { location } = art.name;
-    if (!art._main) {
-      ext.name = {
-        path: [ { id: art.name.absolute, location } ],
-        location,
-        absolute: art.name.absolute,
-      };
-      if (model.extensions)
-        model.extensions.push(ext);
-      else
-        model.extensions = [ ext ];
-    }
-    else {
-      ext.name = { id: art.name.id, location };
-      const parent = extensionFor( art._parent );
-      const kind = kindProperties[art.kind].normalized || art.kind;
-      // enums would be first in elements
-      if ( parent[kindProperties[kind].dict]?.[art.name.id] )
-        throw new CompilerAssertion(art.name.id);
-      setMemberParent( ext, art.name.id, parent, kindProperties[kind].dict );
-    }
-    ext.kind = 'annotate';    // after setMemberParent()!
-    setLink( art, '_extension', ext );
-    setArtifactLink( ext.name, art );
-    if (art.returns)
-      ext.$syntax = 'returns';
-    return ext;
-  }
+  // 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 (const prop in art) {
-      if (prop.charAt(0) === '@')
-        chooseAssignment( prop, 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 );
     }
-    if (art.doc)
-      chooseAssignment( 'doc', art );
   }
 
-  function chooseAssignment( annoName, art ) {
-    let anno = art[annoName];
-    if (!Array.isArray( anno )) { // just one assignment -> use it
-      if (!annotationHasEllipsis( anno ))
-        return;
-      anno = [ anno ];
-    }
-    // console.log('ASSIGN:',art.name.absolute,annoName)
-    const scheduledAssignments = [];
-    // sort assignment according to layer (define is bottom layer):
-    const layeredAnnos = layeredAssignments( anno );
-    let cont = true;
-    while (cont) {
-      const { assignments, issue } = assignmentsOfHighestLayers( layeredAnnos );
-      // console.log( 'CA:', annoName, issue, assignments)
-      let index = assignments.length;
-      cont = !!index;           // safety
-      while (--index >= 0) {
-        const a = assignments[index];
-        scheduledAssignments.push( a );
-        if (!annotationHasEllipsis( a )) {
-          cont = false;
-          break;
+  // 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 );
         }
       }
-      if (issue) {
-        // eslint-disable-next-line no-nested-ternary
-        const msg = (index < 0)
-          ? 'anno-unstable-array'
-          : (issue === true)
-            ? 'anno-duplicate'
-            : 'anno-duplicate-unrelated-layer';
-        const variant = annoName === 'doc' ? 'doc' : 'std';
-        for (const a of assignments) {
-          if (!a.$errorReported) {
-            message( msg, [ a.name?.location || a.location, art ],
-                     { '#': variant, anno: annoName } );
+    }
+    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)
       }
-      else if (index > 0) {     // more than one set (not just ...)
-        const variant = annoName === 'doc' ? 'doc' : 'std';
-        while (index >= 0) {    // do not report for trailing [...]
-          const a = assignments[index--];
-          warning( 'anno-duplicate-same-file', [ a.name?.location || a.location, art ],
-                   { '#': variant, anno: annoName } );
+      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 } );
         }
       }
     }
-    // Now apply the assignments - all but the first have a '...'
-    let result = null;
-    scheduledAssignments.reverse();
-    for (const a of scheduledAssignments)
-      result = applyAssignment( result, a, art, annoName );
-    art[annoName] = result.name ? result
-      : Object.assign( {}, scheduledAssignments[scheduledAssignments.length - 1], result );
+    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 firstEllipsis = annotationHasEllipsis( anno );
-      if (!firstEllipsis)
-        return anno;
-      if (anno.$priority) {   // already complained about with Define
-        const loc = firstEllipsis.location || anno.name.location;
-        message( 'anno-unexpected-ellipsis-layers', [ loc, art ], { code: '...' } );
-      }
+      const loc = firstEllipsis.location || anno.name.location;
+      message( 'anno-unexpected-ellipsis', [ loc, art ], { code: '...' } );
       previousAnno = { val: [] };
     }
     else if (previousAnno.literal !== 'array') {
@@ -1641,69 +1868,70 @@ function extend( model ) {
     return node.variant ? `${ ref }#${ node.variant.id }` : ref;
   }
 
-  // formerly in shared.js: -----------------------------------------------------
-
-  // Copy annotations from `ext` to `art`, overwriting inferred ones.
-  // TODO: move to extend.js if not used anymore in define.js
-  function copyAnnotationsForExtensions( ext, art ) {
-    for (const annoProp in ext) {
-      if (annoProp.charAt(0) === '@' || annoProp === 'doc') {
-        const extAnno = ext[annoProp];
-        if (art[annoProp]?.$inferred)
-          art[annoProp] = extAnno; // overwrite $inferred annos
-        else
-          dictAddArray( art, annoProp, extAnno );
-      }
+  /**
+   * 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 are just assignments in one file,
- * - 'unrelated': there is just one assignment per layer
- * - true: there is at least one layer with two or more assignments, and
+ * - 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
- * TODO: make this usable for extend (elements), too.
  *
- * @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: inMoreThanOneFile( assignments ) };
+    const highest = layered[name]?.extensions || [];
+    delete layered[name];
+    return { highest, issue: inMoreThanOneFile( highest ) };
   }
 
   // collect all layers which are lower than another layer
@@ -1711,42 +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 => !inMoreThanOneFile( layer.assignments ));
+  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 inMoreThanOneFile( assignments ) {
-  if (assignments.length <= 1)
+function inMoreThanOneFile( extensions ) {
+  if (extensions.length <= 1)
     return false;
-  // annotations have no location with implicit `true`, doc have no name:
-  const file = (assignments[0].name || assignments[0]).location?.file;
-  return !file || assignments.slice(1).some( a => (a.name || a).location?.file !== file );
+  const file = extensions[0].location?.file;
+  return !file || extensions.slice(1).some( e => e.location?.file !== file );
 }
 
 /**
- * Compare two assignments which are not comparable via layering:
- * - via the fs.realpath of the file (not layer!) of the assignments, then
- * - via the line, then column of the assignments.
+ * 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 compareAssignments( a, b ) {
+function compareExtensions( a, b ) {
   const fileA = layers.realname( a._block );
   const fileB = layers.realname( b._block );
   if (fileA !== fileB)
@@ -1755,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)
@@ -1811,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'];