@sap/cds-compiler 2.15.8 → 3.1.0

package/lib/compiler/extend.js

@@ -7,8 +7,8 @@
 
 const { searchName, weakLocation } = require('../base/messages');
 const {
-  isDeprecatedEnabled, isBetaEnabled,
-  forEachGeneric, forEachInOrder,
+  isDeprecatedEnabled,
+  forEachGeneric, forEachInOrder, forEachDefinition,
 } = require('../base/model');
 const { dictAdd } = require('../base/dictionaries');
 const { kindProperties, dictKinds } = require('./base');
@@ -33,6 +33,7 @@ function extend( model ) {
   const {
     resolvePath,
     resolveUncheckedPath,
+    checkAnnotate,
     defineAnnotations,
     attachAndEmitValidNames,
     checkDefinitions,
@@ -47,15 +48,16 @@ function extend( model ) {
 
   applyExtensions();
 
-  const commonLanguagesEntity // TODO: remove beta after a grace period
-        = (options.addTextsLanguageAssoc || isBetaEnabled( options, 'addTextsLanguageAssoc' )) &&
-        model.definitions['sap.common.Languages'];
+  const commonLanguagesEntity = options.addTextsLanguageAssoc &&
+    model.definitions['sap.common.Languages'];
   const addTextsLanguageAssoc = !!(commonLanguagesEntity && commonLanguagesEntity.elements &&
                                    commonLanguagesEntity.elements.code);
   Object.keys( model.definitions ).forEach( processArtifact );
 
   lateExtensions( false );
 
+  compositionChildPersistence();
+
   /**
    * Process "composition of" artifacts.
    *
@@ -88,6 +90,25 @@ function extend( model ) {
     }
   }
 
+  /**
+   * Copy `@cds.persistence.skip` and `@cds.persistence.skip` from parent to child
+   * for managed compositions.  This needs to be done after extensions, i.e. annotations,
+   * have been applied or `annotate E.comp` would not have an effect on `E.comp.subComp`.
+   */
+  function compositionChildPersistence() {
+    const processed = new WeakSet();
+    forEachDefinition(model, processCompositionPersistence);
+
+    function processCompositionPersistence(def) {
+      if (def.$inferred === 'composition-entity' && !processed.has(def)) {
+        if (def._parent)
+          processCompositionPersistence(def._parent);
+        copyPersistenceAnnotations(def, def._parent, options);
+        processed.add(def);
+      }
+    }
+  }
+
   // extend ------------------------------------------------------------------
 
   /**
@@ -159,6 +180,10 @@ function extend( model ) {
       checkDefinitions( ext, art, 'actions');
       checkDefinitions( ext, art, 'params');
       checkDefinitions( ext, art, 'columns');
+      if (ext.includes)
+        applyIncludes( ext, art ); // emits error if `includes` is set
+      if (ext.kind === 'annotate')
+        checkAnnotate( ext, art );
       defineAnnotations( ext, art, ext._block, ext.kind );
     }
     return true;
@@ -218,6 +243,8 @@ function extend( model ) {
             art.includes = [ ...ext.includes ];
           applyIncludes( ext, art );
         }
+        if (ext.kind === 'annotate')
+          checkAnnotate( ext, art );
         defineAnnotations( ext, art, ext._block, ext.kind );
         // TODO: do we allow to add elements with array of {...}?  If yes, adapt
         initMembers( ext, art, ext._block ); // might set _extend, _annotate
@@ -369,9 +396,13 @@ function extend( model ) {
         for (const ext of exts) {
           delete ext.name.path[0]._artifact;      // get message for root
           // TODO: make resolvePath('extend'/'annotate') ignore namespaces
-          if (resolvePath( ext.name, ext.kind, ext )) { // should issue error/info
+          // Don't try to apply annotations in the `localized.` namespace.
+          // That's done in `localized.js`.
+          if (!name.startsWith('localized.') &&
+            resolvePath( ext.name, ext.kind, ext )) { // should issue error/info
             // should issue error for cds extensions (annotate ok)
             if (art.kind === 'namespace') {
+              // TODO: Emit error if namespace is extended by non-definitions.
               info( 'anno-namespace', [ ext.name.location, ext ], {},
                     'Namespaces can\'t be annotated' );
             }
@@ -431,6 +462,12 @@ function extend( model ) {
    * @param {XSN.Artifact} art
    */
   function applyIncludes( ext, art ) {
+    if (kindProperties[art.kind].include !== true) {
+      error('extend-unexpected-include', [ ext.includes[0]?.location, ext ], { kind: art.kind },
+            'Can\'t extend $(KIND) with includes');
+      return;
+    }
+
     if (!art._ancestors)
       setLink( art, '_ancestors', [] ); // recursive array of includes
     for (const ref of ext.includes) {
@@ -492,17 +529,16 @@ function extend( model ) {
     const fioriAnno = art['@fiori.draft.enabled'];
     const fioriEnabled = fioriAnno && (fioriAnno.val === undefined || fioriAnno.val);
 
-    const textsName = (isDeprecatedEnabled( options, 'generatedEntityNameWithUnderscore' ))
-      ? `${ art.name.absolute }_texts`
-      : `${ art.name.absolute }.texts`;
+    const textsName = `${ art.name.absolute }.texts`;
     const textsEntity = model.definitions[textsName];
     const localized = localizedData( art, textsEntity, fioriEnabled );
     if (!localized)
       return;
     if (textsEntity)            // expanded localized data in source
       return;                   // -> make it idempotent
-    createTextsEntity( art, textsName, localized, fioriEnabled );
+    const newTextsEntity = createTextsEntity( art, textsName, localized, fioriEnabled );
     addTextsAssociations( art, textsName, localized );
+    copyPersistenceAnnotations(newTextsEntity, art, options);
   }
 
   /**
@@ -636,8 +672,6 @@ function extend( model ) {
       };
       dictAdd( art.elements, 'ID_texts', textId );
     }
-    if (isDeprecatedEnabled( options, 'generatedEntityNameWithUnderscore' ))
-      setLink( art, '_base', base );
 
     dictAdd( art.elements, 'locale', locale );
     if (addTextsLanguageAssoc) {
@@ -695,6 +729,8 @@ function extend( model ) {
     }
     if (fioriEnabled)
       annotateWith( art, '@assert.unique.locale', art.location, assertUniqueValue, 'array' );
+
+    return art;
   }
 
   /**
@@ -808,9 +844,7 @@ function extend( model ) {
         target = resolvePath( origin.targetAspect, 'compositionTarget', origin );
       if (!target || !target.elements)
         return;
-      const entityName = (isDeprecatedEnabled( options, 'generatedEntityNameWithUnderscore' ))
-        ? `${ base.name.absolute }_${ elem.name.id }`
-        : `${ base.name.absolute }.${ elem.name.id }`;
+      const entityName = `${ base.name.absolute }.${ elem.name.id }`;
       const entity = allowAspectComposition( target, elem, keys, entityName ) &&
             createTargetEntity( target, elem, keys, entityName, base );
       elem.target = {
@@ -931,7 +965,7 @@ function extend( model ) {
     // By default, 'up_' is a managed primary key association.
     // If 'up_' shall be rendered unmanaged, infer the parent
     // primary keys and add the ON condition
-    if (isDeprecatedEnabled( options, 'unmanagedUpInComponent' )) {
+    if (isDeprecatedEnabled( options, '_unmanagedUpInComponent' )) {
       addProxyElements( art, keys, 'aspect-composition', target.name && location,
                         'up__', '@odata.containment.ignore' );
       up.on = augmentEqual( location, 'up_', Object.values( keys ), 'up__' );
@@ -942,8 +976,6 @@ function extend( model ) {
       // even if target cardinality is 1..1
       up.notNull = { location, val: true };
     }
-    if (isDeprecatedEnabled( options, 'generatedEntityNameWithUnderscore' ))
-      setLink( art, '_base', base._base || base );
 
     dictAdd( art.elements, 'up_', up);
     addProxyElements( art, target.elements, 'aspect-composition', target.name && location );
@@ -951,6 +983,10 @@ function extend( model ) {
     setLink( art, '_block', model.$internal );
     model.definitions[entityName] = art;
     initArtifact( art );
+
+    // Copy persistence annotations from aspect.
+    copyPersistenceAnnotations(art, target, options);
+
     return art;
   }
 
@@ -972,6 +1008,27 @@ function extend( model ) {
   }
 }
 
+/**
+ * Copy the annotations `@cds.persistence.skip`/`@cds.persistence.exists` from
+ * source to target if present on source but not target.
+ *
+ * @param {object} target
+ * @param {object} source
+ * @param {CSN.Options} options
+ */
+function copyPersistenceAnnotations(target, source, options) {
+  if (!source)
+    return;
+  // Copy @cds.persistence.skip/exists annotation.
+  const noCopyExists = isDeprecatedEnabled( options, 'eagerPersistenceForGeneratedEntities' );
+  const existsAnno = '@cds.persistence.exists';
+  const skipAnno = '@cds.persistence.skip';
+  if (!noCopyExists && source[existsAnno] && !target[existsAnno])
+    target[existsAnno] = source[existsAnno];
+  if (source[skipAnno] && !target[skipAnno])
+    target[skipAnno] = source[skipAnno];
+}
+
 function augmentEqual( location, assocname, relations, prefix = '' ) {
   const args = relations.map( eq );
   return (args.length === 1)

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

@@ -2,6 +2,7 @@
 
 'use strict';
 
+const { dictAddArray } = require('../base/dictionaries');
 const { forEachGeneric, forEachMember } = require('../base/model');
 const { setLink, setArtifactLink } = require('./utils');
 
@@ -33,7 +34,7 @@ function finalizeParseCdl( model ) {
       for (const ext of extensionsDict[name]) {
         ext.name.absolute = resolveUncheckedPath( ext.name, 'extend', ext );
         // Define annotations of this top-level extension
-        defineAnnotations( ext, ext, ext._block );
+        defineAnnotations( ext, ext, ext._block, 'extend' );
         mergeAnnotatesForSameArtifact( ext );
         // Initialize members and define annotations in sub-elements.
         initMembers( ext, ext, ext._block, true );
@@ -81,8 +82,12 @@ function finalizeParseCdl( model ) {
     for (const include of artifact.includes || [])
       resolveUncheckedPath(include, 'include', main);
 
+    // define.js takes care that `target` is a ref and
+    // `targetAspect` is a structure.
     if (artifact.target)
       resolveUncheckedPath(artifact.target, 'target', main);
+    if (artifact.targetAspect)
+      resolveTypesForParseCdl(artifact.targetAspect, main);
 
     if (artifact.from) {
       const { from } = artifact;
@@ -92,12 +97,6 @@ function finalizeParseCdl( model ) {
       resolveTypesForParseCdl(from, main);
     }
 
-    if (artifact.targetAspect) {
-      if (artifact.targetAspect.path)
-        resolveUncheckedPath(artifact.targetAspect, 'target', main);
-      resolveTypesForParseCdl(artifact.targetAspect, main);
-    }
-
     // Recursively go through all XSN properties.  There are a few that need to be
     // handled specifically.  Refer to the code below this loop for details.
     for (const prop in artifact) {
@@ -157,8 +156,6 @@ function finalizeParseCdl( model ) {
    * @param {XSN.Artifact} user
    */
   function resolveTypeUnchecked(artWithType, user) {
-    if (!artWithType.type)
-      return;
     const root = artWithType.type.path && artWithType.type.path[0];
     if (!root) // parse error
       return;
@@ -186,7 +183,7 @@ function finalizeParseCdl( model ) {
       let struct = artWithType;
       while (struct.kind === 'element')
         struct = struct._parent;
-      if (struct.kind === 'select' || struct !== user._main) {
+      if (struct.kind === 'select' || struct.kind === 'annotation' || struct !== user._main) {
         message( 'type-unexpected-typeof', [ artWithType.type.location, user ],
                  { keyword: 'type of', '#': struct.kind } );
         return;
@@ -221,17 +218,27 @@ function finalizeParseCdl( model ) {
 
     forEachMember(ext, sub => mergeAnnotatesForSameArtifact(sub));
 
-    if (ext.$annotations && Array.isArray(ext.$duplicates)) {
-      const annotates = ext.$duplicates.filter(val => (val.kind === 'annotate'));
-      for (const dup of annotates) {
-        ext.$annotations.push(...dup.$annotations);
-        delete dup.$annotations;
+    // do not do a complex merge:
+    if (isComplexExtension( ext ) ||
+        !Array.isArray( ext.$duplicates ) || ext.$duplicates.some( isComplexExtension ))
+      return;
+    for (const dup of ext.$duplicates) {
+      for (const prop in dup) {
+        if (prop.charAt(0) === '@')
+          dictAddArray( ext, prop, dup[prop] );
       }
-      ext.$duplicates = ext.$duplicates.filter(val => (val.kind !== 'annotate'));
-      if (ext.$duplicates.length === 0)
-        delete ext.$duplicates;
     }
+    delete ext.$duplicates;
   }
 }
 
+/**
+ * We only de-duplicate an extend/annotate `ext` in function
+ * mergeAnnotatesForSameArtifact() if the extend/annotate is simple, i.e. has
+ * no members like elements.
+ */
+function isComplexExtension( ext ) {
+  return ext.kind !== 'annotate' || ext.elements || ext.parameters || ext.actions;
+}
+
 module.exports = finalizeParseCdl;

package/lib/compiler/index.js

@@ -33,6 +33,7 @@ const check = require('./checks');
 
 const { emptyWeakLocation } = require('../base/location');
 const { createMessageFunctions, deduplicateMessages } = require('../base/messages');
+const { checkRemovedDeprecatedFlags } = require('../base/model');
 const { promiseAllDoNotRejectImmediately } = require('../base/node-helpers');
 const { cdsFs } = require('../utils/file');
 
@@ -83,6 +84,8 @@ function parseX( source, filename, options = {}, messageFunctions = null ) {
     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 model = { location: { file: filename } };
   messageFunctions.error( 'file-unknown-ext', emptyWeakLocation(filename),
@@ -224,6 +227,7 @@ function compileX( filenames, dir = '', options = {}, fileCache = Object.create(
  * @param {string} [dir=""] Base directory. All files are resolved relatively
  *                          to this directory
  * @param {object} [options={}] Compilation options.
+ * @param {object} [fileCache]
  * @returns {XSN.Model} Augmented CSN
  */
 function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.create(null) ) {
@@ -235,7 +239,7 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
   const model = { sources: a.sources, options };
   model.$messageFunctions = createMessageFunctions( options, 'compile', model );
 
-  let asts = [];
+  const asts = [];
   const errors = [];
   a.files.forEach( val => readAndParseSync( val, (err, ast) => {
     if (err)
@@ -253,17 +257,16 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
   if (!options.parseOnly && !options.parseCdl) {
     while (asts.length) {
       const fileNames = readDependenciesSync( asts );
-      asts = [];
-      // TODO: check the following eslint error
-      // eslint-disable-next-line no-loop-func
-      fileNames.forEach( (fileName) => {
+      asts.length = 0;
+      // Push dependencies to `ast`. Only works because readAndParseSync() is synchronous.
+      for (const fileName of fileNames) {
         readAndParseSync(fileName, ( err, ast ) => {
           if (err)
             throw err;
           if (ast)
             asts.push( ast );
         });
-      } );
+      }
     }
   }
 
@@ -378,6 +381,15 @@ function compileSourcesX( sourcesDict, options = {} ) {
       ast.location = { file: filename };
       assertConsistency( ast, options );
     }
+
+    for (const dep of sources[filename].dependencies || []) {
+      if (!dep.realname) {
+        // `realname` is used by setLayers(). For compileSources(), we don't resolve
+        // the USING paths and use the literal instead, which may be part of the
+        // source dictionary.
+        dep.realname = dep.val;
+      }
+    }
   }
   moduleLayers.setLayers( sources );
 
@@ -391,14 +403,15 @@ function compileSourcesX( sourcesDict, options = {} ) {
  * @param {object} options Options
  * @returns {object} XSN
  *
- * TODO: probaby issue message api-recompiled-csn there.
+ * TODO: probably issue message api-recompiled-csn there.
  */
 function recompileX( csn, options ) {
-  options = { ...options, parseCdl: false, $recompile: true };
-  // TODO: $recompile: true should be enough
   // Explicitly set parseCdl to false because backends cannot handle it
-  // Explicitly delete all toCsn options:
+  options = { ...options, parseCdl: false, $recompile: true };
+  // Reset csnFlavor: Use client style (default)
+  delete options.csnFlavor;
   delete options.toCsn;
+  // TODO: $recompile: true should be enough
 
   const file = csn.$location && csn.$location.file &&
     csn.$location.file.replace(/[.]cds$/, '.cds.csn') || '<recompile>.csn';
@@ -428,6 +441,9 @@ function compileDoX( model ) {
   const { throwWithError } = model.$messageFunctions;
   if (!options.testMode)
     model.meta = {}; // provide initial central meta object
+
+  checkRemovedDeprecatedFlags( options, model.$messageFunctions );
+
   if (options.parseOnly) {
     throwWithError();
     return model;
@@ -500,7 +516,7 @@ function processFilenamesSync( filenames, dir ) {
       // Resolve possible symbolic link; if the file does not exist
       // we just continue using the original name because readFile()
       // already handles non-existent files.
-      name = fs.realpathSync(name);
+      name = fs.realpathSync.native(name);
     }
     catch (e) {
       // Ignore the not-found (ENOENT) error

package/lib/compiler/moduleLayers.js

@@ -53,6 +53,12 @@ function layer( art ) {
   return art && art._layerRepresentative;
 }
 
+function realname( art ) {
+  while (art && art.kind !== 'source')
+    art = art._block;
+  return art && art.realname || '';
+}
+
 function compareLayer( a, b ) {
   while (a && a.kind !== 'source')
     a = a._block;
@@ -64,5 +70,6 @@ function compareLayer( a, b ) {
 module.exports = {
   setLayers,
   layer,
+  realname,
   compareLayer,
 };

package/lib/compiler/populate.js

@@ -73,22 +73,16 @@ function populate( model ) {
   /** @type {any} may also be a boolean */
   let newAutoExposed = [];
 
-  // behavior depending on option `deprecated`:
-  const enableExpandElements = !isDeprecatedEnabled( options, 'noElementsExpansion' );
-  // TODO: we should get rid of noElementsExpansion soon; both
-  // beta.nestedProjections and beta.universalCsn do not work with it.
   const scopedRedirections
-        = enableExpandElements &&
-          !isDeprecatedEnabled( options, 'generatedEntityNameWithUnderscore' ) &&
-          !isDeprecatedEnabled( options, 'shortAutoexposed' ) &&
-          !isDeprecatedEnabled( options, 'longAutoexposed' ) &&
-          !isDeprecatedEnabled( options, 'noInheritedAutoexposeViaComposition' ) &&
-          !isDeprecatedEnabled( options, 'noScopedRedirections' );
+        = !isDeprecatedEnabled( options, '_shortAutoexposed' ) &&
+          !isDeprecatedEnabled( options, '_longAutoexposed' ) &&
+          !isDeprecatedEnabled( options, '_noInheritedAutoexposeViaComposition' ) &&
+          !isDeprecatedEnabled( options, '_noScopedRedirections' );
   const autoexposeViaComposition
-        = (isDeprecatedEnabled( options, 'noInheritedAutoexposeViaComposition' ))
+        = (isDeprecatedEnabled( options, '_noInheritedAutoexposeViaComposition' ))
           ? 'Composition'
           : true;
-  const redirectInSubQueries = isDeprecatedEnabled( options, 'redirectInSubQueries' );
+  const redirectInSubQueries = isDeprecatedEnabled( options, '_redirectInSubQueries' );
 
   forEachDefinition( model, traverseElementEnvironments );
   while (newAutoExposed.length) {
@@ -167,7 +161,7 @@ function populate( model ) {
     // console.log(message( null, art.location, art, {}, 'Info','FT').toString())
     const chain = [];
     while (art && !('_effectiveType' in art) &&
-           (art.type || art._origin || art.value && art.value.path) &&
+           (art.type || art._origin || art.value?.path || art.value?.type) &&
            // TODO: really stop at art.enum? See #8942
            !art.target && !art.enum && !art.elements && !art.items) {
       chain.push( art );
@@ -197,7 +191,7 @@ function populate( model ) {
       let eType = art;
       if (eType._outer)
         eType = effectiveType( eType._outer );
-      // collect the "latest" cardinality (calculate lazyly if necessary)
+      // collect the "latest" cardinality (calculate lazily if necessary)
       let cardinality = art.cardinality ||
           art._effectiveType && (() => getCardinality( art._effectiveType ));
       let prev = art;
@@ -224,10 +218,12 @@ function populate( model ) {
       return art._origin;
     if (art.type)
       return resolveType( art.type, art );
+    if (art.value?.type)
+      return resolveType( art.value.type, art );
     // console.log( 'EXPR-IN', art.kind, refString(art.name) )
     if (!art._main || !art.value || !art.value.path)
       return undefined;
-    if (art._pathHead && art.value) {
+    if (art._pathHead && art.value.path) {
       setLink( art, '_origin', resolvePath( art.value, 'expr', art, null ) );
       return art._origin;
     }
@@ -248,7 +244,9 @@ function populate( model ) {
       let struct = user;
       while (struct.kind === 'element')
         struct = struct._parent;
-      if (struct.kind === 'select') {
+      if (struct.kind === 'select' || struct.kind === 'annotation') {
+        // `type of` in annotation definitions can't work, because csn type refs
+        // always refer to definitions.
         message( 'type-unexpected-typeof', [ ref.location, user ],
                  { keyword: 'type of', '#': struct.kind } );
         // we actually refer to an element in _combined; TODO: return null if
@@ -295,7 +293,7 @@ function populate( model ) {
 
 
   function expandItems( art, origin, eType ) {
-    if (!enableExpandElements || art.items)
+    if (art.items)
       return false;
     if (isInParents( art, eType )) {
       art.items = 0;            // circular
@@ -312,8 +310,6 @@ function populate( model ) {
   }
 
   function expandElements( art, struct, eType ) {
-    if (!enableExpandElements)
-      return false;
     if (art.elements || art.kind === '$tableAlias' ||
         // no element expansions for "non-proper" types like
         // entities (as parameter types) etc:
@@ -347,7 +343,7 @@ function populate( model ) {
   }
 
   function expandEnum( art, origin ) {
-    if (!enableExpandElements || art.enum)
+    if (art.enum)
       return false;
     const ref = art.type || art.value || art.name;
     const location = weakLocation( ref && ref.location || art.location );
@@ -469,14 +465,11 @@ function populate( model ) {
         }
       }
     }
-    // Without element expansion, we can't merge nested elements.
-    if (art.kind === 'entity' || enableExpandElements) {
-      for (const id in art.elements$) {
-        const selem = art.elements$[id]; // specified element
-        if (!selem.$replacement) {
-          error( 'query-unspecified-element', [ selem.name.location, selem ], { id },
-                 'Element $(ID) does not result from the query' );
-        }
+    for (const id in art.elements$) {
+      const selem = art.elements$[id]; // specified element
+      if (!selem.$replacement) {
+        error( 'query-unspecified-element', [ selem.name.location, selem ], { id },
+               'Element $(ID) does not result from the query' );
       }
     }
   }
@@ -490,8 +483,6 @@ function populate( model ) {
     forEachGeneric( query, '$tableAliases', resolveTabRef );
 
     initFromColumns( query, query.columns );
-    // TODO: already in definer: complain about EXCLUDING with no wildcard
-    // (would have been automatically with a good CDL syntax: `* without (...)`)
     if (query.excludingDict) {
       for (const name in query.excludingDict)
         resolveExcluding( name, query._combined, query.excludingDict, query );
@@ -1055,8 +1046,6 @@ function populate( model ) {
   // which is not a context/service/namespace, or the definition itself.
   // If inside service, it is the direct child of the (most inner) service.
   function definitionScope( art ) {
-    if (art._base)              // with deprecated.generatedEntityNameWithUnderscore
-      return art._base;
     let base = art;
     while (art._parent) {
       if (art._parent.kind === 'service')
@@ -1112,7 +1101,7 @@ function populate( model ) {
       return false;
     }
     // no @cds.autoexpose or @cds.autoexpose:null
-    // TODO: introduce deprecated.noInheritedAutoexposeViaComposition
+    // TODO: introduce deprecated._noInheritedAutoexposeViaComposition
     art.$autoexpose = model.$compositionTargets[art.name.absolute]
       ? autoexposeViaComposition
       : null;
@@ -1121,17 +1110,15 @@ function populate( model ) {
 
   function autoExposedName( target, service, elemScope ) {
     const { absolute } = target.name;
-    if (isDeprecatedEnabled( options, 'shortAutoexposed' )) {
+    if (isDeprecatedEnabled( options, '_shortAutoexposed' )) {
       const parent = definitionScope( target )._parent;
       const name = (parent) ? absolute.substring( parent.name.absolute.length + 1 ) : absolute;
-      // no need for dedot here (as opposed to deprecated.longAutoexposed), as
+      // no need for dedot here (as opposed to deprecated._longAutoexposed), as
       // the name for dependent entities have already been created using `_` then
       return `${ service.name.absolute }.${ name }`;
     }
-    if (isDeprecatedEnabled( options, 'longAutoexposed' )) {
-      const dedot = isDeprecatedEnabled( options, 'generatedEntityNameWithUnderscore' );
-      return `${ service.name.absolute }.${ dedot ? absolute.replace( /\./g, '_' ) : absolute }`;
-    }
+    if (isDeprecatedEnabled( options, '_longAutoexposed' ))
+      return `${ service.name.absolute }.${ absolute }`;
     const base = definitionScope( target );
     if (base === target)
       return `${ service.name.absolute }.${ absolute.substring( absolute.lastIndexOf('.') + 1 ) }`;

package/lib/compiler/propagator.js

@@ -1,4 +1,10 @@
-//
+// Propagate properties in XSN
+
+// See also internalDoc/PropagatedCsn.md.
+// As opposed to that document, the propagator here works on XSN, not CSN.
+// We also do not deep-copy member dictionaries here, but create proxy members
+// which get their properties via propagation: we use function `onlyViaParent`
+// if that property would not be propagated otherwise.
 
 'use strict';
 
@@ -11,6 +17,7 @@ const {
 const { setLink, linkToOrigin, withAssociation } = require('./utils');
 // const { refString } = require( '../base/messages')
 
+// Note that propagation here is also used for deep-copying (function `onlyViaParent`)
 function propagate( model ) {
   const props = {
     '@com.sap.gtt.core.CoreModel.Indexable': never,
@@ -56,9 +63,8 @@ function propagate( model ) {
     returns,
   };
   const { options } = model;
-  const enableExpandElements = !isDeprecatedEnabled( options, 'noElementsExpansion' );
   // eslint-disable-next-line max-len
-  const oldVirtualNotNullPropagation = isDeprecatedEnabled( options, 'oldVirtualNotNullPropagation' );
+  const oldVirtualNotNullPropagation = isDeprecatedEnabled( options, '_oldVirtualNotNullPropagation' );
 
   forEachDefinition( model, run );
 
@@ -189,7 +195,7 @@ function propagate( model ) {
     if (!type || type._main)
       return false;
     // We do not consider the $expand status, as elements are already expanded
-    // by the resolve(), and if not due to deprecated.noElementsExpansion
+    // by the resolve()
     run( type );
     return type[prop];
   }
@@ -313,11 +319,10 @@ function propagate( model ) {
 
   function items( prop, target, source ) {
     // usually considered expensive, except:
-    // - array of Entity (smooth upgrade: array of String(3), array of DerivedScalar)
+    // - array of Entity
     const line = availableAtType( prop, target, source );
     if (!line ||
-        line.type && line.type._artifact && line.type._artifact.kind === 'entity' ||
-        !line.elements && !line.enum && !line.items && !enableExpandElements)
+        line.type && line.type._artifact && line.type._artifact.kind === 'entity')
       returns( prop, target, source, true );
   }
 }