@sap/cds-compiler 3.1.2 → 3.4.0

package/lib/compiler/resolve.js

@@ -69,7 +69,6 @@ const {
 } = require('./utils');
 
 const detectCycles = require('./cycle-detector');
-const layers = require('./moduleLayers');
 
 const $location = Symbol.for('cds.$location');
 
@@ -88,14 +87,18 @@ function resolve( model ) {
   const {
     resolvePath,
     checkAnnotate,
-    defineAnnotations,
+    initAnnotations,
+    copyAnnotationsForExtensions,
     attachAndEmitValidNames,
     lateExtensions,
+    applyTypeExtensions,
     effectiveType,
     directType,
     resolveType,
     resolveTypeArgumentsUnchecked,
     populateQuery,
+    layeredAssignments,
+    assignmentsOfHighestLayers,
   } = model.$functions;
   const { environment } = model.$volatileFunctions;
   Object.assign( model.$functions, {
@@ -168,15 +171,7 @@ function resolve( model ) {
     for (const name in query.elements) {
       const elem = query.elements[name];
       // no key prop for duplicate elements or additional specified elements:
-      if (elem.$duplicates || !elem.value)
-        continue;
-      const nav = pathNavigation( elem.value );
-      if (!nav.navigation)
-        continue;            // undefined, expr, $magic, :const, $self (!), $self.elem
-      const { item } = nav;
-      if (item !== elem.value.path[elem.value.path.length - 1])
-        continue;         // having selected a sub elem / navigated along assoc
-      const { key } = item._artifact;
+      const key = !elem.$duplicates && !elem.expand && inheritedSourceKeyProp( elem );
       if (key) {
         if (!doIt)
           return true;
@@ -186,6 +181,20 @@ function resolve( model ) {
     return false;
   }
 
+  function inheritedSourceKeyProp( { value, _pathHead } ) {
+    if (!value || !value.path)
+      return null;
+    const nav = pathNavigation( value );
+    const item = value.path[value.path.length - 1];
+    if (nav.navigation && nav.item === item)
+      return item._artifact?.key;
+    if (value.path.length !== 1 || _pathHead?.kind !== '$inline')
+      return null;
+    const hpath = _pathHead.value?.path;
+    const head = hpath?.length === 1 && hpath[0]._navigation;
+    return head?.kind === '$tableAlias' && item._artifact?.key;
+  }
+
   function primarySourceNavigation( aliases ) {
     for (const name in aliases)
       return aliases[name].elements;
@@ -240,6 +249,7 @@ function resolve( model ) {
     function selectTest( expr ) {
       const art = withAssociation( expr, targetMaxNotOne );
       if (art) {
+        // ID published! Used in stakeholder project; if renamed, add to oldMessageIds
         info( 'query-navigate-many', [ art.location, query ], { art },
               {
                 // eslint-disable-next-line max-len
@@ -314,9 +324,10 @@ function resolve( model ) {
       // TODO: shouldn't be this part of populate.js ?
       const items = {
         location: weakLocation( (obj.type || obj).location ),
-        $inferred: 'expand-items',
+        $inferred: 'expanded',
       };
       setLink( items, '_outer', obj );
+      setLink( items, '_parent', obj._parent );
       setLink( items, '_origin', type.items );
       obj.items = items;
       obj.$expand = 'origin';
@@ -361,7 +372,7 @@ function resolve( model ) {
       }
     }
     if (obj.target) {
-      // console.log(obj.name,obj._origin.name)
+      // console.log(obj.name,obj._origin?.name,obj)
       if (obj._origin && obj._origin.$inferred === 'REDIRECTED')
         resolveTarget( art, obj._origin );
       // console.log(error( 'test-target', [ obj.location, obj ],
@@ -511,9 +522,9 @@ function resolve( model ) {
       setArtifactLink( ext.name, art );
 
       if (art) {
-        if (art.kind === 'annotate')
-          checkAnnotate( ext, art );
-        defineAnnotations( ext, art, ext._block, ext.kind );
+        checkAnnotate( ext, art );
+        initAnnotations( ext, ext._block, ext.kind ); // TODO: do in define.js
+        copyAnnotationsForExtensions( ext, art );
         // eslint-disable-next-line no-shadow
         forEachMember( ext, ( elem, name, prop ) => {
           storeExtension( elem, name, prop, art, ext._block );
@@ -555,7 +566,7 @@ function resolve( model ) {
         }
       }
     }
-    if (art && art._annotate) {
+    if (art?._annotate) {
       if (art.kind === 'action' || art.kind === 'function') {
         expandParameters( art );
         if (art.returns)
@@ -579,6 +590,15 @@ function resolve( model ) {
       //     annotateMembers( env && env[n], dict[n], 'elements', n, parent, 'element' );
       // }
     }
+
+    if (art?._extendType) {
+      // Only works because annotateMembers is called in resolveRefs() _after_ `.type` was resolved.
+      // TODO: If we allow extending included elements, we may need custom $expand,
+      //       similar to annotate above.
+      art._extendType.forEach(resolveRefs);
+      applyTypeExtensions(art);
+    }
+
     return;
 
     function notFound( msgId, location, address, args, validDict ) {
@@ -632,7 +652,7 @@ function resolve( model ) {
           // not to create proxies
           const orig = origin.params[name];
           linkToOrigin( orig, name, art, 'params', weakLocation( orig.location ), true )
-            .$inferred = 'expand-param';
+            .$inferred = 'expanded';
         }
       }
       if (!art.returns && origin.returns) {
@@ -642,7 +662,7 @@ function resolve( model ) {
           name: Object.assign( {}, art.name, { id: '', param: '', location } ),
           kind: 'param',
           location,
-          $inferred: 'expand-param',
+          $inferred: 'expanded',
         };
         setLink( art.returns, '_parent', art );
         setLink( art.returns, '_main', art._main || art );
@@ -751,90 +771,21 @@ function resolve( model ) {
       : Object.assign( {}, scheduledAssignments[scheduledAssignments.length - 1], result );
   }
 
-  // Group assignments by their layers.  An assignment provided with a definition
-  // 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
-  function layeredAssignments( assignment ) {
-    const layered = Object.create(null);
-    for (const a of assignment) {
-      const layer = a.$priority && layers.layer( a );
-      // just consider layer if Extend/Annotate, not Define
-      const name = (layer) ? layer.realname : '';
-      const done = layered[name];
-      if (done)
-        done.assignments.push( a );
-      else
-        layered[name] = { name, layer, assignments: [ a ] };
-      // TODO: file - if set: unique in layer
-    }
-    return layered;
-  }
-
-  // Return assignments of the highest layers.
-  // Also return 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
-  function assignmentsOfHighestLayers( layeredAnnos ) {
-    const layerNames = Object.keys( layeredAnnos );
-    // 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 };
-    }
-
-    // collect all layers which are lower than another layer
-    const allExtends = Object.create(null);
-    allExtends[''] = {};        // the "Define" layer
-    for (const name of layerNames) {
-      if (name)                 // not the "Define" layer
-        Object.assign( allExtends, layeredAnnos[name].layer._layerExtends );
-    }
-    // console.log('HIE:',Object.keys(allExtends))
-    const assignments = [];
-    const highest = [];
-    for (const name of layerNames) {
-      if (!(name in allExtends)) {
-        const layer = layeredAnnos[name];
-        delete layeredAnnos[name];
-        highest.push( layer );
-        assignments.push( ...layer.assignments );
-      }
-    }
-    assignments.sort( compareAssignments );
-    const good = highest.every( layer => layer.assignments.length === 1 );
-    // 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 };
-  }
-
-  function compareAssignments( a, b ) {
-    const fileA = layers.realname( a._block );
-    const fileB = layers.realname( b._block );
-    if (fileA !== fileB)
-      return (fileA > fileB) ? 1 : -1;
-    return (a?.location?.line || 0) - (b?.location?.line || 0) ||
-           (a?.location?.col || 0) - (b?.location?.col || 0);
-  }
-
   function applyAssignment( previousAnno, anno, art, annoName ) {
+    const hasBase = previousAnno?.literal === 'array';
     if (!previousAnno) {
-      if (!annotationHasEllipsis( anno ))
+      const firstEllipsis = annotationHasEllipsis( anno );
+      if (!firstEllipsis)
         return anno;
       if (anno.$priority) {   // already complained about with Define
-        message( 'anno-unexpected-ellipsis-layers', // TODO: better location
-                 [ anno.name.location, art ], { code: '...' } );
+        const loc = firstEllipsis.location || anno.name.location;
+        message( 'anno-unexpected-ellipsis-layers', [ loc, art ], { code: '...' } );
       }
       previousAnno = { val: [] };
     }
     else if (previousAnno.literal !== 'array') {
-      error( 'anno-mismatched-ellipsis', // TODO: better location
-             [ anno.name.location, art ], { code: '...' } );
+      // 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;
@@ -855,7 +806,8 @@ function resolve( model ) {
             break;
           }
         }
-        if (upToSpec) {       // non-matched UP TO
+        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)' );
         }
@@ -1045,7 +997,7 @@ function resolve( model ) {
     else if (obj.type && !obj.type.$inferred && art._parent && art._parent.kind === 'select') {
       // New association in views, i.e. parent is a query.
       error( 'query-expected-on-condition', [ obj.target.location, art ], {},
-             'Expected on-condition for published association' );
+             'Expected ON-condition for published association' );
       return; // avoid subsequent errors
     }
     else if (target && !obj.foreignKeys && target.kind === 'entity') {
@@ -1128,6 +1080,11 @@ function resolve( model ) {
              'Only an association can be redirected' );
       return;
     }
+    else if ((elem.value || elem.expand) && elem.type && !elem.type.$inferred) {
+      error( 'ref-unexpected-assoc', [ elem.type.location, elem ], {},
+             'Casting to an association is not supported' );
+      return;
+    }
     // console.log(message( null, elem.location, elem, {target,art:assoc}, 'Info','RE')
     //             .toString(), elem.value)
     const nav = elem._main && elem._main.query && elem.value && pathNavigation( elem.value );
@@ -1135,7 +1092,7 @@ function resolve( model ) {
       if (!elem.on && origType.on) {
         error( 'rewrite-not-supported', [ elem.target.location, elem ], {},
                // TODO: Better text ?
-               'The ON condition is not rewritten here - provide an explicit ON condition' );
+               'The ON-condition is not rewritten here - provide an explicit ON-condition' );
         return;
       }
     }
@@ -1148,6 +1105,7 @@ function resolve( model ) {
       if (!elem.target.$inferred && !elem.on && !elem.foreignKeys) {
         // Only a managed redirection gets this info message.  Because otherwise
         // we'd have to check whether on-condition/foreignKeys are the same.
+        // ID published! Used in stakeholder project; if renamed, add to oldMessageIds
         info( 'redirected-to-same', [ elem.target.location, elem ], { art: target },
               'The redirected target is the original $(ART)' );
       }
@@ -1162,12 +1120,17 @@ function resolve( model ) {
       if (!from)
         return;                 // parse error - TODO: or UNION?
       if (!from.path) {
-        warning( 'redirected-to-complex', [ elem.target.location, elem ],
-                 { art: target, '#': target === elem.target._artifact ? 'target' : 'std' },
-                 {
-                   std: 'Redirection involves the complex view $(ART)',
-                   target: 'The redirected target $(ART) is a complex view',
-                 });
+        const isTarget = target === elem.target._artifact;
+        const op = from.op?.val || target.query.op?.val;
+        const variant = (!isTarget && 'std') || (op && 'targetOp') || 'target';
+        // ID published! Used in stakeholder project; if renamed, add to oldMessageIds
+        info( 'redirected-to-complex', [ elem.target.location, elem ],
+              { art: target, '#': variant, keyword: op || '' }, {
+                std: 'Redirection involves the complex view $(ART)',
+                target: 'The redirected target $(ART) is a complex view',
+                // eslint-disable-next-line max-len
+                targetOp: 'The redirected target $(ART) is a complex view with $(KEYWORD)',
+              });
         break;
       }
       target = from._artifact;
@@ -1301,13 +1264,13 @@ function resolve( model ) {
 
           let variant;
           if (type.builtin)
-          // `.type` is already a builtin: use a nicer message.
+            // `.type` is already a builtin: use a nicer message.
             variant = 'builtin';
           else if (effectiveTypeArt.builtin)
-          // base type is a builtin, i.e. a scalar
+            // base type is a builtin, i.e. a scalar
             variant = 'type';
           else
-          // effectiveType is not a builtin -> array or structured
+            // effectiveType is not a builtin -> array or structured
             variant = 'non-scalar';
 
           error('type-unexpected-argument', [ artWithType[param].location, artWithType ], {
@@ -1432,7 +1395,7 @@ function resolve( model ) {
     }
     const exp = (expected === 'from') ? 'expr' : expected;
     if (Array.isArray(dict)) {
-      message( 'args-expected-named', [ dict[0] && dict[0].location || stepLocation, user ],
+      message( 'args-expected-named', [ dict[0] && dict[0].location || stepLocation, user ], {},
                'Named parameters must be provided for the entity' );
       for (const a of dict)
         resolveExpr( a, exp, user, extDict );

package/lib/compiler/shared.js

@@ -12,7 +12,6 @@ const {
   setArtifactLink,
   dependsOn,
   pathName,
-  annotationHasEllipsis,
 } = require('./utils');
 
 function artifactsEnv( art ) {
@@ -87,6 +86,11 @@ function fns( model ) {
       expectedMsgId: 'expected-struct',
       envFn: artifactsEnv,
     },
+    viewInclude: {
+      check: checkViewIncludesRef,
+      expectedMsgId: 'ref-expecting-bare-aspect',
+      envFn: artifactsEnv,
+    },
     target: {
       check: checkEntityRef,
       expectedMsgId: 'expected-entity',
@@ -135,15 +139,22 @@ function fns( model ) {
       dollar: true,
       rootEnv: 'elements',      // the final environment for the path root
       noDep: true,              // do not set dependency for circular-check
+      allowSelf: true,
     }, // TODO: special assoc for only on user
     'mixin-on': {
       escape: 'param',    // TODO: extra check that assocs containing param in ON is not published
       next: '_$next',           // TODO: lexical: ... how to find the (next) lexical environment
       dollar: true,
       noDep: true,              // do not set dependency for circular-check
+      allowSelf: true,
     }, // TODO: special assoc for only on user
     rewrite: {
-      next: '_$next', dollar: true, escape: 'param', noDep: true, rewrite: true,
+      next: '_$next',
+      dollar: true,
+      escape: 'param',
+      noDep: true,
+      allowSelf: true,
+      rewrite: true,
     }, // TODO: assertion that there is no next/escape used
     'order-by': {
       next: '_$next',
@@ -153,7 +164,11 @@ function fns( model ) {
       deprecatedSourceRefs: true,
     },
     'order-by-union': {
-      next: '_$next', dollar: true, escape: 'param', noDep: true, noExt: true,
+      next: '_$next',
+      dollar: true,
+      escape: 'param',
+      noDep: true,
+      noExt: true,
     },
     // expr TODO: better - on condition for assoc, other on
     // expr TODO: write dependency, but care for $self
@@ -169,7 +184,7 @@ function fns( model ) {
     resolveTypeArgumentsUnchecked,
     resolvePath,
     checkAnnotate,
-    defineAnnotations,
+    copyAnnotationsForExtensions,
     attachAndEmitValidNames,
   } );
   return;
@@ -183,7 +198,22 @@ function fns( model ) {
     // - derived structure types: would have to follow type in extend/include;
     // - entities with params: clarify inheritance, use of param in ON/DEFAULT;
     // - query entities/events: difficult sequence of resolve steps
-    return !(art.elements && !art.query && !art.type && !art.params);
+    // - aspect without elements (useful for actions/annotations)
+    return !(art.elements && !art.query && !art.type && !art.params) && art.kind !== 'aspect';
+  }
+
+  /**
+   * Returns true, if the given artifact can be included by a query entity / view.
+   *
+   * We currently allow:
+   * - aspects without elements (the aspect may have actions):
+   *   either no `elements` property or empty dictionary
+   *
+   * @param {XSN.Artifact} art
+   * @return {boolean}
+   */
+  function checkViewIncludesRef( art ) {
+    return !(art.kind === 'aspect' && (!art.elements || Object.keys(art.elements).length === 0));
   }
 
   /**
@@ -331,7 +361,8 @@ function fns( model ) {
       return setArtifactLink( ref, art );
     }
     else if (!spec.envFn && user._pathHead) {
-      // eslint-disable-next-line no-empty
+      if (art.kind === '$self')
+        rejectBareSelf( spec, path, user, extDict );
     }
     else if (art.kind === 'using') {
       const def = model.definitions[art.name.absolute];
@@ -374,7 +405,10 @@ function fns( model ) {
       // TODO: set art?
     }
     else if (art.kind === '$tableAlias' || art.kind === '$self') {
-      if (spec.noAliasOrMixin && art.kind !== '$self') { // TODO: extra kind $self?
+      if (art.kind === '$self') {
+        rejectBareSelf( spec, path, user, extDict );
+      }
+      else if (spec.noAliasOrMixin) {
         // TODO: good enough for now - change later to not search for table aliases at all
         signalNotFound( 'ref-rejected-on', [ head.location, user ], extDict && [ extDict ],
                         { '#': 'alias', id: head.id } );
@@ -447,6 +481,15 @@ function fns( model ) {
     return setArtifactLink( ref, art );
   }
 
+  function rejectBareSelf( spec, path, user, extDict ) {
+    if (path.length === 1 && !spec.allowSelf && !user.expand && !user.inline) {
+      const head = path[0];
+      // TODO: extra text variant for JOIN-ON (if we have an extra `expected`)
+      signalNotFound( 'ref-unexpected-self', [ head.location, user ], extDict && [ extDict ],
+                      { id: head.id } );
+    }
+  }
+
   // Issue errors for "smart" element-in-artifact references
   // without a colon; and errors for misplaced colons in references.
   // This function likely disappears again in cds-compiler v2.x.
@@ -534,16 +577,21 @@ function fns( model ) {
   // if the artifact does not exist.  Return a "fresh" artifact for
   // non-existing external using references if `unchecked` is truthy.
   function getPathRoot( path, spec, user, env, extDict, msgArt ) {
-    if (!spec.envFn && user._pathHead) {
-      // TODO: not necessarily for explicit ON condition in expand
+    const head = path[0];
+    if (!head || !head.id || !env)
+      return undefined;         // parse error
+    if (!spec.envFn && user._pathHead && head.id.charAt(0) !== '$') {
+      if (spec.rootEnv === 'elements') { // ON condition in expand/inline
+        let root = user._pathHead;
+        while (root.kind === '$inline')
+          root = root._parent;
+        return root;
+      }
       VolatileFns.environment( user._pathHead ); // make sure _origin is set
       return user._pathHead._origin;
       // const { _origin } = user._pathHead;
       // return (_origin && _origin.kind === '$tableAlias') ? _origin._origin : _origin;
     }
-    const head = path[0];
-    if (!head || !head.id || !env)
-      return undefined;         // parse error
     // if (head.id === 'k') {console.log(Object.keys(user));throw Error(JSON.stringify(user.name))}
     // if head._artifact is set or is null then it was already computed once
     if ('_artifact' in head)
@@ -576,7 +624,7 @@ function fns( model ) {
             message( 'ref-obsolete-parameters', [ head.location, user ],
                      { code: `$parameters.${ path[1].id }`, newcode: `:${ path[1].id }` },
                      'Obsolete $(CODE) - replace by $(NEWCODE)' );
-            // TODO: replace it in to-csn correspondingly
+            // TODO: replace it in to-csn correspondingly  !!!
             return setArtifactLink( head, r );
           }
         }
@@ -665,8 +713,7 @@ function fns( model ) {
                         { art: searchName( msgArt, head.id, 'element' ) } );
       }
       else {
-        signalNotFound( 'ref-undefined-var', [ head.location, user ], valid, { id: head.id },
-                        'Element or variable $(ID) has not been found' );
+        signalNotFound( 'ref-undefined-var', [ head.location, user ], valid, { id: head.id } );
       }
     }
     else if (env.$frontend && env.$frontend !== 'cdl' || spec.global) {
@@ -685,6 +732,9 @@ function fns( model ) {
   // search environment (for the first path item) is `arg`.  For messages about
   // missing artifacts (as opposed to elements), provide the `head` (first
   // element item in the path)
+  // TODO - think about setting _navigation for all $navElement – the
+  // "ref: ['tabAlias']: inline: […]" handling might be easier
+  // (no _pathHead consultation for key prop and renaming support)
   function getPathItem( path, spec, user, artItemsCount, headArt ) {
     // let art = (headArt && headArt.kind === '$tableAlias') ? headArt._origin : headArt;
     let art = headArt;
@@ -796,13 +846,11 @@ function fns( model ) {
         // TODO: views elements are proxies to query-0 elements, not the same
         // TODO: better message text
         signalNotFound( 'query-undefined-element', [ item.location, user ],
-                        [ env ], { id: item.id },
-                        'Element $(ID) has not been found in the elements of the query' );
+                        [ env ], { id: item.id } );
       }
       else if (art.kind === '$parameters') {
         signalNotFound( 'ref-undefined-param', [ item.location, user ],
-                        [ env ], { art: searchName( art._main, item.id, 'param' ) },
-                        { param: 'Entity $(ART) has no parameter $(MEMBER)' } );
+                        [ env ], { art: art._main, id: item.id } );
       }
       else {
         const variant = art.kind === 'aspect' && !art.name && 'aspect';
@@ -824,14 +872,13 @@ function fns( model ) {
    * @param {any} location
    * @param {object[]} valid
    * @param  {object} [textParams]
-   * @param  {any} [texts]
    */
-  function signalNotFound(msgId, location, valid, textParams, texts ) {
+  function signalNotFound(msgId, location, valid, textParams ) {
     if (location.$notFound)
       return;
     location.$notFound = true;
     /** @type {object} */
-    const err = message( msgId, location, textParams, texts );
+    const err = message( msgId, location, textParams );
     if (valid)
       attachAndEmitValidNames(err, ...valid.reverse());
   }
@@ -889,6 +936,8 @@ function fns( model ) {
   // (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?
+
     // Namespaces cannot be annotated in CSN but because they exist as XSN artifacts
     // they can still be applied. Namespace annotations are extracted in to-csn.js
     // In parseCdl mode USINGs and other unknown references are generated as
@@ -914,44 +963,23 @@ function fns( model ) {
     }
   }
 
-  // Set _block links for annotations (necessary for layering).
-  // Also copy annotations from `construct` to `art` (TODO: separate that functionality).
-  function defineAnnotations( construct, art, block, priority = false ) {
-    if (construct.doc)
-      art.doc = construct.doc; // e.g. through `extensions` array in CSN
-
-    // set _block (for layering) and $priority, shallow-copy from extension
-    // TODO: think of removing $priority, then
-    // no _block: define, _block: annotate/extend/edmx
-    // would fit with extending defs with props like length
-    for (const annoProp in construct) {
+  // 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 ) {
+    if (ext.doc)
+      art.doc = ext.doc; // e.g. through `extensions` array in CSN
+    for (const annoProp in ext) {
       if (annoProp.charAt(0) === '@') {
-        let annos = construct[annoProp];
-        if (!(Array.isArray(annos)))
-          annos = [ annos ];
-        for (const a of annos) {
-          setLink( a, '_block', block );
-          a.$priority = priority; // is now: undefined (auto-set) | false | 'annotate' | 'extend'
-          if (construct !== art)
-            addAnnotation( art, annoProp, a );
-          if (!priority && annotationHasEllipsis( a )) {
-            error( 'anno-unexpected-ellipsis',
-                   [ a.name.location, art ], { code: '...' } );
-          }
-        }
+        const extAnno = ext[annoProp];
+        if (art[annoProp]?.$inferred)
+          art[annoProp] = extAnno; // overwrite $inferred annos
+        else
+          dictAddArray( art, annoProp, extAnno );
       }
     }
   }
 }
 
-// Add annotation to definition - overwriting $inferred annos
-function addAnnotation( art, annoProp, anno ) {
-  const old = art[annoProp];
-  if (old && old.$inferred)
-    delete art[annoProp];
-  dictAddArray( art, annoProp, anno );
-}
-
 module.exports = {
   fns,
 };