@sap/cds-compiler 3.4.4 → 3.5.2

package/lib/compiler/.eslintrc.json

@@ -2,6 +2,6 @@
   "root": true,
   "extends": "../../.eslintrc-ydkjsi.json",
   "rules": {
-    "cds-compiler/space-in-func-decl": "error"
+    "cds-compiler/message-no-quotes": "warn"
   }
 }

package/lib/compiler/assert-consistency.js

@@ -417,7 +417,6 @@ function assertConsistency( model, stage ) {
           'args',
           'func',
           'suffix',
-          'quantifier',
           '$inferred',
           '$parens',
           '_artifact',          // _artifact with "localized data"s 'coalesce'

package/lib/compiler/builtins.js

@@ -451,7 +451,7 @@ function initBuiltins( model ) {
     for (const name in builtins) {
       const magic = builtins[name];
       // TODO: rename to $builtinFunction
-      const art = { kind: 'builtin', name: { element: name, id: name } };
+      const art = { kind: 'builtin', name: { id: name, absolute: name } };
       artifacts[name] = art;
 
       if (magic.$autoElement)

package/lib/compiler/checks.js

@@ -27,7 +27,8 @@ function check( model ) {       // = XSN
   } = model.$messageFunctions;
   forEachDefinition( model, checkArtifact );
   forEachGeneric( model, 'vocabularies', checkAnnotationDefinition );
-  checkSapCommonLocale( model, model.$messageFunctions );
+  checkSapCommonLocale( model );
+  checkSapCommonTextsAspects( model );
   return;
 
   function checkArtifact( art ) {
@@ -359,13 +360,13 @@ function check( model ) {       // = XSN
         const { literal, val, location } = elem.cardinality[prop];
         if (!(literal === 'number' && val > 0 ||
               literal === 'string' && val === '*')) {
-          error('invalid-cardinality', [ location, elem ], { '#': prop, code: val }, {
+          error('invalid-cardinality', [ location, elem ], { '#': prop, code: val, newcode: '*' }, {
             // eslint-disable-next-line max-len
-            std: 'Value $(CODE) is invalid for maximum cardinality, expecting a positive number or ‘*’',
+            std: 'Value $(CODE) is invalid for maximum cardinality, expecting a positive number or $(NEWCODE)',
             // eslint-disable-next-line max-len
-            sourceMax: 'Value $(CODE) is invalid for maximum source cardinality, expecting a positive number or ‘*’',
+            sourceMax: 'Value $(CODE) is invalid for maximum source cardinality, expecting a positive number or $(NEWCODE)',
             // eslint-disable-next-line max-len
-            targetMax: 'Value $(CODE) is invalid for maximum target cardinality, expecting a positive number or ‘*’',
+            targetMax: 'Value $(CODE) is invalid for maximum target cardinality, expecting a positive number or $(NEWCODE)',
           });
         }
       }
@@ -485,7 +486,13 @@ function check( model ) {       // = XSN
     if (Array.isArray(onCond)) // condition in brackets results an array
       onCond.forEach(Cond => checkAssociationCondition(elem, Cond));
     else
-      checkAssociationConditionArgs(elem, onCond.args, onCond.op);
+      checkAssociationConditionArgs(elem, onCond.args, getBinaryOp( onCond ));
+  }
+
+  function getBinaryOp( cond ) {
+    const { op, args } = cond;
+    return op?.val === 'ixpr' && args.length === 3 && args[1].literal === 'token' &&
+      args[1] || op;
   }
 
   function checkAssociationConditionArgs( elem, args, op ) {
@@ -495,10 +502,10 @@ function check( model ) {       // = XSN
 
   function checkAssociationOnCondArg( elem, arg, op ) {
     if (Array.isArray(arg)) {
-      arg.forEach(Arg => checkAssociationOnCondArg(elem, Arg, op));
+      arg.forEach(Arg => checkAssociationCondition(elem, Arg));
     }
     else {
-      checkAssociationConditionArgs(elem, arg.args, arg.op);
+      checkAssociationCondition(elem, arg);
       singleCheckUnmanagedAssocCondArgumentNoFollowUnmanagedAssoc(elem, arg, op);
     }
   }
@@ -537,7 +544,7 @@ function check( model ) {       // = XSN
   }
 
   function checkAssociationArgumentStartingWithSelf( op, elem ) {
-    if (op && op.val === 'xpr') // no check for xpr
+    if (op?.val === 'xpr') // no check for xpr, would require re-structuring
       return;
     if (op && op.val !== '=')
       error(null, [ op.location, elem ], {}, '$self comparison is only allowed with \'=\'');
@@ -585,7 +592,7 @@ function check( model ) {       // = XSN
   function checkExpression( xpr, allowAssocTail = false ) {
     // Since the checks for tree-like and token-stream expressions differ,
     // check here what kind of expression we are looking at
-    if (xpr.op && xpr.op.val === 'xpr')
+    if (xpr.op?.val === 'xpr')
       return checkTokenStreamExpression(xpr, allowAssocTail);
     return checkTreeLikeExpression(xpr, allowAssocTail);
   }
@@ -921,20 +928,71 @@ function check( model ) {       // = XSN
   }
 }
 
+/**
+ * Ensure that the sap.common.[Fiori]TextsAspect has proper types for
+ * e.g. `locale` and `ID_texts`.
+ *
+ * @param {XSN.Model} model
+ */
+function checkSapCommonTextsAspects( model ) {
+  checkSapCommonTextsAspectLocale( model, 'sap.common.TextsAspect' );
+  checkSapCommonTextsAspectLocale( model, 'sap.common.FioriTextsAspect' );
+
+  // Check ID_texts: Fiori requires it to be UUID.
+  const fioriTextsAspect = model.definitions['sap.common.FioriTextsAspect'];
+  const id = fioriTextsAspect?.elements?.ID_texts;
+  if (id) {
+    const idType = id._effectiveType;
+    if (!idType || idType.name?.absolute !== 'cds.UUID') {
+      const { error } = model.$messageFunctions;
+      error('def-invalid-element-type', [ id.type.location, id ], {
+        '#': 'std',
+        art: 'sap.common.FioriTextsAspect',
+        elemref: 'ID_texts',
+        type: 'cds.UUID',
+      });
+    }
+  }
+}
+
+/**
+ * Ensure that the `locale` element of sap.common.[Fiori]TextsAspects
+ * is a string type.  This is required by CAP runtimes to work properly.
+ *
+ * @param {XSN.Model} model
+ * @param {string} name Either sap.common.TextsAspects or sap.common.FioriTextsAspects
+ */
+function checkSapCommonTextsAspectLocale( model, name ) {
+  const locale = model.definitions[name]?.elements?.locale;
+  if (locale) {
+    // `locale` could also be `sap.common.Locale`, which must also be a string.
+    const type = locale._effectiveType;
+    if (type?.name?.absolute !== 'cds.String') {
+      const hasCommonLocale = !!model.definitions['sap.common.Locale'];
+      const { error } = model.$messageFunctions;
+      error('def-invalid-element-type', [ locale.type.location, locale ], {
+        '#': hasCommonLocale ? 'texts-aspect-locale' : 'std',
+        art: name,
+        elemref: 'locale',
+        type: 'cds.String',
+        othertype: 'sap.common.Locale',
+      });
+    }
+  }
+}
+
 /**
  * Checks that sap.common.Locale is of type cds.String.  This limitation may
  * be lifted later on.
  *
  * @param {XSN.Model} model
- * @param {object} messageFunctions
  */
-function checkSapCommonLocale( model, messageFunctions ) {
+function checkSapCommonLocale( model ) {
   const localeArt = model.definitions['sap.common.Locale'];
   if (localeArt) {
     const type = localeArt._effectiveType;
-    const isCdsString = type && type.name && type.name.absolute === 'cds.String';
-    if (!isCdsString) {
-      const { message } = messageFunctions;
+    if (type?.name?.absolute !== 'cds.String') {
+      const { message } = model.$messageFunctions;
       message('type-expected-builtin', [ localeArt.name.location, localeArt ],
               { name: 'sap.common.Locale' },
               'Expected $(NAME) to be a string type');

package/lib/compiler/define.js

@@ -132,6 +132,7 @@ const {
   pathName,
   splitIntoPath,
   annotationHasEllipsis,
+  isDirectComposition,
 } = require('./utils');
 const { compareLayer } = require('./moduleLayers');
 const { initBuiltins, isInReservedNamespace } = require('./builtins');
@@ -837,7 +838,7 @@ function define( model ) {
         dictAddArray( p.$tableAliases, table.name.id, table );
       }
       if (table.name.id[0] === '$') {
-        warning( 'syntax-dollar-ident', [ table.name.location, table ], {
+        warning( 'name-invalid-dollar-alias', [ table.name.location, table ], {
           '#': (table.name.$inferred ? '$tableImplicit' : '$tableAlias'),
           name: '$',
           keyword: 'as',
@@ -924,7 +925,7 @@ function define( model ) {
             error( 'duplicate-definition', [ loc, query ], { name: dupName, '#': 'alias' } );
           } );
           if (mixin.name.id[0] === '$') {
-            warning( 'syntax-dollar-ident', [ mixin.name.location, mixin ],
+            warning( 'name-invalid-dollar-alias', [ mixin.name.location, mixin ],
                      { '#': 'mixin', name: '$' } );
           }
         }
@@ -932,11 +933,6 @@ function define( model ) {
     }
   }
 
-  function isDirectComposition( art ) {
-    const type = art.type && art.type.path;
-    return type && type[0] && type[0].id === 'cds.Composition';
-  }
-
   // Return whether the `target` is actually a `targetAspect`
   // TODO: really do that here and not in kick-start.js?
   function targetIsTargetAspect( elem ) {

package/lib/compiler/extend.js

@@ -20,7 +20,7 @@ const {
   setMemberParent,
   dependsOnSilent,
   augmentPath,
-  splitIntoPath,
+  splitIntoPath, isDirectComposition,
 } = require('./utils');
 const layers = require('./moduleLayers');
 const { typeParameters } = require('./builtins');
@@ -54,6 +54,7 @@ function extend( model ) {
   applyExtensions();
 
   const addTextsLanguageAssoc = checkTextsLanguageAssocOption(model, options);
+  const useTextsAspects = checkTextsAspects();
 
   Object.keys( model.definitions ).forEach( processArtifact );
 
@@ -293,6 +294,97 @@ function extend( model ) {
     });
   }
 
+  /**
+   * Check that special `sap.common.*` aspects for `.texts` entities are
+   * consistent with compiler expectations.  Emits messages and returns
+   * false if the aspects are not valid.
+   *
+   * @return {boolean}
+   */
+  function checkTextsAspects() {
+    const textsAspect = model.definitions['sap.common.TextsAspect'];
+    const fioriTextsAspect = model.definitions['sap.common.FioriTextsAspect'];
+
+    let hasError = false;
+
+    if (textsAspect) {
+      const specialElements = { locale: { key: true } };
+      if (!checkTextsAspect(textsAspect, specialElements))
+        hasError = true;
+    }
+
+    if (fioriTextsAspect) {
+      const specialElements = { ID_texts: { key: true }, locale: { key: false } };
+      if (!checkTextsAspect(fioriTextsAspect, specialElements))
+        hasError = true;
+    }
+
+    return !hasError;
+  }
+
+  function checkTextsAspect( art, specialElements ) {
+    if (art.kind !== 'aspect' || !art.elements) {
+      error('def-invalid-texts-aspect', [ art.name.location, art ], { '#': 'no-aspect', art });
+      return false;
+    }
+
+    let hasError = false;
+    if (addTextsLanguageAssoc && art.elements.language) {
+      const lang = art.elements.language;
+      error('def-unexpected-element', [ lang.name.location, lang ],
+            { option: 'addTextsLanguageAssoc', art, name: 'language' },
+            // eslint-disable-next-line max-len
+            '$(ART) is not used because option $(OPTION) conflicts with existing element $(NAME); remove either option or element' );
+      hasError = true;
+    }
+
+    for (const name in specialElements) {
+      const expected = specialElements[name];
+      const elem = art.elements[name];
+      if (!elem) {
+        error('def-invalid-texts-aspect', [ art.name.location, art ],
+              { '#': 'missing', art, name });
+        hasError = true;
+      }
+      else if (expected.key !== undefined && !!elem.key?.val !== expected.key) {
+        const loc = elem.key?.location || elem.name?.location || art.name.location;
+        error('def-invalid-texts-aspect', [ loc, elem ],
+              { '#': expected.key ? 'key' : 'no-key', art: elem });
+        hasError = true;
+      }
+    }
+
+    if (hasError) // avoid subsequent errors, if the special elements are already wrong
+      return false;
+
+    for (const name in art.elements) {
+      const elem = art.elements[name];
+      const include = elem.$inferred === 'include';
+      if (!specialElements[name] && elem.key) {
+        const loc = include ? elem.location : elem.key.location;
+        error( 'def-unexpected-key', [ loc, elem ],
+               { '#': !include ? 'std' : 'include', art } );
+        hasError = true;
+      }
+      else if (hasTruthyProp( elem, 'localized' )) {
+        // TODO: T:loc, i.e. "localized" from other type (needs resolver?)
+        //       Not supported anyway, but important for recompilation (which fails correctly).
+        const loc = elem.localized?.location || elem.location;
+        error( 'def-unexpected-localized', [ loc, elem ],
+               { '#': !include ? 'std' : 'include', art } );
+        hasError = true;
+      }
+      else if (elem.targetAspect) {
+        error( 'def-unexpected-composition', [ elem.targetAspect.location, elem ], { art },
+               '$(ART) can\'t have composition of aspects' );
+        hasError = true;
+      }
+    }
+
+    return !hasError;
+  }
+
+
   /**
    * Copy columns for EXTEND PROJECTION
    *
@@ -614,7 +706,7 @@ function extend( model ) {
   function applyIncludes( ext, art ) {
     if (kindProperties[art.kind].include !== true) {
       error('extend-unexpected-include', [ ext.includes[0]?.location, ext ],
-            { kind: art.kind });
+            { meta: art.kind });
       return;
     }
 
@@ -696,9 +788,8 @@ function extend( model ) {
       return;
     if (textsEntity)            // expanded localized data in source
       return;                   // -> make it idempotent
-    const newTextsEntity = createTextsEntity( art, textsName, localized, fioriEnabled );
+    createTextsEntity( art, textsName, localized, fioriEnabled );
     addTextsAssociations( art, textsName, localized );
-    copyPersistenceAnnotations(newTextsEntity, art, options);
   }
 
   /**
@@ -714,6 +805,9 @@ function extend( model ) {
     let keys = 0;
     const textElems = [];
     const conflictingElements = [];
+    // These elements are required or the localized-mechanism does not work.
+    // Other elements from sap.common.TextsAspect may be "overridden" as per
+    // usual include-mechanism.
     const protectedElements = [ 'locale', 'texts', 'localized' ];
     if (fioriEnabled)
       protectedElements.push('ID_texts');
@@ -798,16 +892,37 @@ function extend( model ) {
    * @param {boolean} fioriEnabled
    */
   function createTextsEntity( base, absolute, textElems, fioriEnabled ) {
-    const art = createTextsEntityWithDefaultElements( base, absolute, textElems, fioriEnabled );
+    const name = (fioriEnabled ? 'sap.common.FioriTextsAspect' : 'sap.common.TextsAspect');
+    const withTextsAspect = useTextsAspects && model.definitions[name];
+
+    const art = withTextsAspect
+      ? createTextsEntityWithInclude( base, absolute, fioriEnabled )
+      : createTextsEntityWithDefaultElements( base, absolute, fioriEnabled );
 
     const { location } = base.name;
-    const { locale } = art.elements;
+
+    if (addTextsLanguageAssoc) {
+      const language = {
+        name: { location, id: 'language' },
+        kind: 'element',
+        location,
+        type: augmentPath( location, 'cds.Association' ),
+        target: augmentPath( location, 'sap.common.Languages' ),
+        on: {
+          op: { val: '=', location },
+          args: [
+            { path: [ { id: 'language', location }, { id: 'code', location } ], location },
+            { path: [ { id: 'locale', location } ], location },
+          ],
+          location,
+        },
+      };
+      setLink( language, '_block', model.$internal );
+      dictAdd( art.elements, 'language', language );
+    }
 
     // assertUnique array value, first entry is 'locale'
-    const assertUniqueValue = [ {
-      path: [ { id: locale.name.id, location: locale.location } ],
-      location: locale.location,
-    } ];
+    const assertUniqueValue = [];
 
     for (const orig of textElems) {
       const elem = linkToOrigin( orig, orig.name.id, art, 'elements' );
@@ -833,13 +948,73 @@ function extend( model ) {
         elem.localized = { val: null, $inferred: 'localized', location: localized.location };
       }
     }
-    if (fioriEnabled)
+
+    initArtifact( art );
+    if (art.includes) {
+      // add elements `locale`, etc. which are required below.
+      applyIncludes(art, art);
+    }
+
+    if (fioriEnabled ) {
+      const { locale } = art.elements;
+      assertUniqueValue.unshift({
+        path: [ { id: locale.name.id, location: locale.location } ],
+        location: locale.location,
+      });
       annotateWith( art, '@assert.unique.locale', art.location, assertUniqueValue, 'array' );
+    }
+
+    copyPersistenceAnnotations(art, base, options);
+    return art;
+  }
 
+  /**
+   * Create the `.texts` entity for the given base artifact.
+   * In contrast to createTextsEntityWithDefaultElements(), this one creates
+   * an include for `sap.common.TextsAspect`.
+   *
+   * Does NOT apply the include!
+   *
+   * TODO: When beta flag textsAspect is removed, update caller-site and remove old coding.
+   *
+   * @param {XSN.Artifact} base
+   * @param {string} absolute
+   * @param {boolean} fioriEnabled
+   */
+  function createTextsEntityWithInclude( base, absolute, fioriEnabled ) {
+    const elements = Object.create(null);
+    const { location } = base.name;
+
+    const include = fioriEnabled ? 'sap.common.FioriTextsAspect' : 'sap.common.TextsAspect';
+    const art = {
+      kind: 'entity',
+      name: { path: splitIntoPath( location, absolute ), absolute, location },
+      includes: [ createInclude( include, base.location ) ],
+      location: base.location,
+      elements,
+      $inferred: 'localized-entity',
+    };
+
+    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 );
+    }
+
+    if (addTextsLanguageAssoc && art.elements.language)
+      art.elements.language = undefined; // TODO: Message? Ignore?
+
+    setLink( art, '_block', model.$internal );
+    model.definitions[absolute] = art;
     return art;
   }
 
-  function createTextsEntityWithDefaultElements( base, absolute, textElems, fioriEnabled ) {
+  /**
+   * @param {XSN.Artifact} base
+   * @param {string} absolute
+   * @param {boolean} fioriEnabled
+   */
+  function createTextsEntityWithDefaultElements( base, absolute, fioriEnabled ) {
     const elements = Object.create(null);
     const { location } = base.name;
     const art = {
@@ -879,28 +1054,8 @@ function extend( model ) {
     }
 
     dictAdd( art.elements, 'locale', locale );
-    if (addTextsLanguageAssoc) {
-      const language = {
-        name: { location, id: 'language' },
-        kind: 'element',
-        location,
-        type: augmentPath( location, 'cds.Association' ),
-        target: augmentPath( location, 'sap.common.Languages' ),
-        on: {
-          op: { val: '=', location },
-          args: [
-            { path: [ { id: 'language', location }, { id: 'code', location } ], location },
-            { path: [ { id: 'locale', location } ], location },
-          ],
-          location,
-        },
-      };
-      setLink( language, '_block', model.$internal );
-      dictAdd( art.elements, 'language', language );
-    }
     setLink( art, '_block', model.$internal );
     model.definitions[absolute] = art;
-    initArtifact( art );
 
     return art;
   }
@@ -943,6 +1098,22 @@ function extend( model ) {
     setLink( localized, '_block', model.$internal );
   }
 
+  /**
+   * Create a structure that can be used as an item in `includes`.
+   *
+   * @param {string} name
+   * @param {XSN.Location} location
+   */
+  function createInclude( name, location ) {
+    const include = {
+      path: [ { id: name, location } ],
+      location,
+    };
+    setArtifactLink( include.path[0], model.definitions[name] );
+    setArtifactLink( include, model.definitions[name] );
+    return include;
+  }
+
   /**
    * Returns whether `art` directly or indirectly has the property 'prop',
    * following the 'origin' and the 'type' (not involving elements).
@@ -1092,6 +1263,15 @@ function extend( model ) {
       });
       return false;
     }
+
+    if (elem.type && !isDirectComposition(elem)) {
+      // Only issue warning for direct usages, not for projections, includes, etc.
+      // TODO: Make it configurable error; v4: error
+      warning( 'def-expected-comp-aspect', [ elem.type.location, elem ],
+               { prop: 'Composition of', otherprop: 'Association to' },
+               'Expected $(PROP), but found $(OTHERPROP) for composition of aspect');
+    }
+
     return true;
   }
 

package/lib/compiler/finalize-parse-cdl.js

@@ -186,8 +186,13 @@ function finalizeParseCdl( model ) {
       // For better error messages, check for invalid TYPE OFs similarly
       // to how `resolveType()` does.
       let struct = artWithType;
-      while (struct.kind === 'element')
-        struct = struct._parent;
+      // `items` have no kind, but need to be skipped as well
+      while (struct.kind === 'element' || struct._outer?.items) {
+        if (struct._outer?.items)
+          struct = struct._outer;
+        else
+          struct = struct._parent;
+      }
       if (struct.kind === 'select' || struct.kind === 'annotation' || struct !== user._main) {
         message( 'type-unexpected-typeof', [ artWithType.type.location, user ],
                  { keyword: 'type of', '#': struct.kind } );

package/lib/compiler/index.js

@@ -40,8 +40,14 @@ const { cdsFs } = require('../utils/file');
 const fs = require('fs');
 const path = require('path');
 
-const csnExtensions = [ '.json', '.csn' ];
-const cdlExtensions = [ '.cds', '.hdbcds', '.hdbdd', '.cdl' ];
+const extensionParsers = {
+  csn: parseCsn.parse,
+  json: parseCsn.parse,
+  cds: parseLanguage,
+  cdl: parseLanguage,
+  hdbcds: parseLanguage,
+  hdbdd: parseLanguage,
+};
 
 // Class for command invocation errors.  Additional members:
 //  `errors`: vector of errors (file IO or ArgumentError)
@@ -75,21 +81,18 @@ class ArgumentError extends Error {
 function parseX( source, filename, options = {}, messageFunctions = null ) {
   if (!messageFunctions)
     messageFunctions = createMessageFunctions( options, 'parse' );
-  const ext = path.extname( filename ).toLowerCase();
-  if (csnExtensions.includes(ext) || options.fallbackParser === 'csn!')
-    return parseCsn.parse( source, filename, options, messageFunctions );
-  if (cdlExtensions.includes(ext))
-    return parseLanguage( source, filename, options, messageFunctions );
-  if (options.fallbackParser === 'csn')
-    return parseCsn.parse( source, filename, options, messageFunctions );
-  if (options.fallbackParser)   // any other value: like 'cdl' (historic reasons)
-    return parseLanguage( source, filename, options, messageFunctions );
-  if (source.startsWith('{')) // Source may be JSON.
-    return parseCsn.parse( source, filename, options, messageFunctions );
+  const ext = path.extname( filename ).slice(1).toLowerCase();
+  // eslint-disable-next-line no-nested-ternary
+  const parser = options.fallbackParser === 'auto!'
+    ? (source?.startsWith('{') ? parseCsn.parse : parseLanguage)
+    : (extensionParsers[ext] || extensionParsers[options.fallbackParser] ||
+       source.startsWith('{') && parseCsn.parse);
+  if (parser)
+    return parser( source, filename, options, messageFunctions );
 
   const model = { location: { file: filename } };
   messageFunctions.error( 'file-unknown-ext', emptyWeakLocation(filename),
-                          { file: ext && ext.slice(1), '#': !ext && 'none' }, {
+                          { file: ext, '#': !ext && 'none' }, {
                             std: 'Unknown file extension $(FILE)',
                             none: 'No file extension',
                           } );

package/lib/compiler/populate.js

@@ -198,12 +198,9 @@ function populate( model ) {
         if (a.expand && expandFromColumns( a, art, cardinality ) ||
             art.target && redirectImplicitly( a, art ) ||
             art.elements && expandElements( a, art ) ||
-            art.items && expandItems( a, art ))
+            art.items && expandItems( a, art ) ||
+            art.enum && expandEnum( a, art ))
           art = a;
-
-        else if (art.enum && expandEnum( a, art ))
-          art = a;
-
         setLink( a, '_effectiveType', art );
       }
     }

package/lib/compiler/propagator.js

@@ -15,6 +15,7 @@ const {
   isDeprecatedEnabled,
 } = require( '../base/model');
 const { setLink, linkToOrigin, withAssociation } = require('./utils');
+const $inferred = Symbol.for('cds.$inferred');
 // const { refString } = require( '../base/messages')
 
 // Note that propagation here is also used for deep-copying (function `onlyViaParent`)
@@ -225,6 +226,7 @@ function propagate( model ) {
       member.$inferred = 'proxy';
       setEffectiveType(member, dict[name]);
     }
+    target[prop][$inferred] = 'prop';
   }
 
   function onlyViaParent( prop, target, source ) {