@sap/cds-compiler 6.9.2 → 7.0.1

package/lib/compiler/extend.js

@@ -4,7 +4,6 @@
 
 const { weakRefLocation } = require('../base/location');
 const { searchName } = require('../base/messages');
-const { isDeprecatedEnabled } = require('../base/specialOptions');
 const { dictAdd, pushToDict, dictForEach } = require('./dictionaries');
 const { kindProperties, dictKinds } = require('./base');
 const {
@@ -17,7 +16,6 @@ const {
   setMemberParent,
   createAndLinkCalcDepElement,
   initExprAnnoBlock,
-  initDollarSelf,
   initBoundSelfParam,
   dependsOnSilent,
   pathName,
@@ -81,9 +79,6 @@ function extend( model ) {
     applyIncludes,              // TODO: re-check
   } );
 
-  const includesNonShadowedFirst
-    = isDeprecatedEnabled( model.options, '_includesNonShadowedFirst' );
-
   const includeCollisions = [];
 
   forEachGeneric( model, 'definitions', tagCompositionTargets );
@@ -186,6 +181,7 @@ function extend( model ) {
       for (const prop in art._extensions) {
         if (Object.hasOwn( art._extensions, prop ) &&
             // remark: if we change the array, consider whether to delete the artifact
+            // TODO: what is the `$gen`?  `$add` is handled...
             ![ 'elements', 'actions', 'params', '$gen' ].includes( prop ))
           applyPropertyExtensions( art, prop );
       }
@@ -292,7 +288,7 @@ function extend( model ) {
 
   /**
    * Applying extensions is handled in extendArtifactAfter(). And only afterward,
-   * an effective sequence number is set.  Meaning that if a sub-artifact already
+   * an effective sequence number is set.  Meaning that if a sub artifact already
    * has a sequence number, then extensions would be lost.
    *
    * A special case are foreign keys, see extendForeignKeys().
@@ -425,6 +421,8 @@ function extend( model ) {
         }
         else if (prop === 'returns') {
           pushToDict( dict, 'elements', ext );
+          if (hasSecurityAnno( ext.returns ))
+            checkReturnsExtension( ext, ext );
           // create 'returns' for the super annotate, store in elements anyway
           if (!art.returns && art.kind === 'annotate')
             annotateCreate( art, '', art, 'returns' );
@@ -498,10 +496,12 @@ function extend( model ) {
     }
     // Now apply the relevant extensions
     scheduled.reverse();
+    art.$postponeInclude ??= 0; // add elems of includes before direct ones
     if (prop === 'includes' && !art.includes?.$original) {
       const $original = art.includes ?? [];
       art.includes = [ ...$original ];
       art.includes.$original = $original;
+      // console.log('APE:',art.name.id,art.includes.map( r => r._artifact?.name.id ))
     }
     if (prop === '$add') {
       extensions[prop] = scheduled;
@@ -703,7 +703,7 @@ function extend( model ) {
         result.push( item );
       }
       else {
-        let upToSpec = item.upTo && checkUpToSpec( item.upTo, art, annoName, true );
+        let upToSpec = !item.$errorReported && item.upTo;
         while (prevPos < previousValue.length) {
           const prevItem = previousValue[prevPos++];
           result.push( prevItem );
@@ -728,40 +728,18 @@ function extend( model ) {
       location: previousAnno.location,
     };
   }
-  // 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 @stylistic/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;
-  }
+  // For the `up to` specification, see ../../test3/Annotations/EllipsisUpTo/
 
   function equalUpTo( previousItem, upToSpec ) {
     if (!previousItem)
       return false;
-    if ('val' in upToSpec) {
+
+    if (upToSpec.sym)           // enum symbol (literal: 'enum')
+      return previousItem.sym?.id === upToSpec.sym.id;
+    if (upToSpec.val !== undefined) {        // not struct, ref or non-val expression
       if (previousItem.val === upToSpec.val) // enum, struct and ref have no val
         return true;
-      // TODO v6: delete the special UP TO comparison?
       const upToVal = upToSpec.val;
       const prevVal = previousItem.val;
       // eslint-disable-next-line eqeqeq
@@ -769,17 +747,27 @@ function extend( model ) {
         ( typeof upToVal === 'number' && stringCouldHaveBeenCdlNumber( prevVal ) ||
           typeof prevVal === 'number' && stringCouldHaveBeenCdlNumber( upToVal ) );
     }
-    else if (upToSpec.path) {
-      return previousItem.path && normalizeRef( previousItem ) === normalizeRef( upToSpec );
-    }
-    else if (upToSpec.sym) {
-      return previousItem.sym && previousItem.sym.id === upToSpec.sym.id;
+
+    if (upToSpec.path) {
+      // console.log(upToSpec.location+'',normalizeRef( upToSpec ),previousItem.struct?.['='])
+      return (previousItem.path)
+        ? normalizeRef( upToSpec ) === normalizeRef( previousItem )
+        : normalizeRef( upToSpec ) === previousItem.struct?.['=']?.val &&
+          (!upToSpec.$tokenTexts || Object.keys( previousItem.struct ).length === 1);
     }
-    else if (upToSpec.struct && previousItem.struct) {
-      return Object.entries( upToSpec.struct )
-        .every( ([ n, v ]) => equalUpTo( previousItem.struct[n], v ) );
+    if (!upToSpec.struct)
+      return false;
+
+    const { struct } = previousItem;
+    if (struct) {
+      const entries = Object.entries( upToSpec.struct );
+      // {} does not match { "=": "ref" }, but { prop: … } and { "=": "ref", more: … }
+      return (entries.length)
+        ? entries.every( ([ n, v ]) => equalUpTo( previousItem.struct[n], v ) )
+        : !struct['='] || Object.keys( struct ).length > 1;
     }
-    return false;
+    return previousItem.path && Object.keys( upToSpec.struct ).length === 1 &&
+      normalizeRef( previousItem ) === upToSpec.struct['=']?.val;
   }
 
   // We only compare a string by number if the string is not empty, and could have
@@ -794,7 +782,7 @@ function extend( model ) {
 
   function normalizeRef( node ) { // see to-csn.js
     const ref = pathName( node.path );
-    // TODO: get rid of name.variant (induces a wrong structure anyway)
+    // TODO XSN 7.1: get rid of name.variant (induces a wrong structure anyway)
     return node.variant ? `${ ref }#${ pathName( node.variant.path ) }` : ref;
   }
 
@@ -886,11 +874,10 @@ function extend( model ) {
       return;
 
     for (const ext of extensions) {
-      let dictCheck = (art.kind !== 'annotate'); // no check in super annotate statement
       forEachGeneric( ext, extProp || (ext.enum ? 'enum' : 'elements'), ( elemExt, name ) => {
         if (elemExt.kind !== 'annotate' && elemExt.kind !== 'extend') // TODO: specified elems
           return;             // definitions inside extend, already handled
-        dictCheck = dictCheck && checkRemainingMemberExtensions( art, elemExt, artProp, name );
+        checkRemainingMemberExtensions( art, elemExt, artProp, name );
         const elem = art[artProp]?.[name] || annotateFor( art, extProp || 'elements', name );
         setLink( elemExt.name, '_artifact', (elem.kind !== 'annotate' ? elem : null ) );
         // TODO: why null for annotate?
@@ -948,13 +935,7 @@ function extend( model ) {
       ? 'ext-unexpected-returns-sec'
       : 'ext-unexpected-returns';
     message( msgId, [ ext.returns.location, ext ],
-             { '#': art.kind, keyword: 'returns' },
-             {
-               std: 'Unexpected $(KEYWORD); only actions and functions have return parameters',
-               action: 'Unexpected $(KEYWORD) for action without return parameter',
-               // function without `returns` can happen via CSN input! TODO: check in parser
-               function: 'Unexpected $(KEYWORD) for function without return parameter',
-             } );
+             { '#': art.kind, keyword: 'returns' } );
     // Do not put completely wrong returns into a “super annotate” statement;
     // this could induce consequential errors with [..., …]:
     return art.kind === 'action' || art.kind === 'function';
@@ -983,7 +964,10 @@ function extend( model ) {
     // (i.e. not put into the "super annotate").
     const dict = parent[prop];
     const securityRelevant = hasSecurityAnno( ext ) ? '-sec' : '';
+    const inSuperAnnotate = (parent.kind === 'annotate');
     if (!dict && !securityRelevant) {
+      if (inSuperAnnotate)      // no check in super annotate statement
+        return;
       // TODO: check - for each name? - better locations
       const location = ext._parent?.[prop]?.[$location] || ext.name.location;
       // Remark: no `elements` dict location with `annotate Main:elem`
@@ -1007,7 +991,7 @@ function extend( model ) {
           break;
         case 'actions':
           if (canBeDraftMember( name, parent, draftBoundActions ))
-            return true;
+            return;
           // TODO: use extra text variant and location of dictionary - no
           notFound( 'ext-undefined-action', ext.name.location, ext,
                     { '#': 'action', art: parent, name } );
@@ -1016,9 +1000,10 @@ function extend( model ) {
           if (model.options.testMode)
             throw new CompilerAssertion(`Missing case for prop: ${ prop }`);
       }
-      return false;
     }
     else if (!dict?.[name]) {
+      if (inSuperAnnotate && !securityRelevant)
+        return;       // there was already a warning for the parent
       // TODO: make variant `returns` an auto-variant for ($ART) ?
       const inReturns = parent._parent?.returns;
       switch (prop) {
@@ -1055,7 +1040,6 @@ function extend( model ) {
             throw new CompilerAssertion(`Missing case for prop: ${ prop }`);
       }
     }
-    return true;
   }
 
   function notFound( msgId, location, address, args, validDict ) {
@@ -1080,10 +1064,10 @@ function extend( model ) {
             annotate[prop] = art[prop];
         }
       }
-      if (extensions.length === 1) { // i.e. no proper location if from more than one extension
-        annotate.location = extensions[0].location;
-        annotate.name.location = extensions[0].name.location;
-      }
+    }
+    if (extensions?.length === 1) { // i.e. no proper location if from more than one extension
+      annotate.location = extensions[0].location;
+      annotate.name.location = extensions[0].name.location;
     }
     extendArtifactBefore( annotate );
     extendArtifactAfter( annotate );
@@ -1158,13 +1142,26 @@ function extend( model ) {
 
   // extend, mainly old-style ---------------------------------------------------
 
+  function addedElements( art ) {
+    return Object.values( art.elements )
+      .reduce( ( acc, elem ) => (elem.kind === 'extend' ? acc : acc + 1), 0 );
+  }
+
+  /**
+   * Extend artifact with additional elements and actions: via includes and/or
+   * extensions.  This happens _after_ `populateArtifact`, i.e. after eventually
+   * having inferred the elements/... from an "origin".
+   */
   function extendArtifactAdd( art ) {
     const { includes } = art;
     if (includes) {
       if (includes.$original)              // if extensions with includes:
         art.includes = includes.$original; // original includes have been stored
       if (art.includes?.length)
-        applyIncludes( art, art );
+        applyIncludes( art, art ); // apply includes provided with definition
+      else if (art.elements)       // next include only after elements so far
+        art.$postponeInclude += addedElements( art );
+
       art.includes = includes;
       // early propagation of specific annotation assignments
       // TODO: propagate in effectiveType() ?
@@ -1172,7 +1169,7 @@ function extend( model ) {
       propagateEarly( art, '@fiori.draft.enabled' );
     }
     if (art._extensions?.$add)
-      extendArtifact( art._extensions.$add, art );
+      extendArtifact( art._extensions.$add, art ); // apply extensions
     checkRedefinitionThroughIncludes( art, 'elements' );
     checkRedefinitionThroughIncludes( art, 'actions' );
   }
@@ -1225,6 +1222,7 @@ function extend( model ) {
   }
 
   function extendMembers( extensions, art ) {
+    // only called in extendArtifact()
     // TODO: do the whole extension stuff lazily if the elements are requested
     const elemExtensions = [];
     // if (art._main)              // extensions already sorted for main artifacts
@@ -1246,7 +1244,9 @@ function extend( model ) {
       //                      'Info', 'EXT').toString())
       setArtifactLink( ext.name, art ); // TODO: probably already done
       if (ext.includes)
-        applyIncludes( ext, art );
+        applyIncludes( ext, art ); // moves included elem to extension(! TODO: recheck)
+      else if (ext.elements)
+        art.$postponeInclude += addedElements( ext );
 
       // console.log(ext,art)
       checkAnnotate( ext, art );
@@ -1364,19 +1364,21 @@ function extend( model ) {
    * Set property `_parent` for all elements in `parent` to `parent` and do so
    * recursively for all sub elements.
    *
-   * If not for extensions: construct === parent
+   * If `construct !== parent`, also copy elements to `parent`.
+   *
+   * (Only) if called recursively: `construct === parent`
    *
    * TODO: separate extension!
    */
   function initMembers( construct, parent, block ) {
+    // only called by extendMembers() and recursively
     // TODO: split extend from init
+    const obj = initItemsLinks( construct, block );
+    initExprAnnoBlock( construct, block, error );
+    if (parent.targetAspect?.elements)
+      parent = parent.targetAspect;
     const main = parent._main || parent;
     const isQueryExtension = construct.kind === 'extend' && main.query;
-    let obj = initItemsLinks( construct, block );
-    initExprAnnoBlock( construct, block );
-    const { targetAspect } = obj;
-    if (targetAspect?.elements)
-      initAnonymousAspect();
 
     if (obj !== parent && obj.elements && parent.enum) { // applying the extension
       initElementsAsEnum();
@@ -1436,42 +1438,6 @@ function extend( model ) {
       forEachGeneric( { enum: obj.elements }, 'enum', init );
     }
 
-    function initAnonymousAspect() {
-      // TODO: main?
-      const inEntity = parent._main?.kind === 'entity';
-      // TODO: also allow indirectly (component in component in entity)?
-      setLink( targetAspect, '_outer', obj );
-      setLink( targetAspect, '_parent', parent._parent );
-      setLink( targetAspect, '_main', null ); // for name resolution
-
-      parent = targetAspect;
-      construct = parent;     // avoid extension behavior
-      targetAspect.kind = 'aspect';   // TODO: probably '$aspect' to detect
-      setLink( targetAspect, '_block', block );
-      initDollarSelf( targetAspect );
-      // allow ref of up_ in anonymous aspect inside entity
-      // (TODO: complain if used and the managed composition is included into
-      // another entity - might induce auto-redirection):
-      if (inEntity && !targetAspect.elements.up_) {
-        const up = {
-          name: { id: 'up_' },
-          kind: '$navElement',
-          location: obj.location,
-        };
-        setLink( up, '_parent', targetAspect );
-        setLink( up, '_main', targetAspect ); // used on main artifact
-        // recompilation case: both target and targetAspect → allow up_ in that case, too:
-        const name = obj.target && resolveUncheckedPath( obj.target, 'target', obj );
-        const entity = name && model.definitions[name];
-        if (entity && entity.elements)
-          setLink( up, '_origin', entity.elements.up_ );
-        // processAspectComposition/expand() sets _origin to element of
-        // generated target entity
-        targetAspect.$tableAliases.up_ = up;
-      }
-      obj = targetAspect;
-    }
-
     function init( elem, name, prop ) {
       if (!elem.name && !elem._outer) {
         const ref = elem.targetElement || elem.kind === 'element' && elem.value;
@@ -1670,6 +1636,7 @@ function extend( model ) {
     //              ...ext.includes.map( r => r._artifact?.name.id ));
     if (!art.query && art.elements) // do not set art.elements and art.enums with query entity!
       includeMembers( ext, art, 'elements' );
+
     if (art.kind !== 'type') {
       includeMembers( ext, art, 'actions' );
     }
@@ -1696,7 +1663,7 @@ function extend( model ) {
     // TODO two kind of messages:
     // Error 'More than one include defines element "A"' (at include ref)
     // Warning 'Overwrites definition from include "I" (at elem def)
-    const propagateKeys = art.kind !== 'type' || !model.options.v7KeyPropagation;
+    const propagateKeys = art.kind !== 'type' || model.options.v6KeyPropagation;
     const parent = ext === art && art;
     const members = ext[prop];
     // if (members)console.log( 'EXT:', prop, art.kind, art.name.id, ...Object.keys(members));
@@ -1704,9 +1671,29 @@ function extend( model ) {
       ext[prop] = Object.create( null );
       ext[prop][$location] = members[$location];
     }
+    let elementsAdded = 0;
     let hasNewElement = false;
-
     for (const ref of ext.includes) {
+      // Elements of include are added after previously provided elements:
+      if (prop === 'elements') {
+        if (ref.$postponeInclude == null) {
+          if (ref._artifact?.elements)
+            ref.$postponeInclude = art.$postponeInclude || 0;
+        }
+        else if (ref.$postponeInclude > 0 && members) {
+          let added = elementsAdded;
+          let postpone = ref.$postponeInclude;
+          elementsAdded += postpone;
+          forEachInOrder( { [prop]: members }, prop, ( elem, name ) => {
+            // The element could have been added in the previous loop (includes) to keep
+            // the element order.
+            if (--added < 0 && --postpone >= 0 && ext[prop][name] !== elem )
+              dictAdd( ext[prop], name, elem );
+          } );
+        }
+        if (ref.$postponeInclude != null) // not reset after bare aspect
+          art.$postponeInclude = 0; // elements of next include directly after this one
+      }
       const template = ref._artifact; // already resolved
       if (template) {           // be robust
         if (template[prop] && !ext[prop])
@@ -1724,7 +1711,7 @@ function extend( model ) {
           if (checkForLocalized && (name === 'texts' || name === 'localized'))
             return;
           if (members && members[name]) {
-            if (!includesNonShadowedFirst && !ext[prop][name])
+            if (!ext[prop][name])
               dictAdd( ext[prop], name, members[name] ); // to keep order
             return;
           }
@@ -1734,8 +1721,6 @@ function extend( model ) {
           if (!parent) // not yet set for EXTEND foo WITH bar => linkToOrigin() did not add it
             dictAdd( ext[prop], name, elem );
           elem.$inferred = 'include';
-          if (origin.masked)    // TODO(v6): remove 'masked'
-            elem.masked = Object.assign( { $inferred: 'include' }, origin.masked );
           if (origin.key && propagateKeys)
             elem.key = Object.assign( { $inferred: 'include' }, origin.key );
           if (origin.value && origin.$syntax === 'calc') {
@@ -1754,14 +1739,20 @@ function extend( model ) {
     }
     if (!hasNewElement && members) {
       ext[prop] = members;
+      if (prop === 'elements')
+        art.$postponeInclude += addedElements( ext );
     }
     else if (members) {
+      let added = elementsAdded;
       // TODO: expand elements having direct elements (if needed)
       forEachInOrder( { [prop]: members }, prop, ( elem, name ) => {
         // The element could have been added in the previous loop (includes) to keep
         // the element order.
-        if (ext[prop][name] !== elem )
+        if (--added < 0 && ext[prop][name] !== elem ) {
           dictAdd( ext[prop], name, elem );
+          if (prop === 'elements' && elem.kind !== 'extend')
+            ++art.$postponeInclude;
+        }
       } );
     }
   }

package/lib/compiler/generate.js

@@ -47,6 +47,7 @@ function generate( model ) {
   const textsAspect = model.definitions['sap.common.TextsAspect'];
   let enableLanguageAssoc = null; // → addLanguageAssoc()
   let enableTextsAspect = null;   // → useTextsAspect()
+  const copyJournal = !isDeprecatedEnabled( options, '_noPersistenceJournalForGeneratedEntities' );
   return;
 
   /**
@@ -725,7 +726,7 @@ function generate( model ) {
     // annotations (remark: adding elements is not allowed for generated artifacts):
     extendArtifactBefore( art );
     setGenExtensions( art, { _composition: elem } );
-    setLink( art, '_origin', target ); // TODO: does this hurt?
+    setLink( art, '_origin', target ); // needed especially with anonymous target aspect
     return art;
   }
 
@@ -746,7 +747,7 @@ function generate( model ) {
     }
 
     if (targetAspect.name) {          // named target aspect
-      if (!isDeprecatedEnabled( options, 'noCompositionIncludes' )) {
+      if (!isDeprecatedEnabled( options, '_noCompositionIncludes' )) {
         art.includes = [ createInclude( targetAspect.name.id, location ) ];
         art.includes.$origin = []; // included elements after up_
         // TODO: propagate in effectiveType()
@@ -790,8 +791,6 @@ function generate( model ) {
       setLink( proxy, '_block', origin._block );
       if (location)
         proxy.$inferred = inferred;
-      if (origin.masked)
-        proxy.masked = Object.assign( { $inferred: 'include' }, origin.masked );
       if (origin.key)
         proxy.key = Object.assign( { $inferred: 'include' }, origin.key );
       if (origin.value && origin.$syntax === 'calc') {
@@ -824,13 +823,10 @@ function generate( model ) {
       return;
 
     // Copied since v6
-    const copyJournal = !isDeprecatedEnabled( options, 'noPersistenceJournalForGeneratedEntities' );
     if (copyJournal)
       copy( '@cds.persistence.journal' );
 
-    const copyExists = !isDeprecatedEnabled( options, '_eagerPersistenceForGeneratedEntities' );
-    if (copyExists)
-      copy( '@cds.persistence.exists' );
+    copy( '@cds.persistence.exists' );
     copy( '@cds.persistence.skip' );
     copy( '@cds.tenant.independent' );
 

package/lib/compiler/populate.js

@@ -459,8 +459,7 @@ function populate( model ) {
     const location = weakRefLocation( ref ) || weakLocation( art.location );
     // console.log( message( null, location, art, {target:struct,art}, 'Info','EXPAND-ELEM')
     //              .toString(), Object.keys(struct.elements))
-    proxyCopyMembers( art, 'elements', struct.elements, location,
-                      null, isDeprecatedEnabled( options, '_noKeyPropagationWithExpansions' ) );
+    proxyCopyMembers( art, 'elements', struct.elements, location, null );
     // Set elements expansion status (the if condition is always true, as no
     // elements expansion will take place on artifact with existing other
     // member property):
@@ -724,9 +723,8 @@ function populate( model ) {
       // (we might have those already)
       if (alias.kind === 'mixin' || alias.kind === '$self')
         return;
-      if (!alias.elements) // could be false in hierarchical JOIN - TODO: necessary?
-        effectiveType( alias ); // element → $navElement expansion for $tableAlias
-
+      if (!effectiveType( alias )) // not found or cyclic
+        return;
       forEachGeneric( { elements: alias.elements }, 'elements', ( elem, name ) => {
         if (elem.$duplicates !== true)
           dictAddArray( query._combined, name, elem, null ); // not dictAdd()
@@ -887,8 +885,7 @@ function populate( model ) {
 
     for (const name in env) {
       const navElem = env[name];
-      // TODO: remove all access to masked (use 'grep')
-      if (excludingDict[name] || navElem.masked?.val)
+      if (excludingDict[name])
         continue;
       const sibling = siblingElements[name];
       if (sibling) {          // is explicitly provided (without duplicate)

package/lib/compiler/propagator.js

@@ -37,7 +37,6 @@ function propagate( model ) {
     // TODO(!): think of having an extra XSN property for calculated elements,
     // replacing `value:…`+`$syntax:'calc'` and `$calc:…
     $calc: enumOrCalcValue,
-    // masked: special = done in definer
     // key: special = done in resolver
     // actions: struct includes & primary source = in definer/resolver
     type: notWithExpand,
@@ -65,7 +64,7 @@ function propagate( model ) {
   };
   const ruleToFunction = {
     __proto__: null,
-    never,
+    never: onlyViaParent,
     onlyViaArtifact,
     onlyViaParent,
     notWithPersistenceTable,
@@ -165,10 +164,11 @@ function propagate( model ) {
     const viaType = target.type && // TODO: falsy $inferred value instead of 'cast'?
           (!target.type.$inferred || target.type.$inferred === 'cast');
     const keys = Object.keys( source );
-    // console.log('PROPS:',ref(source),'->',ref(target),keys.join('+'))
+    // console.log('PROPS:',source.name.id,'->',target.name.id,keys.join('+'))
     for (const prop of keys) {
       // TODO: warning with competing props from multi-includes, but not in propagator.js
-      if (target[prop] !== undefined &&
+      if ((target[prop] !== undefined && target[prop]?.$inferred !== 'prop-null') &&
+          // do not propagate into calculated element from calc expression:
           (prop !== 'value' || !source.$calcDepElement || !target._main?.query) ||
           source[prop] === undefined)
         continue;
@@ -178,8 +178,6 @@ function propagate( model ) {
     }
   }
 
-  function never() { /* no-op: don't propagate */ }
-
   function always( prop, target, source ) {
     const val = source[prop];
     if (Array.isArray( val )) {
@@ -261,6 +259,7 @@ function propagate( model ) {
   }
 
   // Only propagate if parent object (which is not necessarily `_parent`) was propagated.
+  // (part of a deep-copy)
   function onlyViaParent( prop, target, source ) {
     if (target.$inferred === 'proxy' || target.$inferred === 'expanded')
       // assocs and enums do not have 'include'
@@ -316,14 +315,15 @@ function propagate( model ) {
 
   function annotation( prop, target, source ) {
     const anno = source[prop];
-    if (anno.val !== null)
-      withKind( prop, target, source ); // TODO: unfold
+    withKind( prop, target, source );
+    if (anno.val === null && target[prop]?.$inferred === 'prop')
+      target[prop].$inferred = 'prop-null';
   }
 
   function docComment( prop, target, source ) {
     if (model.options.propagateDocComments)
       annotation( prop, target, source );
-    else // TODO: or just "never"
+    else
       onlyViaParent( prop, target, source );
   }