@sap/cds-compiler 3.1.2 → 3.4.0

package/lib/compiler/kick-start.js

@@ -10,7 +10,6 @@ function kickStart( model ) {
   const { message } = model.$messageFunctions;
 
   const { resolveUncheckedPath, resolvePath } = model.$functions;
-  Object.assign( model.$functions, { projectionAncestor } );
 
   // Set _service link (sorted to set it on parent first).  Could be set
   // directly, but beware a namespace becoming a service later.
@@ -68,7 +67,7 @@ function kickStart( model ) {
     // no redirection target for E if Service2.E = projection on Service1.E and
     // Service1.E = projection on E
     const chain = [];
-    const autoexposed = art.$generated || annotationVal( art['@cds.autoexposed'] );
+    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
@@ -80,7 +79,7 @@ function kickStart( model ) {
       chain.push( art );
       setLink( art, '_ancestors', null ); // avoid infloop with cyclic from
       const name = resolveUncheckedPath( art._from[0], 'include', art ); // TODO: 'include'?
-      art = name && projectionAncestor( model.definitions[name], art.params );
+      art = name && model.definitions[name];
       if (autoexposed)
         break;                  // only direct projection for auto-exposed
     }
@@ -93,38 +92,6 @@ function kickStart( model ) {
     }
   }
 
-  // Return argument `source` if entity `source` has parameters like `params`
-  // - same parameters, although `params` can contain a new optional one (with DEFAULT)
-  // - a parameter in `params` can be optional which is not in `source.params`, but not vice versa
-  // - exactly the same types (type argument do not matter)
-  function projectionAncestor( source, params ) {
-    if (!source)
-      return source;
-    if (!params)                // proj has no params => ok if source has no params
-      return !source.params && source;
-    const sourceParams = source.params || Object.create(null);
-    for (const n in sourceParams) {
-      if (!(n in params))       // source param is not projection param
-        return null;            // -> can't be used as implicit redirection target
-    }
-    for (const n in params) {
-      const pp = params[n];
-      const sp = sourceParams[n];
-      if (sp) {
-        if (sp.default && !pp.default) // param DEFAULT clause not supported yet
-          return null;          // param is not optional anymore
-        const pt = pp.type && resolveUncheckedPath( pp.type, 'type', pp );
-        const st = sp.type && resolveUncheckedPath( sp.type, 'type', sp );
-        if ((pt || null) !== (st || null))
-          return null;          // params have different type
-      }
-      else if (!pp.default) {
-        return null;
-      }        // non-optional param in projection, but not source
-    }
-    return source;
-  }
-
   function postProcessArtifact( art ) {
     tagCompositionTargets( art );
     if (art.$queries) {

package/lib/compiler/populate.js

@@ -19,7 +19,6 @@
 
 const {
   isDeprecatedEnabled,
-  isBetaEnabled,
   forEachDefinition,
   forEachMember,
   forEachGeneric,
@@ -29,6 +28,7 @@ const {
 } = require('../base/dictionaries');
 const { dictLocation } = require('../base/location');
 const { weakLocation } = require('../base/messages');
+const { CompilerAssertion } = require('../base/error');
 
 const { kindProperties } = require('./base');
 const {
@@ -36,6 +36,8 @@ const {
   setLink,
   setArtifactLink,
   annotationVal,
+  annotationIsFalse,
+  annotationLocation,
   augmentPath,
   splitIntoPath,
   linkToOrigin,
@@ -59,7 +61,6 @@ function populate( model ) {
     resolvePath,
     attachAndEmitValidNames,
     initArtifact,
-    projectionAncestor,
   } = model.$functions;
   model.$volatileFunctions.environment = environment;
   Object.assign( model.$functions, {
@@ -103,8 +104,8 @@ function populate( model ) {
   function traverseElementEnvironments( art ) {
     populateView( art );
     environment( art );
-    if (art.elements$)
-      mergeSpecifiedElements(art);
+    if (art.elements$ || art.enum$)
+      mergeSpecifiedElementsOrEnum(art);
     forEachMember( art, traverseElementEnvironments );
   }
 
@@ -188,9 +189,6 @@ function populate( model ) {
         setLink( a, '_effectiveType', art );
     }
     else {
-      let eType = art;
-      if (eType._outer)
-        eType = effectiveType( eType._outer );
       // collect the "latest" cardinality (calculate lazily if necessary)
       let cardinality = art.cardinality ||
           art._effectiveType && (() => getCardinality( art._effectiveType ));
@@ -200,8 +198,8 @@ function populate( model ) {
           cardinality = a.cardinality;
         if (a.expand && expandFromColumns( a, art, cardinality ) ||
             art.target && redirectImplicitly( a, art ) ||
-            art.elements && expandElements( a, art, eType ) ||
-            art.items && expandItems( a, art, eType ))
+            art.elements && expandElements( a, art ) ||
+            art.items && expandItems( a, art ))
           art = a;
         else if (art.enum && expandEnum( a, prev ))
           prev = a;             // do not set art - effective type is base
@@ -292,31 +290,32 @@ function populate( model ) {
   // Expansiosn --------------------------------------------------------------
 
 
-  function expandItems( art, origin, eType ) {
+  function expandItems( art, origin ) {
     if (art.items)
       return false;
-    if (isInParents( art, eType )) {
+    if (origin.items === 0 || art.$inferred === 'expanded' && isInRecursiveExpansion( art )) {
       art.items = 0;            // circular
       return true;
     }
     const ref = art.type || art.value || art.name;
     const location = ref && ref.location || art.location;
-    art.items = { $inferred: 'expand-element', location };
+    art.items = { $inferred: 'expanded', location };
     setLink( art.items, '_outer', art );
+    setLink( art.items, '_parent', art._parent );
     setLink( art.items, '_origin', origin.items );
     if (!art.$expand)
       art.$expand = 'origin';   // if value stays, elements won't appear in CSN
     return true;
   }
 
-  function expandElements( art, struct, eType ) {
-    if (art.elements || art.kind === '$tableAlias' ||
+  function expandElements( art, struct ) {
+    if (art.elements || art.kind === '$tableAlias' || art.kind === '$inline' ||
         // no element expansions for "non-proper" types like
         // entities (as parameter types) etc:
         struct.kind !== 'type' && struct.kind !== 'element' && struct.kind !== 'param' &&
         !struct._outer)
       return false;
-    if (struct.elements === 0 || isInParents( art, eType )) {
+    if (struct.elements === 0 || art.$inferred === 'expanded' && isInRecursiveExpansion( art )) {
       art.elements = 0;         // circular
       return true;
     }
@@ -331,14 +330,14 @@ function populate( model ) {
         continue;
       linkToOrigin( orig, name, art, 'elements', weakLocation( location ), true )
         // or should we use orig.location? - TODO: try to find test to see message
-        .$inferred = 'expand-element';
+        .$inferred = 'expanded';
     }
     // Set elements expansion status (the if condition is always true, as no
     // elements expansion will take place on artifact with existing other
     // member property):
     if (!art.$expand)
       art.$expand = 'origin';   // if value stays, elements won't appear in CSN
-    // TODO: have some art.elements[SYM.$inferred] = 'expand-element';
+    // TODO: have some art.elements[SYM.$inferred] = 'expanded';
     return true;
   }
 
@@ -352,39 +351,56 @@ function populate( model ) {
       const orig = origin.enum[name];
       linkToOrigin( orig, name, art, 'enum', location, true )
         // or should we use orig.location? - TODO: try to find test to see message
-        .$inferred = 'expand-element';
+        .$inferred = 'expanded';
     }
     // Set elements expansion status (the if condition is always true, as no
     // elements expansion will take place on artifact with existing other
     // member property):
     if (!art.$expand)
       art.$expand = 'origin';   // if value stays, elements won't appear in CSN
-    art.enum[$inferred] = 'expand-element';
+    art.enum[$inferred] = 'expanded';
     return true;
   }
 
   /**
-   * Return true iff `struct` is `art` or a direct or indirect parent of `art`,
-   * we also check for the outer objects of `items`.  (There is no need to
-   * check the parents of main artifacts, as these are contexts, services or
-   * namespaces, and do not serve as type.)
+   * Return true iff `art` is from a recursive expansion, i.e.  if any of its
+   * expanded parents (including _outer) has the same non-expansion-origin.
    */
-  function isInParents( art, struct ) {
-    if (art === struct)
+  function isInRecursiveExpansion( art ) {
+    const current = nonExpandedArtifact( art );
+    if (current.$inCycle)
       return true;
-    while (art._outer) {        // for items
-      art = art._outer;
-      if (art === struct)
-        return true;
-    }
-    while (art._main) {
-      art = art._parent;
-      if (art === struct)
+    const cycle = [ current ];
+    while (art.$inferred === 'expanded') {
+      art = outerOrParent( art );
+      const origin = nonExpandedArtifact( art );
+      cycle.push( origin );
+      if (origin.$inCycle || origin === current) {
+        for (const a of cycle)
+          a.$inCycle = true;
         return true;
+      }
     }
     return false;
   }
 
+  function outerOrParent( art ) {
+    if (art._outer)
+      return art._outer;
+    art = art._parent;
+    // TODO: think about setting _parent of elements in `items` object holding
+    // `elements`, not the most outer `items` -> return art._outer || art._parent
+    while (art.items)
+      art = art.items;
+    return art;
+  }
+
+  function nonExpandedArtifact( art ) {
+    while (art.$inferred === 'expanded')
+      art = art._origin;
+    return art;
+  }
+
   //--------------------------------------------------------------------------
   // Views
   //--------------------------------------------------------------------------
@@ -442,12 +458,12 @@ function populate( model ) {
    *
    * @param art
    */
-  function mergeSpecifiedElements( art ) {
+  function mergeSpecifiedElementsOrEnum( art ) {
     // Later we use specified elements as proxies to inferred of leading query
     // (No, we probably do not.)
-    for (const id in art.elements) {
-      const ielem = art.elements[id];  // inferred element
-      const selem = art.elements$[id]; // specified element
+    for (const id in (art.elements || art.enum)) {
+      const ielem = art.elements ? art.elements[id] : art.enum[id];  // inferred element
+      const selem = art.elements$ ? art.elements$[id] : art.enum$[id]; // specified element
       if (!selem) {
         info( 'query-missing-element', [ ielem.name.location, art ], { id },
               'Element $(ID) is missing in specified elements' );
@@ -463,8 +479,14 @@ function populate( model ) {
           setLink(ielem, 'elements$', selem.elements);
           delete selem.elements;
         }
+        if (selem.enum) {
+          setLink(ielem, 'enum$', selem.enum);
+          delete selem.enum;
+        }
       }
     }
+    // TODO: We don't check enum$, yet! We first need to fix expansion for
+    //       `cast(elem as EnumType)` (see #9421)
     for (const id in art.elements$) {
       const selem = art.elements$[id]; // specified element
       if (!selem.$replacement) {
@@ -569,10 +591,6 @@ function populate( model ) {
         const siblings = wildcardSiblings( columns, query );
         expandWildcard( col, siblings, inlineHead, query );
       }
-      if ((col.expand || col.inline) && !isBetaEnabled( options, 'nestedProjections' )) {
-        error( null, [ col.location, query ], { prop: (col.expand ? 'expand' : 'inline') },
-               'Unsupported nested $(PROP)' );
-      }
       // If neither expression (value), expand nor new association.
       if (!col.value && !col.expand && !(col.target && col.type))
         continue;             // error should have been reported by parser
@@ -608,10 +626,10 @@ function populate( model ) {
       return '';
     const path = col.value &&
         (col.value.path || !col.value.args && col.value.func && col.value.func.path);
-    if (path) {
+    if (path && path.length) {
       const last = !path.broken && path.length && path[path.length - 1];
       if (last) {
-        col.name = { id: last.id, location: last.location, $inferred: 'as' };
+        col.name = { id: last.id || '', location: last.location, $inferred: 'as' };
         return col.name.id;
       }
     }
@@ -645,18 +663,28 @@ function populate( model ) {
     // console.log( message( null, elem.location, elem, {art:query}, 'Info','RED').toString(),
     //              elem.value)
     // TODO: make this resolvePath() also part of directType() ?!
-    if (!origin)
+    if (!origin || elem.expand)
       return;
+    // TODO: or should we push elems with `expand` sibling to extra list for better messages?
     if (elem.foreignKeys) {   // REDIRECTED with explicit foreign keys
       forEachGeneric( elem, 'foreignKeys', (key, name) => initKey( key, name, elem ) );
     }
 
     // now set things which are necessary for later sub phases:
     const nav = pathNavigation( elem.value );
-    if (nav.navigation && nav.item === elem.value.path[elem.value.path.length - 1]) {
+    const item = elem.value.path[elem.value.path.length - 1];
+    if (nav.navigation && nav.item === item) {
+      // sourceElem, alias.sourceElem, mixin:
       // redirectImplicitly( elem, origin );
       pushLink( nav.navigation, '_projections', elem );
     }
+    else if (elem._pathHead?.kind === '$inline' && elem.value.path.length === 1) {
+      const hpath = elem._pathHead.value?.path;
+      const head = hpath?.length === 1 && hpath[0]._navigation;
+      // Alias .{ elem } - but not with Alias.{ $magic }: consider for ON-rewrite
+      if (head?.kind === '$tableAlias' && item.id.charAt(0) !== '$')
+        pushLink( head.elements[item.id], '_projections', elem );
+    }
   }
 
   function initKey( key, name, elem ) {
@@ -701,7 +729,7 @@ function populate( model ) {
     //             Object.keys(env),Object.keys(elements))
     for (const name in env) {
       const navElem = env[name];
-      // TODO: if it is an array, filter out those with masked
+      // TODO: remove all access to masked (use 'grep')
       if (excludingDict[name] || navElem.masked && navElem.masked.val)
         continue;
       const sibling = siblingElements[name];
@@ -770,13 +798,17 @@ function populate( model ) {
         path && path[path.length - 1].id !== sibling.name.id) { // or renamed
       const { id } = sibling.name;
       if (Array.isArray(navElem)) {
+        // ID published! Used in stakeholder project; if renamed, add to oldMessageIds
         info( 'wildcard-excluding-many', [ sibling.name.location, query ], { id },
-              'This select item replaces $(ID) from two or more sources' );
+          // eslint-disable-next-line max-len
+              'This select item replaces $(ID) from two or more sources. Add $(ID) to $(KEYWORD) to silence this message' );
       }
       else {
+        // ID published! Used in stakeholder project; if renamed, add to oldMessageIds
         info( 'wildcard-excluding-one', [ sibling.name.location, query ],
-              { id, alias: navElem._parent.name.id },
-              'This select item replaces $(ID) from table alias $(ALIAS)' );
+              { id, alias: navElem._parent.name.id, keyword: 'excluding' },
+          // eslint-disable-next-line max-len
+              'This select item replaces $(ID) from table alias $(ALIAS). Add $(ID) to $(KEYWORD) to silence this message' );
       }
     }
   }
@@ -787,9 +819,13 @@ function populate( model ) {
     queryElem.value = { path, location }; // TODO: can we omit that?  We have _origin
     setArtifactLink( path[0], origin );
     setLink( queryElem, '_origin', origin );
-    // TODO: set _projections when top-level?
+    // set _projections when inline with table alias:
+    const alias = pathHead?.value?.path?.[0]?._navigation;
+    if (alias?.kind === '$tableAlias')
+      pushLink( alias.elements[name], '_projections', queryElem );
   }
 
+  // called by expandWildcard():
   function setElementOrigin( queryElem, navElem, name, location ) {
     const sourceElem = navElem._origin;
     const alias = navElem._parent;
@@ -892,7 +928,7 @@ function populate( model ) {
           preferredElemScope( target, service, elem, assoc._main || assoc );
     const exposed = minimalExposure( target, service, elemScope );
 
-    if (!exposed.length && elemScope !== true) {
+    if (!exposed.length) {
       const origTarget = target;
       if (isAutoExposed( target ))
         target = createAutoExposed( origTarget, service, elemScope );
@@ -930,7 +966,7 @@ function populate( model ) {
       for (const proj of exposed) {
         // TODO: def-ambiguous-target (just v3, as the current is infamous and used in options),
         message( 'redirected-implicitly-ambiguous',
-                 [ weakLocation( proj.location ), proj ],
+                 [ weakLocation( proj.name.location ), proj ],
                  {
                    '#': withAnno && 'justOne',
                    target,
@@ -989,10 +1025,12 @@ function populate( model ) {
     const targetScope = definitionScope( target );
     if (targetScope === assocScope) { // intra-scope in model
       const elemScope = definitionScope( elem._main || elem );
-      if (targetScope === target ||  // unscoped target in model
+      // without the if, compile.recompile.json versus expected csn.json in
+      // test3/Redirections/AutoExposeDeepScoped would fail
+      if (targetScope === target ||  // model target is scope root
           assocScope === assocMain || // unscoped assoc source in model
           elemScope !== (elem._main || elem)) // scoped assoc source in service
-        return elemScope;                     // own scope, then global
+        return elemScope;         // own scope, then global
     }
     if (targetScope === target)  // unscoped target in model / other service
       return false;              // all (there could be no scoped autoexposed)
@@ -1021,17 +1059,6 @@ function populate( model ) {
   function scopedExposure( descendants, elemScope, target ) {
     if (!elemScope)             // no scoped redirections
       return descendants;
-    if (elemScope === true || elemScope === 'auto') {
-      // cross-scope navigation, scoped model target, but there is no unique
-      // redirection target for target model scope -> unsure redirection scope
-      const unscoped = descendants.filter( d => d === definitionScope( d ) );
-      if (unscoped.length)      // use unscoped new targets if present
-        return unscoped;
-      // Need to filter out auto-exposed, otherwise the behavior is
-      // processing-order dependent (not storing the autoexposed in
-      // _descendents would only be an alternative w/o recompilation)
-      return descendants.filter( d => !d.$generated && !annotationVal( d['@cds.autoexposed'] ) );
-    }
     // try scope as target first, even if it has @cds.redirection.target: false
     if (isDirectProjection( elemScope, target ))
       return [ elemScope ];
@@ -1059,7 +1086,6 @@ function populate( model ) {
 
   function isDirectProjection( proj, base ) {
     return proj.kind === 'entity' && // not event
-      projectionAncestor( base, proj.params ) && // same params
       // direct proj (TODO: or should we add them to another list?)
       proj.query && proj.query.op && proj.query.op.val === 'SELECT' &&
       proj._from && proj._from.length === 1 &&
@@ -1137,8 +1163,25 @@ function populate( model ) {
     const autoexposed = model.definitions[absolute];
     if (autoexposed && (autoexposed.kind !== 'namespace' || !scopedRedirections)) {
       if (isDirectProjection( autoexposed, target )) {
-        if (options.testMode)
-          throw new Error( `Tried to auto-expose ${ target.name.absolute } twice`);
+        const anno = autoexposed['@cds.redirection.target'];
+        if (annotationIsFalse( anno )) {
+          // It would probably be cleaner to ignore a dubious
+          // `@cds.redirection.target: false` earlier, but that is not easy to detect
+          // due to the name of the autoexposed entity with scoped redirections
+          if (!anno.$errorReported) {
+            info( 'anno-redirecting-anyway',
+                  [ annotationLocation( anno ), autoexposed ],
+                  { target, art: absolute, code: '@cds.redirection.target: false' },
+                  '$(TARGET) is auto-redirected to $(ART) even with $(CODE)' );
+            anno.$errorReported = 'anno-redirecting-anyway';
+          }
+        }
+        else if (autoexposed._parent === service ||
+                 !annotationVal( autoexposed['@cds.autoexposed'] )) {
+          // existing def not auto-exposed, or un-scoped auto-exposed: should not happen
+          if (options.testMode)
+            throw new CompilerAssertion( `Tried to auto-expose ${ target.name.absolute } twice`);
+        }
         return autoexposed;
       }
       error( 'duplicate-autoexposed', [ service.name.location, service ],

package/lib/compiler/propagator.js

@@ -93,12 +93,14 @@ function propagate( model ) {
       source = getOrigin( target );
     }
     if (source) {               // the source has fully propagated properties
-      step({ target, source });
+      chain.push({ target, source });
     }
     else if (target._main) {    // source is element, which has not inherited props yet
       run( target._main );       // run on main artifact first
     }
-    else if (target.includes) {
+
+    // Even with a query source, go through `includes`. `source` is propagated first, i.e. wins.
+    if (target.includes) {
       let targets = [ target ];
       while (targets.length) {
         const news = [];
@@ -233,7 +235,7 @@ function propagate( model ) {
   }
 
   function onlyViaParent( prop, target, source ) {
-    if (target.$inferred === 'proxy' || target.$inferred === 'expand-element')
+    if (target.$inferred === 'proxy' || target.$inferred === 'expanded')
       // assocs and enums do not have 'include'
       always( prop, target, source );
   }