@sap/cds-compiler 4.1.2 → 4.2.2

package/lib/compiler/generate.js

@@ -18,6 +18,7 @@ const {
   isDirectComposition,
   copyExpr,
 } = require('./utils');
+const { weakLocation } = require('../base/messages');
 
 function generate( model ) {
   const { options } = model;
@@ -33,7 +34,7 @@ function generate( model ) {
     applyIncludes,
   } = model.$functions;
 
-  const addTextsLanguageAssoc = checkTextsLanguageAssocOption(model, options);
+  const addTextsLanguageAssoc = checkTextsLanguageAssocOption( model, options );
   const useTextsAspect = checkTextsAspect();
 
   Object.keys( model.definitions ).forEach( processArtifact );
@@ -63,14 +64,14 @@ function generate( model ) {
    */
   function compositionChildPersistence() {
     const processed = new WeakSet();
-    forEachDefinition(model, processCompositionPersistence);
+    forEachDefinition( model, processCompositionPersistence );
 
     function processCompositionPersistence( def ) {
-      if (def.$inferred === 'composition-entity' && !processed.has(def)) {
+      if (def.$inferred === 'composition-entity' && !processed.has( def )) {
         if (def._parent)
-          processCompositionPersistence(def._parent);
+          processCompositionPersistence( def._parent );
         copyPersistenceAnnotations( def, def._parent );
-        processed.add(def);
+        processed.add( def );
       }
     }
   }
@@ -90,18 +91,18 @@ function generate( model ) {
     const specialElements = { locale: { key: true } };
 
     if (textsAspect.kind !== 'aspect' || !textsAspect.elements) {
-      error('def-invalid-texts-aspect', [ textsAspect.name.location, textsAspect ],
-            { '#': 'no-aspect', art: textsAspect });
+      error( 'def-invalid-texts-aspect', [ textsAspect.name.location, textsAspect ],
+             { '#': 'no-aspect', art: textsAspect } );
       return false;
     }
 
     let hasError = false;
     if (addTextsLanguageAssoc && textsAspect.elements.language) {
       const lang = textsAspect.elements.language;
-      error('def-unexpected-element', [ lang.name.location, lang ],
-            { option: 'addTextsLanguageAssoc', art: textsAspect, 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' );
+      error( 'def-unexpected-element', [ lang.name.location, lang ],
+             { option: 'addTextsLanguageAssoc', art: textsAspect, 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;
     }
 
@@ -109,14 +110,14 @@ function generate( model ) {
       const expected = specialElements[name];
       const elem = textsAspect.elements[name];
       if (!elem) {
-        error('def-invalid-texts-aspect', [ textsAspect.name.location, textsAspect ],
-              { '#': 'missing', art: textsAspect, name });
+        error( 'def-invalid-texts-aspect', [ textsAspect.name.location, textsAspect ],
+               { '#': 'missing', art: textsAspect, name } );
         hasError = true;
       }
       else if (expected.key !== undefined && !!elem.key?.val !== expected.key) {
         const loc = elem.key?.location || elem.name?.location || textsAspect.name.location;
-        error('def-invalid-texts-aspect', [ loc, elem ],
-              { '#': expected.key ? 'key' : 'no-key', art: elem });
+        error( 'def-invalid-texts-aspect', [ loc, elem ],
+               { '#': expected.key ? 'key' : 'no-key', art: elem } );
         hasError = true;
       }
     }
@@ -193,9 +194,9 @@ function generate( model ) {
     // usual include-mechanism.
     const protectedElements = [ 'locale', 'texts', 'localized' ];
     if (fioriEnabled)
-      protectedElements.push('ID_texts');
+      protectedElements.push( 'ID_texts' );
     if (addTextsLanguageAssoc)
-      protectedElements.push('language');
+      protectedElements.push( 'language' );
 
     for (const name in art.elements) {
       const elem = art.elements[name];
@@ -214,6 +215,13 @@ function generate( model ) {
       else if (isLocalized) {
         textElems.push( elem );
       }
+
+      if (isKey && isLocalized) {
+        const errpos = elem.localized || elem.type || elem.name;
+        warning( 'def-ignoring-localized', [ errpos.location, elem ],
+                 { keyword: 'localized' },
+                 'Keyword $(KEYWORD) is ignored for primary keys' );
+      }
     }
     if (textElems.length <= keys)
       return false;
@@ -336,8 +344,8 @@ function generate( model ) {
       // Because ID_texts is not copied from TextsAspect, the order is messed
       // up.  Fix it.
       const { elements } = art;
-      art.elements = Object.create(null);
-      const names = [ 'ID_texts', 'locale', ...Object.keys(elements) ];
+      art.elements = Object.create( null );
+      const names = [ 'ID_texts', 'locale', ...Object.keys( elements ) ];
       for (const name of names)
         art.elements[name] = elements[name];
 
@@ -367,7 +375,7 @@ function generate( model ) {
   function createTextsEntityWithInclude( base, absolute, fioriEnabled ) {
     const textsAspectName = 'sap.common.TextsAspect';
     const textsAspect = model.definitions['sap.common.TextsAspect'];
-    const elements = Object.create(null);
+    const elements = Object.create( null );
     const { location } = base.name;
     const art = {
       kind: 'entity',
@@ -415,7 +423,7 @@ function generate( model ) {
    * @param {boolean} fioriEnabled
    */
   function createTextsEntityWithDefaultElements( base, absolute, fioriEnabled ) {
-    const elements = Object.create(null);
+    const elements = Object.create( null );
     const { location } = base.name;
     const art = {
       kind: 'entity',
@@ -528,7 +536,7 @@ function generate( model ) {
    * @returns {boolean}
    */
   function hasTruthyProp( art, prop ) {
-    const processed = Object.create(null); // avoid infloops with circular refs
+    const processed = Object.create( null ); // avoid infloops with circular refs
     let name = art.name.absolute;        // is ok, since no recursive type possible
     while (art && !processed[name]) {
       if (art[prop])
@@ -568,7 +576,7 @@ function generate( model ) {
     return;
 
     function baseKeys() {
-      const k = Object.create(null);
+      const k = Object.create( null );
       for (const name in base.elements) {
         const elem = base.elements[name];
         if (elem.$duplicates)
@@ -654,22 +662,22 @@ function generate( model ) {
       return false;
     }
     const names = Object.keys( target.elements )
-      .filter( n => n.startsWith('up__') && keyNames.includes( n.substring(4) ) );
+      .filter( n => n.startsWith( 'up__' ) && keyNames.includes( n.substring(4) ) );
     if (names.length) {
       // FUTURE: if named type, add sub info with location of "up_" element
       error( null, [ location, elem ], { target: entityName, names }, {
         std: 'Key elements $(NAMES) can\'t be added to $(TARGET) as these already exist',
         one: 'Key element $(NAMES) can\'t be added to $(TARGET) as it already exist',
-      });
+      } );
       return false;
     }
 
-    if (elem.type && !isDirectComposition(elem)) {
+    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');
+               'Expected $(PROP), but found $(OTHERPROP) for composition of aspect' );
     }
 
     return true;
@@ -689,9 +697,14 @@ function generate( model ) {
 
     const art = {
       kind: 'entity',
-      name: { path: splitIntoPath( location, entityName ), absolute: entityName, location },
+      name: {
+        path: splitIntoPath( location, entityName ),
+        absolute: entityName,
+        // for code navigation (e.g. via `extend`s): point to the element's name
+        location: elem.name.location,
+      },
       location,
-      elements: Object.create(null),
+      elements: Object.create( null ),
       $inferred: 'composition-entity',
     };
     if (target.name) {          // named target aspect
@@ -704,17 +717,19 @@ function generate( model ) {
       setLink( art, '_upperAspects', elem._main._upperAspects || [] );
     }
 
+    // Since there is no user-written up_ element, use a weak location to the beginning of {…}.
+    const upLocation = weakLocation( location );
     const up = { // elements.up_ = ...
-      name: { location, id: 'up_' },
+      name: { location: upLocation, id: 'up_' },
       kind: 'element',
-      location,
+      location: upLocation,
       $inferred: 'aspect-composition',
-      type: augmentPath( location, 'cds.Association' ),
-      target: augmentPath( location, base.name.absolute ),
+      type: augmentPath( upLocation, 'cds.Association' ),
+      target: augmentPath( upLocation, base.name.absolute ),
       cardinality: {
-        targetMin: { val: 1, literal: 'number', location },
-        targetMax: { val: 1, literal: 'number', location },
-        location,
+        targetMin: { val: 1, literal: 'number', location: upLocation },
+        targetMax: { val: 1, literal: 'number', location: upLocation },
+        location: upLocation,
       },
     };
     // By default, 'up_' is a managed primary key association.
@@ -723,16 +738,17 @@ function generate( model ) {
     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__' );
+      up.on = augmentEqual( upLocation, 'up_', Object.values( keys ), 'up__' );
     }
     else {
-      up.key = { location, val: true };
+      up.key = { location: upLocation, val: true };
       // managed associations must be explicitly set to not null
       // even if target cardinality is 1..1
-      up.notNull = { location, val: true };
+      up.notNull = { location: upLocation, val: true };
     }
 
-    dictAdd( art.elements, 'up_', up);
+    dictAdd( art.elements, 'up_', up );
+    // Only for named aspects, use a new location; otherwise use the origin's one.
     addProxyElements( art, target.elements, 'aspect-composition', target.name && location );
 
     setLink( art, '_block', model.$internal );
@@ -750,7 +766,7 @@ function generate( model ) {
     for (const name in elements) {
       const pname = `${ prefix }${ name }`;
       const origin = elements[name];
-      const proxy = linkToOrigin( origin, pname, null, null, location || origin.location );
+      const proxy = linkToOrigin( origin, pname, null, null, location, true );
       setLink( proxy, '_block', origin._block );
       proxy.$inferred = inferred;
       if (origin.masked)
@@ -801,7 +817,7 @@ function augmentEqual( location, assocname, relations, prefix = '' ) {
     : { op: { val: 'and', location }, args, location };
 
   function eq( refs ) {
-    if (Array.isArray(refs))
+    if (Array.isArray( refs ))
       return { op: { val: '=', location }, args: refs.map( ref ), location };
 
     const { id } = refs.name;
@@ -815,7 +831,7 @@ function augmentEqual( location, assocname, relations, prefix = '' ) {
     };
   }
   function ref( path ) {
-    return { path: path.split('.').map( id => ({ id, location }) ), location };
+    return { path: path.split( '.' ).map( id => ({ id, location }) ), location };
   }
 }
 
@@ -826,12 +842,12 @@ function checkTextsLanguageAssocOption( model, options ) {
   if (options.addTextsLanguageAssoc && !commonLanguagesEntity) {
     const variant = !languages ? 'std' : 'code';
     const loc = model.definitions['sap.common.Languages']?.name?.location || null;
-    model.$messageFunctions.info('api-ignoring-language-assoc', loc, {
+    model.$messageFunctions.info( 'api-ignoring-language-assoc', loc, {
       '#': variant, option: 'addTextsLanguageAssoc', art: 'sap.common.Languages', name: 'code',
     }, {
       std: 'Ignoring option $(OPTION) because entity $(ART) is missing',
       code: 'Ignoring option $(OPTION) because entity $(ART) is missing element $(NAME)',
-    });
+    } );
   }
 
   return !!commonLanguagesEntity;

package/lib/compiler/index.js

@@ -12,7 +12,7 @@
 
 'use strict';
 
-const { resolveModule, resolveModuleSync } = require('../utils/moduleResolve');
+const { makeModuleResolver, makeModuleResolverSync } = require('../utils/moduleResolve');
 const parseLanguage = require('../language/antlrParser'); // TODO: should we do some lazyload here?
 const parseCsn = require('../json/from-csn');
 
@@ -53,7 +53,7 @@ const extensionParsers = {
 //  `errors`: vector of errors (file IO or ArgumentError)
 class InvocationError extends Error {
   constructor( errs, ...args ) {
-    super(...args);
+    super( ...args );
     this.code = 'ERR_CDS_COMPILER_INVOCATION';
     this.errors = errs;
     this.hasBeenReported = false;
@@ -64,7 +64,7 @@ class InvocationError extends Error {
 //  `argument`: the command argument (repeated file names)
 class ArgumentError extends Error {
   constructor( arg, ...args ) {
-    super(...args);
+    super( ...args );
     this.code = 'ERR_CDS_COMPILER_ARGUMENT';
     this.argument = arg;
   }
@@ -86,15 +86,15 @@ function parseX( source, filename, options = {}, messageFunctions = null ) {
   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)
+    ? (source?.startsWith( '{' ) ? parseCsn.parse : parseLanguage)
     : (extensionParsers[ext] || extensionParsers[options.fallbackParser] ||
-       source.startsWith('{') && parseCsn.parse);
+       source.startsWith( '{' ) && parseCsn.parse);
   if (parser)
     return parser( source, filename, options, messageFunctions );
 
   const model = new XsnSource();
   model.location = new CsnLocation( filename );
-  messageFunctions.error( 'file-unknown-ext', emptyWeakLocation(filename),
+  messageFunctions.error( 'file-unknown-ext', emptyWeakLocation( filename ),
                           { file: ext, '#': !ext && 'none' }, {
                             std: 'Unknown file extension $(FILE)',
                             none: 'No file extension',
@@ -131,29 +131,30 @@ function parseX( source, filename, options = {}, messageFunctions = null ) {
 //  - 'string' or instanceof Buffer: the file content
 //  - { realname: fs.realpath(filename) }: if filename is not canonicalized
 //
-function compileX( filenames, dir = '', options = {}, fileCache = Object.create(null) ) {
+function compileX( filenames, dir = '', options = {}, fileCache = Object.create( null ) ) {
   // A non-proper dictionary (i.e. with prototype) is safe if the keys are
   // absolute file names - they start with `/` or `\` or similar
   // if (Object.getPrototypeOf( fileCache ))
   //   fileCache = Object.assign( Object.create(null), fileCache );
-  dir = path.resolve(dir);
+  dir = path.resolve( dir );
   const model = { sources: null, options };
   model.$messageFunctions = createMessageFunctions( options, 'compile', model );
+  const { resolveModule } = makeModuleResolver( options, fileCache, model.$messageFunctions );
   let input = null;
 
   let all = processFilenames( filenames, dir )
-    .then((processedInput) => {
+    .then( (processedInput) => {
       input = processedInput;
       model.sources = input.sources;
-    })
-    .then(() => promiseAllDoNotRejectImmediately( input.files.map(readAndParse) ))
+    } )
+    .then( () => promiseAllDoNotRejectImmediately( input.files.map( readAndParse ) ) )
     .then( testInvocation, (reason) => {
       // do not reject with PromiseAllError, use InvocationError:
       const errs = reason.valuesOrErrors.filter( e => e instanceof Error );
       // internal error if no file IO error (has property `path`)
       return Promise.reject( errs.find( e => !e.path ) ||
                              new InvocationError( [ ...input.repeated, ...errs ]) );
-    });
+    } );
 
   if (!options.parseOnly && !options.parseCdl)
     all = all.then( readDependencies );
@@ -161,7 +162,7 @@ function compileX( filenames, dir = '', options = {}, fileCache = Object.create(
   return all.then( () => {
     moduleLayers.setLayers( input.sources );
     return compileDoX( model );
-  });
+  } );
 
   // Read file `filename` and parse its content, return messages
   async function readAndParse( filename ) {
@@ -210,10 +211,8 @@ function compileX( filenames, dir = '', options = {}, fileCache = Object.create(
       }
       // create promises after all usingFroms have been collected, as the
       // Promise executor is called immediately with `new`:
-      for (const module in dependencies) {
-        promises.push( resolveModule( dependencies[module], fileCache, options,
-                                      model.$messageFunctions ) );
-      }
+      for (const module in dependencies)
+        promises.push( resolveModule( dependencies[module] ) );
     }
     if (!promises.length)
       return [];
@@ -236,23 +235,25 @@ function compileX( filenames, dir = '', options = {}, fileCache = Object.create(
  * @param {object} [fileCache]
  * @returns {XSN.Model} Augmented CSN
  */
-function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.create(null) ) {
+function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.create( null ) ) {
   // A non-proper dictionary (i.e. with prototype) is safe if the keys are
   // absolute file names - they start with `/` or `\` or similar
-  dir = path.resolve(dir);
+  dir = path.resolve( dir );
   const a = processFilenamesSync( filenames, dir );
 
   const model = { sources: a.sources, options };
   model.$messageFunctions = createMessageFunctions( options, 'compile', model );
+  const { resolveModuleSync } = makeModuleResolverSync( options, fileCache,
+                                                        model.$messageFunctions );
 
   const asts = [];
   const errors = [];
   a.files.forEach( val => readAndParseSync( val, (err, ast) => {
     if (err)
-      errors.push(err);
+      errors.push( err );
     if (ast)
-      asts.push(ast);
-  }));
+      asts.push( ast );
+  } ) );
 
   if (errors.length || a.repeated.length) {
     // internal error if no file IO error (has property `path`)
@@ -266,12 +267,12 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
       asts.length = 0;
       // Push dependencies to `ast`. Only works because readAndParseSync() is synchronous.
       for (const fileName of fileNames) {
-        readAndParseSync(fileName, ( err, ast ) => {
+        readAndParseSync( fileName, ( err, ast ) => {
           if (err)
             throw err;
           if (ast)
             asts.push( ast );
-        });
+        } );
       }
     }
   }
@@ -282,12 +283,12 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
   // Read file `filename` and parse its content, return messages
   function readAndParseSync( filename, cb ) {
     if ( filename === false ) {   // module which has not been found
-      cb(null, null);
+      cb( null, null );
       return;
     }
     const rel = a.sources[filename] || path.relative( dir, filename );
     if (typeof rel === 'object') { // already parsed
-      cb(null, null);
+      cb( null, null );
       return;                 // no further dependency processing
     }
     // no parallel readAndParse with same resolved filename should read the file,
@@ -296,7 +297,7 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
 
     cdsFs( fileCache, options.traceFs ).readFileSync( filename, 'utf8', (err, source) => {
       if (err) {
-        cb(err, null);
+        cb( err, null );
       }
       else {
         try {
@@ -308,10 +309,10 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
           cb( null, ast );
         }
         catch (e) {
-          cb(e, null);
+          cb( e, null );
         }
       }
-    });
+    } );
   }
 
   function readDependenciesSync( astArray ) {
@@ -331,10 +332,8 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
       }
       // create promises after all usingFroms have been collected, as the
       // Promise executor is called immediately with `new`:
-      for (const module in dependencies) {
-        fileNames.push( resolveModuleSync( dependencies[module], fileCache, options,
-                                           model.$messageFunctions ) );
-      }
+      for (const module in dependencies)
+        fileNames.push( resolveModuleSync( dependencies[module] ) );
     }
     if (!fileNames.length)
       return [];
@@ -366,7 +365,7 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
 function compileSourcesX( sourcesDict, options = {} ) {
   if (typeof sourcesDict === 'string')
     sourcesDict = { '<stdin>.cds': sourcesDict };
-  const sources = Object.create(null);
+  const sources = Object.create( null );
   const model = { sources, options };
   model.$messageFunctions = createMessageFunctions( options, 'compile', model );
 
@@ -424,9 +423,9 @@ function recompileX( csn, options ) {
   // TODO: $recompile: true should be enough
 
   const file = csn.$location && csn.$location.file &&
-    csn.$location.file.replace(/[.]cds$/, '.cds.csn') || '<recompile>.csn';
+    csn.$location.file.replace( /[.]cds$/, '.cds.csn' ) || '<recompile>.csn';
 
-  const sources = Object.create(null);
+  const sources = Object.create( null );
   const model = { sources, options };
   model.$messageFunctions = createMessageFunctions( options, 'compile', model );
   // TODO: or use module which invokes the recompilation?
@@ -435,7 +434,7 @@ function recompileX( csn, options ) {
   moduleLayers.setLayers( sources );
   const compiled = compileDoX( model ); // calls throwWithError()
   if (options.messages)         // does not help with exception in compileDoX()
-    deduplicateMessages(options.messages); // TODO: do better
+    deduplicateMessages( options.messages ); // TODO: do better
   return compiled;
 }
 
@@ -480,12 +479,11 @@ function compileDoX( model ) {
   resolve( model );
   tweakAssocs( model );
   assertConsistency( model );
+  check( model );
   throwWithError();
   if (options.lintMode)
     return model;
 
-  check(model);
-  throwWithError();
   return propagator.propagate( model );
 }
 
@@ -500,7 +498,7 @@ function compileDoX( model ) {
  * not normalized - any strings work
  */
 async function processFilenames( filenames, dir ) {
-  const filenameMap = Object.create(null);
+  const filenameMap = Object.create( null );
 
   const promises = [];
   for (const originalName of filenames) {
@@ -510,12 +508,12 @@ async function processFilenames( 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.
-    const promise = fs.promises.realpath(path.resolve(dir, originalName))
-      .then(setName, () => setName(originalName));
-    promises.push(promise);
+    const promise = fs.promises.realpath( path.resolve( dir, originalName ) )
+      .then( setName, () => setName( originalName ) );
+    promises.push( promise );
   }
 
-  await Promise.all(promises);
+  await Promise.all( promises );
   return createSourcesDict( filenames, filenameMap, dir );
 }
 
@@ -523,15 +521,15 @@ async function processFilenames( filenames, dir ) {
  * Synchronous version of processFilenames().
  */
 function processFilenamesSync( filenames, dir ) {
-  const filenameMap = Object.create(null);
+  const filenameMap = Object.create( null );
 
   for (const originalName of filenames) {
-    let name = path.resolve(dir, originalName);
+    let name = path.resolve( dir, originalName );
     try {
       // 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.native(name);
+      name = fs.realpathSync.native( name );
     }
     catch (e) {
       // Ignore the not-found (ENOENT) error
@@ -553,7 +551,7 @@ function processFilenamesSync( filenames, dir ) {
  * @return {{sources: object, files: string[], repeated: ArgumentError[]}}
  */
 function createSourcesDict( filenames, filenameMap, dir ) {
-  const sources = Object.create(null);
+  const sources = Object.create( null );
   const files = [];
   const repeated = [];
 
@@ -561,7 +559,7 @@ function createSourcesDict( filenames, filenameMap, dir ) {
     const name = filenameMap[originalName];
     if (!sources[name]) {
       sources[name] = path.relative( dir, name );
-      files.push(name);
+      files.push( name );
     }
     else if (typeof sources[name] === 'string') { // not specified more than twice
       const msg = `Repeated argument: file '${ sources[name] }'`;

package/lib/compiler/kick-start.js

@@ -33,7 +33,7 @@ function kickStart( model ) {
     const art = model.definitions[name];
     if (art._parent === undefined)
       return;                   // nothing to do for builtins and redefinitions
-    if (art.query && art._ancestors === undefined)
+    if (art.query && art._ancestors === undefined && art.kind === 'entity')
       setProjectionAncestors( art );
 
     let parent = art._parent;
@@ -44,7 +44,7 @@ function kickStart( model ) {
     if (!parent || !service)
       return;
     // To be removed when nested services are allowed
-    if (!isBetaEnabled(options, 'nestedServices') && art.kind === 'service') {
+    if (!isBetaEnabled( options, 'nestedServices' ) && art.kind === 'service') {
       while (parent.kind !== 'service')
         parent = parent._parent;
       message( 'service-nested-service', [ art.name.location, art ], { art: parent },
@@ -66,15 +66,16 @@ function kickStart( model ) {
     // TODO: do not do implicit redirection across services, i.e. Service2.E is
     // no redirection target for E if Service2.E = projection on Service1.E and
     // Service1.E = projection on E
+
+    // Remark: _ancestors are also set with includes, and there also for aspects,
+    // types and events.
     const chain = [];
     const autoexposed = annotationVal( art['@cds.autoexposed'] );
-    const preferredRedirectionTarget = annotationVal( art['@cds.redirection.target'] );
     // no need to set preferredRedirectionTarget in the while loop as we would
     // use the projection having @cds.redirection.target anyhow instead of
     // `art` anyway (if we do the no-x-service-implicit-redirection TODO above)
     while (art?.query?.from?.path && // direct select with one source
-           art._ancestors !== 0 &&        // prevent inf-loop
-           (preferredRedirectionTarget || !annotationIsFalse( art['@cds.redirection.target'] ) )) {
+           art._ancestors !== 0) {   // prevent inf-loop
       chain.push( art );
       setLink( art, '_ancestors', 0 ); // avoid infloop with cyclic from
       const name = resolveUncheckedPath( art.query.from, 'from', art );
@@ -109,10 +110,10 @@ function kickStart( model ) {
     return;
 
     function expose( ancestor ) {
-      if (ancestor._service === service)
+      if (ancestor._service === service || annotationIsFalse( art['@cds.redirection.target'] ))
         return;
       const desc = ancestor._descendants ||
-            setLink( ancestor, '_descendants', Object.create(null) );
+            setLink( ancestor, '_descendants', Object.create( null ) );
       if (!desc[sname])
         desc[sname] = [ art ];
       else

package/lib/compiler/moduleLayers.js

@@ -23,7 +23,7 @@ function setLayers( sources ) {
 
   // It is ensured that the representative is called last in SCC and that
   // dependent SCCs are called first
-  function setExtends( node, representative, sccDeps = Object.create(null) ) {
+  function setExtends( node, representative, sccDeps = Object.create( null ) ) {
     setLink( node, '_layerRepresentative', representative );
     if (layerRepresentative !== representative) {
       layerRepresentative = representative;