@sap/cds-compiler 2.15.4 → 3.0.0

package/lib/checks/validator.js

@@ -103,8 +103,9 @@ const commonMemberValidators
   validateAssociationsInItems, checkForInvalidTarget,
   checkVirtualElement, checkElementTypeDefinitionHasType ];
 
+// TODO: checkManagedAssoc is a forEachMemberRecursively!
 const commonArtifactValidators = [ checkTypeDefinitionHasType, checkPrimaryKey, checkManagedAssoc ];
-
+// TODO: Does it make sense to run the on-condition check as part of a CSN validator?
 const commonQueryValidators = [ validateMixinOnCondition ];
 
 /**

package/lib/compiler/assert-consistency.js

@@ -118,8 +118,10 @@ function assertConsistency( model, stage ) {
         '$sources',
       ],
     },
-    location: {                 // location req if at least one property:
-      isRequired: parent => noSyntaxErrors() || Object.keys( parent ).length,
+    location: {
+      // every thing with a $location in CSN must have a XSN location even
+      // with syntax errors (currently even internal artifacts like $using):
+      isRequired: parent => noSyntaxErrors() || parent && parent.kind,
       kind: true,
       requires: [ 'file' ],     // line is optional in top-level location
       optional: [ 'line', 'col', 'endLine', 'endCol', '$notFound' ],
@@ -185,12 +187,16 @@ function assertConsistency( model, stage ) {
           // are missing the location property
           test: isDictionary( definition ),
           requires: [ 'kind', 'name' ],
-          optional: [ 'elements', '$autoElement', '$uncheckedElements', '_effectiveType', '_deps' ],
+          optional: [
+            'elements', '$autoElement', '$uncheckedElements',
+            '$requireElementAccess', '_effectiveType', '_deps',
+          ],
           schema: {
             kind: { test: isString, enum: [ 'builtin' ] },
             name: { test: isObject, requires: [ 'id', 'element' ] },
             $autoElement: { test: isString },
             $uncheckedElements: { test: isBoolean },
+            $requireElementAccess: { test: isBoolean },
             // missing location for normal "elements"
             elements: { test: TODO },
           },
@@ -217,8 +223,7 @@ function assertConsistency( model, stage ) {
     usings: {
       test: isArray(),
       requires: [ 'kind', 'location' ],
-      optional: [ 'name', 'extern', 'usings', '$annotations', 'fileDep' ],
-      // TODO: get rid of $annotations: []
+      optional: [ 'name', 'extern', 'usings', 'fileDep' ],
     },
     extern: {
       requires: [ 'location', 'path' ],
@@ -304,7 +309,6 @@ function assertConsistency( model, stage ) {
       kind: 'element',
       test: isDictionary( definition ), // definition since redef
       requires: [ 'location', 'name' ],
-      optional: [ '$annotations' ], // TODO: get rid of annos: []
     },
     orderBy: { inherits: 'value', test: isArray( expression ) },
     sort: { test: locationVal( isString ), enum: [ 'asc', 'desc' ] },
@@ -449,11 +453,11 @@ function assertConsistency( model, stage ) {
     '@': {
       kind: true,
       inherits: 'value',
-      optional: [ 'name', '_block', '$priority', '$duplicate', '$inferred', '$duplicates' ],
+      optional: [ 'name', '_block', '$priority', '$inferred', '$duplicates', '$errorReported' ],
       // TODO: name requires if not in parser?
     },
-    $priority: { test: TODO }, // TODO: rename to $priority
-    $annotations: { parser: true, kind: true, test: TODO },
+    $priority: { test: TODO },
+    $annotations: { parser: true, kind: true, test: TODO }, // deprecated, still there for cds-lsp
     name: {
       isRequired: stageParser && (() => false), // not required in parser
       kind: true,
@@ -468,7 +472,7 @@ function assertConsistency( model, stage ) {
       ],
     },
     absolute: { test: isString },
-    variant: { test: TODO }, // TODO: not set in CDL parser, only in $annotations
+    variant: { test: TODO }, // TODO: not set in CDL parser
     element: { test: TODO }, // TODO: { test: isString },
     action: { test: isString },
     param: { test: isString },
@@ -581,6 +585,7 @@ function assertConsistency( model, stage ) {
     // (it can contain the artifact itself with no/failed autoexposure):
     _descendants: { kind: [ 'entity' ], test: isDictionary( isArray( TODO ) ) },
 
+    $errorReported: { parser: true, test: isBoolean },     // to avoid duplicate messages
     $duplicates: { parser: true, kind: true, test: TODO }, // array of arts or true
     $extension: { kind: true, test: TODO }, // TODO: introduce $applied instead or $status
     $inferred: { parser: true, kind: true, test: isString },

package/lib/compiler/builtins.js

@@ -76,19 +76,92 @@ const functionsWithoutParens = [
   'CURRENT_USER', 'SESSION_USER', 'SYSTEM_USER',
 ];
 
-const specialFunctions = {
+const specialFunctions = compileFunctions( {
+  '': [                         // the default
+    {
+      intro: [ 'ALL', 'DISTINCT' ],
+      introMsg: [],             // do not list them in code completion
+    },
+    {},
+  ],
   ROUND: [
     null, null, {               // 3rd argument: rounding mode
-      ROUND_HALF_UP: 'argFull',
-      ROUND_HALF_DOWN: 'argFull',
-      ROUND_HALF_EVEN: 'argFull',
-      ROUND_UP: 'argFull',
-      ROUND_DOWN: 'argFull',
-      ROUND_CEILING: 'argFull',
-      ROUND_FLOOR: 'argFull',
+      expr: [ 'ROUND_HALF_UP', 'ROUND_HALF_DOWN', 'ROUND_HALF_EVEN',
+        'ROUND_UP', 'ROUND_DOWN', 'ROUND_CEILING', 'ROUND_FLOOR' ],
     },
   ],
-};
+  TRIM: [
+    {
+      intro: [ 'LEADING', 'TRAILING', 'BOTH' ],
+      expr: [ 'LEADING', 'TRAILING', 'BOTH' ],
+      separator: [ 'FROM' ],
+    },
+  ],
+  EXTRACT: [
+    {
+      expr: [ 'YEAR', 'MONTH', 'DAY', 'HOUR', 'MINUTE', 'SECOND' ],
+      separator: [ 'FROM' ],
+    },
+  ],
+  COUNT: [
+    {
+      expr: [ '*' ],
+      intro: [ 'ALL', 'DISTINCT' ],
+    },
+  ],
+  MIN: 'COUNT',
+  MAX: 'COUNT',
+  SUM: 'COUNT',
+  AVG: 'COUNT',
+  STDDDEV: 'COUNT',
+  VAR: 'COUNT',
+  LOCATE_REGEXPR: [
+    {
+      intro: [ 'START', 'AFTER' ],
+      separator: [ 'FLAG', 'IN', 'FROM', 'OCCURRENCE', 'GROUP' ],
+    },
+  ],
+  OCCURRENCES_REGEXPR: [
+    {
+      separator: [ 'FLAG', 'IN', 'FROM' ],
+    },
+  ],
+  REPLACE_REGEXPR: [
+    {
+      separator: [ 'FLAG', 'IN', 'WITH', 'FROM', 'OCCURRENCE' ],
+      expr: [ 'ALL' ],
+    },
+  ],
+  SUBSTRING_REGEXPR: [
+    {
+      separator: [ 'FLAG', 'IN', 'FROM', 'OCCURRENCE', 'GROUP' ],
+    },
+  ],
+} );
+
+function compileFunctions( special ) {
+  const compiled = {};
+  for (const [ name, val ] of Object.entries( special ))
+    compiled[name] = (typeof val === 'string' ? special[val] : val).map( compileArg );
+  return compiled;
+}
+
+function compileArg( src ) {
+  if (!src)
+    return src;
+  const tgt = {
+    intro: src.intro || [],
+    expr: src.expr || [],
+    separator: src.separator || [],
+  };
+  for (const generic of [ 'intro', 'expr', 'separator' ]) { // intro before expr!
+    for (const token of src[generic] || [])
+      tgt[token] = generic;
+  }
+  if (tgt.intro)             // same token could be in both 'expr' and 'intro':
+    tgt.introMsg = src.introMsg || tgt.intro.filter( token => tgt[token] === 'intro' );
+  return tgt;
+}
 
 /**
  * Variables that have special meaning in CDL/CSN.
@@ -106,12 +179,15 @@ const magicVariables = {
     elements: {
       from: {}, to: {},
     },
+    // Require that elements are accessed, i.e. no $at, only $at.<element>.
+    $requireElementAccess: true,
   },
   $now: {}, // Dito
   $session: {
     // In ABAP CDS session variables are accessed in a generic way via
     // the pseudo variable $session.
     $uncheckedElements: true,
+    $requireElementAccess: true,
   },
 };
 
@@ -286,6 +362,8 @@ function initBuiltins( model ) {
         art.$autoElement = magic.$autoElement;
       if (magic.$uncheckedElements)
         art.$uncheckedElements = magic.$uncheckedElements;
+      if (magic.$requireElementAccess)
+        art.$requireElementAccess = magic.$requireElementAccess;
 
       createMagicElements( art, magic.elements );
       if (options.variableReplacements)

package/lib/compiler/define.js

@@ -505,13 +505,13 @@ function define( model ) {
       initParentLink( parent, definitions );
     }
     if (art.kind !== 'namespace' &&
-        isDeprecatedEnabled( options, 'generatedEntityNameWithUnderscore' )) {
+        isDeprecatedEnabled( options, '_generatedEntityNameWithUnderscore' )) {
       let p = parent;
       while (p && kindProperties[p.kind].artifacts)
         p = p._parent;
       if (p) {
         error( 'subartifacts-not-supported', [ art.name.location, art ],
-               { art: p, prop: 'deprecated.generatedEntityNameWithUnderscore' },
+               { art: p, prop: 'deprecated._generatedEntityNameWithUnderscore' },
                // eslint-disable-next-line max-len
                'With the option $(PROP), no sub artifact can be defined for a non-context/service $(ART)' );
       }

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');
@@ -47,15 +47,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 +89,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 ------------------------------------------------------------------
 
   /**
@@ -492,7 +512,7 @@ function extend( model ) {
     const fioriAnno = art['@fiori.draft.enabled'];
     const fioriEnabled = fioriAnno && (fioriAnno.val === undefined || fioriAnno.val);
 
-    const textsName = (isDeprecatedEnabled( options, 'generatedEntityNameWithUnderscore' ))
+    const textsName = (isDeprecatedEnabled( options, '_generatedEntityNameWithUnderscore' ))
       ? `${ art.name.absolute }_texts`
       : `${ art.name.absolute }.texts`;
     const textsEntity = model.definitions[textsName];
@@ -501,8 +521,9 @@ function extend( model ) {
       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,7 +657,7 @@ function extend( model ) {
       };
       dictAdd( art.elements, 'ID_texts', textId );
     }
-    if (isDeprecatedEnabled( options, 'generatedEntityNameWithUnderscore' ))
+    if (isDeprecatedEnabled( options, '_generatedEntityNameWithUnderscore' ))
       setLink( art, '_base', base );
 
     dictAdd( art.elements, 'locale', locale );
@@ -695,6 +716,8 @@ function extend( model ) {
     }
     if (fioriEnabled)
       annotateWith( art, '@assert.unique.locale', art.location, assertUniqueValue, 'array' );
+
+    return art;
   }
 
   /**
@@ -808,7 +831,7 @@ function extend( model ) {
         target = resolvePath( origin.targetAspect, 'compositionTarget', origin );
       if (!target || !target.elements)
         return;
-      const entityName = (isDeprecatedEnabled( options, 'generatedEntityNameWithUnderscore' ))
+      const entityName = (isDeprecatedEnabled( options, '_generatedEntityNameWithUnderscore' ))
         ? `${ base.name.absolute }_${ elem.name.id }`
         : `${ base.name.absolute }.${ elem.name.id }`;
       const entity = allowAspectComposition( target, elem, keys, entityName ) &&
@@ -931,7 +954,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,7 +965,7 @@ function extend( model ) {
       // even if target cardinality is 1..1
       up.notNull = { location, val: true };
     }
-    if (isDeprecatedEnabled( options, 'generatedEntityNameWithUnderscore' ))
+    if (isDeprecatedEnabled( options, '_generatedEntityNameWithUnderscore' ))
       setLink( art, '_base', base._base || base );
 
     dictAdd( art.elements, 'up_', up);
@@ -951,6 +974,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 +999,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 );
@@ -221,17 +222,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');
 
@@ -224,6 +225,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 +237,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 +255,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 +379,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 +401,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 +439,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 +514,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

@@ -74,21 +74,21 @@ function populate( model ) {
   let newAutoExposed = [];
 
   // behavior depending on option `deprecated`:
-  const enableExpandElements = !isDeprecatedEnabled( options, 'noElementsExpansion' );
+  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, '_generatedEntityNameWithUnderscore' ) &&
+          !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) {
@@ -1094,7 +1094,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;
@@ -1103,15 +1103,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' );
+    if (isDeprecatedEnabled( options, '_longAutoexposed' )) {
+      const dedot = isDeprecatedEnabled( options, '_generatedEntityNameWithUnderscore' );
       return `${ service.name.absolute }.${ dedot ? absolute.replace( /\./g, '_' ) : absolute }`;
     }
     const base = definitionScope( target );

package/lib/compiler/propagator.js

@@ -56,9 +56,9 @@ function propagate( model ) {
     returns,
   };
   const { options } = model;
-  const enableExpandElements = !isDeprecatedEnabled( options, 'noElementsExpansion' );
+  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 +189,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(), and if not due to deprecated._noElementsExpansion
     run( type );
     return type[prop];
   }