@sap/cds-compiler 4.2.4 → 4.3.0

package/lib/compiler/tweak-assocs.js

@@ -6,8 +6,7 @@ const {
   forEachGeneric,
   forEachInOrder,
 } = require('../base/model');
-const { dictLocation } = require('../base/location');
-const { weakLocation } = require('../base/messages');
+const { dictLocation, weakLocation } = require('../base/location');
 
 const {
   setLink,
@@ -21,6 +20,7 @@ const {
   setExpandStatus,
 } = require('./utils');
 const { CsnLocation } = require('./classes');
+const { CompilerAssertion } = require('../base/error');
 
 const $location = Symbol.for( 'cds.$location' );
 const $inferred = Symbol.for( 'cds.$inferred' );
@@ -131,20 +131,37 @@ function tweakAssocs( model ) {
                // eslint-disable-next-line max-len
                'Do not specify an $(KEYWORD) condition when redirecting the managed association $(ART)' );
       }
+      checkIgnoredFilter( elem );
     }
     else if (elem.foreignKeys && !inferredForeignKeys( elem.foreignKeys )) {
       const assoc = getOrigin( elem );
-      if (assoc && assoc.on) {
+      if (assoc?.on) {
         error( 'rewrite-on-for-managed',
                [ elem.foreignKeys[$location] || dictLocation( elem.foreignKeys ), elem ],
                { art: assocWithExplicitSpec( assoc ) },
                'Do not specify foreign keys when redirecting the unmanaged association $(ART)' );
       }
-      else if (assoc && assoc.foreignKeys) {
+      else if (assoc?.foreignKeys) {
         // same sequence is not checked
         rewriteKeysMatch( elem, assoc );
         rewriteKeysCovered( assoc, elem );
       }
+
+      checkIgnoredFilter( elem );
+    }
+  }
+
+  /**
+   * Publishing an association with filters is allowed, but the filter is ignored
+   * if the association is redirected.  That indicates modeling mistakes, so we
+   * emit a warning.
+   */
+  function checkIgnoredFilter( elem ) {
+    const lastStep = elem.value?.path?.[elem.value.path.length - 1];
+    if (lastStep?.where) {
+      const loc = lastStep.where.location;
+      const variant = elem.foreignKeys ? 'fKey' : 'onCond';
+      warning( 'query-ignoring-filter', [ loc, elem ], { '#': variant } );
     }
   }
 
@@ -208,7 +225,7 @@ function tweakAssocs( model ) {
   }
 
   function rewriteAssociation( element ) {
-    let elem = element.items || element; // TODO v2: nested items
+    let elem = element.items || element; // TODO v5: nested items
     if (elem.elements)
       forEachGeneric( elem, 'elements', rewriteAssociation );
     if (!originTarget( elem ))
@@ -276,6 +293,8 @@ function tweakAssocs( model ) {
     } );
     if (elem.foreignKeys) // Possibly no fk was set
       elem.foreignKeys[$inferred] = 'rewrite';
+
+    addConditionFromAssocPublishing( elem, assoc );
   }
 
   // TODO: there is no need to rewrite the on condition of non-leading queries,
@@ -301,8 +320,11 @@ function tweakAssocs( model ) {
     const cond = copyExpr( assoc.on,
       // replace location in ON except if from mixin element
                            nav.tableAlias && elem.name.location );
-    cond.$inferred = 'copy';
     elem.on = cond;
+    addConditionFromAssocPublishing( elem, assoc );
+    // `cond` still points to the original condition; does not include possible assoc filter
+    elem.on.$inferred = 'copy';
+
     // console.log(message( null, elem.location, elem, {art:assoc,target:assoc.target},
     //   'Info','ON').toString(), nav)
     const { navigation } = nav;
@@ -312,11 +334,9 @@ function tweakAssocs( model ) {
     // Currently, having an unmanaged association inside a struct is not
     // supported by this function:
     if (navigation !== assoc && navigation._origin !== assoc) { // TODO: re-check
-      // For "assoc1.assoc2" and "structelem1.assoc2"
-      if (elem._redirected !== null) { // null = already reported
-        error( 'rewrite-not-supported', [ elem.target.location, elem ], {},
-               'The ON-condition is not rewritten here - provide an explicit ON-condition' );
-      }
+      // For "assoc1.assoc2" and "struct.elem1.assoc2"
+      if (elem._redirected !== null) // null = already reported
+        error( 'rewrite-not-supported', [ elem.target.location, elem ] );
       return;
     }
     if (!nav.tableAlias || nav.tableAlias.path) {
@@ -328,7 +348,167 @@ function tweakAssocs( model ) {
       error( null, [ elem.value.location, elem ], {},
              'Selecting unmanaged associations from a sub query is not supported' );
     }
-    cond.$inferred = 'rewrite';
+    elem.on.$inferred = 'rewrite';
+  }
+
+  /**
+   * If an unmanaged association is being published, we add a potential
+   * filter to the ON-condition and use its cardinality.
+   * If a managed association is published, we transform it into an unmanaged
+   * and do the same.
+   *
+   * The added condition (filter) is already rewritten relative to `elem`.
+   */
+  function addConditionFromAssocPublishing( elem, assoc ) {
+    const publishAssoc = (elem._main?.query && elem.value?.path?.length > 0);
+    if (!publishAssoc)
+      return;
+
+    const { location } = elem.name;
+    const lastStep = elem.value.path[elem.value.path.length - 1];
+
+    if (lastStep?.cardinality) {
+      if (!elem.cardinality)
+        elem.cardinality = assoc.cardinality || { location };
+      for (const card of [ 'sourceMin', 'targetMin', 'targetMax' ]) {
+        if (lastStep.cardinality[card])
+          elem.cardinality[card] = copyExpr( lastStep.cardinality[card], location );
+      }
+    }
+
+    if (lastStep?.where) {
+      // If there are foreign keys, transform them into an ON-condition first.
+      if (assoc.foreignKeys) {
+        const cond = foreignKeysToOnCondition( elem );
+        if (cond) {
+          elem.on = cond;
+          elem.foreignKeys = undefined;
+        }
+      }
+
+      if (elem.on) {
+        elem.on = {
+          op: { val: 'and', location },
+          args: [
+            // TODO: Get rid of $parens
+            { ...elem.on, $parens: [ assoc.location ] },
+            filterToCondition( lastStep, elem ),
+          ],
+          location,
+          $inferred: 'copy',
+        };
+      }
+    }
+  }
+
+  /**
+   * Transform a filter on `assoc` into an ON-condition.
+   * Paths inside the filter are rewritten relative to `elem`.
+   */
+  function filterToCondition( assoc, elem ) {
+    const cond = copyExpr( assoc.where );
+    // TODO: Get rid of $parens
+    cond.$parens = [ assoc.location ];
+    traverseExpr( cond, 'rewrite-filter', elem, (expr) => {
+      if (!expr.path || expr.path.length === 0)
+        return;
+
+      const root = expr.path[0]._navigation || expr.path[0]._artifact;
+      if (!root)
+        return; // only for compile error, e.g. missing definition
+      if (root.kind === '$self') {
+        // $projection -> $self for recompilability
+        expr.path[0].id = '$self';
+      }
+      else if (!root.builtin && root.kind !== 'builtin') {
+        expr.path.unshift({
+          id: elem.name.id,
+          location: elem.name.location,
+        });
+        setLink( expr.path[0], '_artifact', elem );
+        // _navigation link not necessary because this condition is not rewritten
+        // inside the same view (would otherwise be needed for mixins).
+      }
+    } );
+    return cond;
+  }
+
+  // Caller must ensure ON-condition correctness via rewriteExpr()!
+  function foreignKeysToOnCondition( elem ) {
+    const nav = pathNavigation( elem.value );
+    if (!nav.tableAlias && model.options.testMode && !elem._pathHead)
+      throw new CompilerAssertion('rewriting keys to ON-condition: no tableAlias but not inline');
+
+    if (!nav.tableAlias || elem._parent?.kind === 'element' ||
+       (nav && nav.item !== elem.value.path[elem.value.path.length - 1])) {
+      // - no nav.tableAlias for mixins or inside inline; mixins can't have managed assocs, though.
+      // - _parent is element for expand
+      // - nav.item is different for multi-path steps e.g. `sub.assoc`, which is not supported, yet
+      // TODO: Support this
+      error( 'rewrite-not-supported', [ elem.value.location, elem ] );
+      return null;
+    }
+
+    let cond = [];
+    forEachInOrder( elem, 'foreignKeys', function keyToCond( fKey ) {
+      // Format:      lhs = rhs
+      //         assoc.id = assoc_id
+      // lhs and rhs look the same, but have different ids and _artifact links.
+      // rhs is rewritten further down to ensure that the foreign key is projected.
+      const lhs = {
+        path: [
+          { id: elem.name.id, location: elem.name.location },
+          ...copyExpr( fKey.targetElement.path ),
+        ],
+        location: elem.name.location,
+      };
+      setLink( lhs.path[0], '_artifact', elem ); // different to rhs!
+      setLink( lhs, '_artifact', lhs.path[lhs.path.length - 1] );
+
+      const rhs = {
+        path: [
+          // use origin's name; elem could have alias
+          { id: elem._origin.name.id, location: elem._origin.name.location },
+          ...copyExpr( fKey.targetElement.path ),
+        ],
+        location: elem.name.location,
+      };
+      setLink( rhs.path[0], '_artifact', elem._origin ); // different to lhs!
+      setLink( rhs, '_artifact', rhs.path[rhs.path.length - 1] );
+
+      // Can't use rewriteExpr as that would use `assoc[…]` itself as well.
+      const projectedFk = firstProjectionForPath( rhs.path, nav.tableAlias, elem );
+      rewritePath( rhs, projectedFk.item, elem, projectedFk.elem, elem.value.location );
+
+      const fkCond = {
+        op: { val: 'ixpr', location: elem.name.location },
+        args: [
+          lhs,
+          { val: '=', literal: 'token', location: elem.name.location },
+          rhs,
+        ],
+        location: elem.name.location,
+      };
+      cond.push(fkCond);
+    } );
+
+    if (cond.length === 0) {
+      const lastStep = elem.value.path[elem.value.path.length - 1];
+      error( 'expr-missing-foreign-key', [ lastStep.location, elem ], {
+        '#': 'publishingFilter',
+        id: lastStep.id,
+      } );
+      return null;
+    }
+
+    cond = (cond.length === 1) ? cond[0]
+      : {
+        op: { val: 'and', location: elem.name.location },
+        args: cond,
+        location: elem.name.location,
+      };
+
+    return cond;
   }
 
   function rewriteExpr( expr, assoc, tableAlias ) {
@@ -347,14 +527,16 @@ function tweakAssocs( model ) {
     if (tableAlias) { // from ON cond of element in source ref/d by table alias
       const source = tableAlias._origin;
       const root = expr.path[0]._navigation || expr.path[0]._artifact;
-      // console.log( info(null, [ assoc.name.location, assoc ],
-      //                   { names: expr.path.map(i => i.id), art: root }, 'TA').toString());
       if (!root || root._main !== source)
         return;                 // not $self or source element
       if (expr.scope === 'param' || root.kind === '$parameters')
         return;                 // are not allowed anyway - there was an error before
-      const { item, elem } = firstProjectionForPath( expr.path, tableAlias, assoc );
-      rewritePath( expr, item, assoc, elem, assoc.value.location );
+      const result = firstProjectionForPath( expr.path, tableAlias, assoc );
+      // For `assoc[…]`, ensure that we don't rewrite to another projection on `assoc`.
+      if (result.item && assoc._origin === result.item._artifact)
+        result.elem = assoc;
+
+      rewritePath( expr, result.item, assoc, result.elem, assoc.value.location );
     }
     else if (assoc._main.query) { // from ON cond of mixin element in query
       const root = expr.path[0]._navigation || expr.path[0]._artifact;
@@ -370,8 +552,8 @@ function tweakAssocs( model ) {
       }
       const nav = pathNavigation( expr );
       if (nav.navigation || nav.tableAlias) { // rewrite src elem, mixin, $self[.elem]
-        rewritePath( expr, nav.item, assoc,
-                     navProjection( nav.navigation, assoc ),
+        const elem = (assoc._origin === root) ? assoc : navProjection( nav.navigation, assoc );
+        rewritePath( expr, nav.item, assoc, elem,
                      nav.item ? nav.item.location : expr.path[0].location );
       }
     }
@@ -384,6 +566,8 @@ function tweakAssocs( model ) {
         return;                                   // just $self
       // corresponding elem in including structure
       const elem = (assoc._main.items || assoc._main).elements[item.id];
+      if (!elem)
+        return; // See #11755
       if (!(Array.isArray( elem ) ||            // no msg for redefs
             elem === item._artifact ||          // redirection for explicit def
             elem._origin === item._artifact)) {
@@ -410,7 +594,7 @@ function tweakAssocs( model ) {
           name: assoc.name.id, art: item._artifact, elemref: { ref: path },
         }, {
           std: 'Projected association $(NAME) uses non-projected element $(ELEMREF)',
-          element: 'Projected association $(NAME) uses non-projected element $(MEMBER) of $(ART)',
+          element: 'Projected association $(NAME) uses non-projected element $(ELEMREF) of $(ART)',
         } );
       }
       delete root._navigation;
@@ -461,9 +645,6 @@ function tweakAssocs( model ) {
   }
 
   function rewriteItem( elem, item, name, assoc, forKeys ) {
-    // TODO: for rewriting ON conditions of explicitly provided model targets,
-    // we need to only rewrite the current element, not all sibling elements
-    // TODO: this will be different in v4
     if (!elem._redirected)
       return true;
     for (const alias of elem._redirected) {

package/lib/compiler/utils.js

@@ -11,7 +11,6 @@
 'use strict';
 
 const { dictAdd, pushToDict, dictFirst } = require('../base/dictionaries');
-const { kindProperties } = require('./base');
 const { XsnName, XsnArtifact, CsnLocation } = require('./classes');
 
 const $inferred = Symbol.for( 'cds.$inferred' );
@@ -149,23 +148,6 @@ function setMemberParent( elem, name, parent, prop ) {
     parent = parent._outer;
   setLink( elem, '_parent', parent );
   setLink( elem, '_main', parent._main || parent );
-  const parentName = parent.name || parent._outer?.name;
-  if (parentName) // may not be available in e.g. cast() - TODO recheck (#9503)
-    elem.name.absolute = parentName.absolute;
-  if (!parentName || name == null)
-    return;
-  const normalized = kindProperties[elem.kind].normalized || elem.kind;
-  [ 'element', 'alias', 'select', 'param', 'action' ].forEach( ( kind ) => {
-    if (normalized === kind)
-      elem.name[kind] = (parentName[kind] != null && kind !== 'select' && kind !== 'alias') ? `${ parentName[kind] }.${ name }` : name;
-
-    else if (parentName[kind] != null)
-      elem.name[kind] = parentName[kind];
-
-    else
-      delete elem.name[kind];
-  } );
-  // try { throw new CompilerAssertion('Foo') } catch (e) { elem.name.stack = e; };
 }
 
 /**

package/lib/gen/Dictionary.json

@@ -485,7 +485,8 @@
     "Common.ExternalID": {
       "Type": "Edm.String",
       "AppliesTo": [
-        "Property"
+        "Property",
+        "Parameter"
       ],
       "$experimental": true
     },
@@ -2666,6 +2667,7 @@
       "$kind": "ComplexType",
       "BaseType": "Capabilities.ReadRestrictionsBase",
       "Properties": {
+        "TypecastSegmentSupported": "Edm.Boolean",
         "ReadByKeyRestrictions": "Capabilities.ReadByKeyRestrictionsType",
         "Readable": "Edm.Boolean",
         "Permissions": "Collection(Capabilities.PermissionType)",
@@ -3513,7 +3515,9 @@
         "Padding": "Edm.Boolean",
         "HeaderFooter": "Edm.Boolean",
         "ResultSizeDefault": "Edm.Int32",
-        "ResultSizeMaximum": "Edm.Int32"
+        "ResultSizeMaximum": "Edm.Int32",
+        "IANATimezoneFormat": "Edm.Boolean",
+        "Treeview": "Edm.Boolean"
       }
     },
     "PersonalData.EntitySemanticsType": {
@@ -3570,8 +3574,8 @@
             "Value": "UserID",
             "Type": "String"
           },
-          "EndOfPurposeDate": {
-            "Value": "EndOfPurposeDate",
+          "EndOfBusinessDate": {
+            "Value": "EndOfBusinessDate",
             "Type": "String"
           }
         },
@@ -3640,6 +3644,7 @@
       "$kind": "ComplexType",
       "Properties": {
         "Url": "Edm.String",
+        "Stream": "Edm.Stream",
         "ContentType": "Edm.String",
         "ByteSize": "Edm.Int64",
         "ChangedAt": "Edm.DateTimeOffset",
@@ -3652,6 +3657,7 @@
       "$kind": "ComplexType",
       "Properties": {
         "Url": "Edm.String",
+        "Stream": "Edm.Stream",
         "Width": "Edm.String",
         "Height": "Edm.String"
       }

package/lib/gen/language.checksum

@@ -1 +1 @@
-0c76b976c907bebf1f1913d063dca4bf
+462a4274cec75ca772064210a7421aec

package/lib/gen/languageParser.js

@@ -2674,7 +2674,7 @@ class languageParser extends genericAntlrParser_js_1.default {
             this.state = 290;
             this.match(languageParser.T__0);
             this._ctx.stop = this._input.LT(-1);
-            localctx.source.namespace = this.attachLocation(localctx.decl);
+            localctx.source.namespace = localctx.decl;
         }
         catch (re) {
             if (re instanceof antlr4_1.default.error.RecognitionException) {
@@ -15997,7 +15997,7 @@ class languageParser extends genericAntlrParser_js_1.default {
             this.state = 3698;
             this.match(languageParser.Identifier);
             this._ctx.stop = this._input.LT(-1);
-            localctx.id = this.identAst(localctx.stop, localctx.category);
+            localctx.id = this.identAst(null, localctx.category);
         }
         catch (re) {
             if (re instanceof antlr4_1.default.error.RecognitionException) {
@@ -16030,7 +16030,7 @@ class languageParser extends genericAntlrParser_js_1.default {
                 this.consume();
             }
             this._ctx.stop = this._input.LT(-1);
-            localctx.id = this.identAst(localctx.stop, localctx.category);
+            localctx.id = this.identAst(null, localctx.category);
         }
         catch (re) {
             if (re instanceof antlr4_1.default.error.RecognitionException) {

package/lib/inspect/inspectPropagation.js

@@ -41,6 +41,7 @@ function inspectPropagation( xsn, options, artifactName ) {
     return null;
   }
   result.push(color.underline('analyzing propagation for artifact:'));
+  // TODO: back to artifactXsn.name.id (not ok now, and not before this change!)
   result.push(`  name: ${ artifactXsn.name.id }`);
   result.push(`  kind: ${ artifactXsn.kind }`);
 
@@ -131,7 +132,7 @@ function _inspectElements( artifactXsn ) {
     const elementXsn = artifactXsn.elements[element];
     const loc = locationString(_origin(elementXsn).name.location);
     let origin;
-    const originName = elementXsn._origin?.name?.absolute || '';
+    const originName = (elementXsn._origin?._main || elementXsn._origin)?.name?.id || '';
 
     if (elementXsn.$inferred) {
       // Use nice(r) output for known $inferred

package/lib/json/from-csn.js

@@ -267,6 +267,7 @@ const schema = compileSchema( {
     dictionaryOf: definition,
     defaultKind: 'element',
     validKinds: [ 'element' ],
+    requires: requiresOnWithBothTargetProps,
     inKind: [
       'element',
       'type',
@@ -365,15 +366,15 @@ const schema = compileSchema( {
   },
   targetAspect: {
     type: artifactRef,
-    xorException: 'target',     // see xorGroup :type
+    xorException: inferredTargetEntityForAspect, // usually allows `target`
     msgVariant: 'or-object',    // for 'syntax-expecting-string',
     requires: 'elements',
     optional: [ 'elements' ], // 'elements' for ad-hoc aspect compositions
-    inKind: [ 'element', 'type' ],
+    inKind: [ 'element' ],
   },
   target: {
     type: artifactRef,
-    xorException: 'targetAspect', // see xorGroup :type
+    xorException: inferredTargetEntityForAspect, // usually allows `targetAspect`
     msgVariant: 'or-object',    // for 'syntax-expecting-string',
     requires: 'elements',
     optional: [ 'elements' ], // 'elements' for ad-hoc COMPOSITION OF (gensrc style CSN)
@@ -980,9 +981,7 @@ function definition( def, spec, xsn, csn, name ) {
   if (!isObject( def, spec )) {
     return {
       kind: (inExtensions ? 'annotate' : spec.defaultKind),
-      name: {
-        id: '', path: [], absolute: name || '', location: location(),
-      },
+      name: { id: '', location: location() },
       location: location(),
     };
   }
@@ -1442,20 +1441,19 @@ function annoValue( val, spec ) {
     //  - there is exactly one property ('=')
     //  - there is at least one other expression property (e.g. "xpr")
     // TODO: Have xprInAnnoProperties centrally for other backends to use as well (toCdl)
-    const valKeys = Object.keys(val);
-    if (valKeys.length > 1 &&
-        xprInAnnoProperties.some(prop => val[prop] !== undefined)) {
-      const s = schema['@'].schema['-expr'];
-      const r = { location: location() };
-      Object.assign(r, object(val, s));
-      return r;
-    }
-    else if (valKeys.length === 1) {
+    const valKeys = Object.keys( val );
+    if (valKeys.length === 1) {
       ++virtualLine;
-      const r = refSplit( val['='], '=' );
+      const r = refSplit( val['='], '=' ); // i.e. no extra `variant` stuff
       ++virtualLine;
       return r;
     }
+    else if (xprInAnnoProperties.some( prop => val[prop] !== undefined) ) {
+      const s = schema['@'].schema['-expr'];
+      const r = { location: location() };
+      Object.assign( r, object( val, s ) );
+      return r;
+    }
     // fallthrough -> unchecked structure
   }
   if (typeof val['#'] === 'string') {
@@ -1491,15 +1489,12 @@ function annoValue( val, spec ) {
 }
 
 function annotation( val, spec, xsn, csn, name ) {
-  const absolute = (xsn ? name.substring(1) : name);
-  // TODO: really care about variant (qualifier parts)?
-  const variantIndex = absolute.indexOf('#') + 1 || absolute.length; // including '#'
-  const n = refSplit( absolute.substring( 0, variantIndex ), !xsn && '{}' );
-  if (!n)
-    return undefined;
-  n.absolute = absolute;
-  if (variantIndex < absolute.length)
-    n.variant = refSplit( name.substring( variantIndex ), null );
+  // not used for the value
+  const id = (xsn ? name.substring(1) : name);
+  if (!id) {              // `"@": …` is already syntax-unknown-property
+    message( 'syntax-invalid-name', location(true), { '#': '{}' } );
+  }
+  const n = { id, location: location() };
   const r = annoValue( val, spec );
   r.name = n;
   return r;
@@ -1785,7 +1780,7 @@ function getSpec( parentSpec, csn, prop, xor, expected, kind ) {
         return { prop, type: ignore };
       return { prop, type: extra };
     }
-    // TODO v4: No warning with --sloppy
+    // TODO v5: No warning with --sloppy
     warning( 'syntax-unknown-property', location(true), { prop },
              'Unknown CSN property $(PROP)' );
     return { type: ignore };
@@ -1820,7 +1815,7 @@ function getSpec( parentSpec, csn, prop, xor, expected, kind ) {
              kind,
            } );
   }
-  else if (checkAndSetXorGroup( s.xorGroups, s.xorException, prop, xor )) {
+  else if (checkAndSetXorGroup( s.xorGroups, s.xorException, prop, xor, csn )) {
     // TODO: If all targets of onlyWith are xor-excluded/ignore, also exclude/ignore this one.
     onlyWith( s, s.onlyWith, csn, prop, xor, expected );
     return s;
@@ -1849,6 +1844,18 @@ function calculateKind( def, spec ) {
     : kind;
 }
 
+function requiresOnWithBothTargetProps( csn ) {
+  if (!csn.on && csn.target && csn.targetAspect &&
+      inferredTargetEntityForAspect( 'target', 'targetAspect', csn )) {
+    error( 'syntax-missing-property', location(true), {
+      '#': 'bothTargets',
+      siblingprop: 'targetAspect',
+      otherprop: 'target',
+      prop: 'on',
+    } );
+  }
+}
+
 function onlyWith( spec, need, csn, prop, xor, expected ) {
   if (!need)
     return spec;
@@ -1861,6 +1868,10 @@ function onlyWith( spec, need, csn, prop, xor, expected ) {
     if (need in csn)            // TODO: enumerable ?
       return spec;
   }
+  else if (typeof need === 'function') {
+    need( csn, prop );
+    return spec;
+  }
   else if (need.some( n => n in csn )) {
     return spec;
   }
@@ -1895,7 +1906,7 @@ function onlyWith( spec, need, csn, prop, xor, expected ) {
  * @param {object} xor
  * @return {boolean}
  */
-function checkAndSetXorGroup( groups, exception, prop, xor ) {
+function checkAndSetXorGroup( groups, exception, prop, xor, csn ) {
   if (!groups || groups.length === 0)
     return true;
   let silent = false;
@@ -1907,6 +1918,13 @@ function checkAndSetXorGroup( groups, exception, prop, xor ) {
     }
     if (siblingprop === exception)
       return true;
+    if (typeof exception === 'function') {
+      const r = exception( prop, siblingprop, csn, silent );
+      if (r === false)           // error reported
+        silent = true;
+      if (r != null)
+        return r;
+    }
     if (!silent) {
       error( 'syntax-unexpected-property', location(true), { '#': 'sibling', prop, siblingprop } );
       silent = true;
@@ -1915,6 +1933,23 @@ function checkAndSetXorGroup( groups, exception, prop, xor ) {
   });
 }
 
+function inferredTargetEntityForAspect( prop, siblingprop, csn, silent = true ) {
+  if (siblingprop !== 'target' && siblingprop !== 'targetAspect')
+    return null;
+  const { target } = csn;
+  if (typeof target !== 'object' || !target?.elements)
+    return true;
+  if (!silent) {
+    error( 'syntax-unexpected-property', location(true), {
+      '#': prop,
+      prop,
+      siblingprop,
+      subprop: 'elements',
+    } );
+  }
+  return false;
+}
+
 function implicitName( ref ) {
   // careful, the input CSN might be wrong!
   const item = ref && ref[ref.length - 1];