@sap/cds-compiler 6.6.2 → 6.7.2

package/lib/compiler/shared.js

@@ -43,11 +43,15 @@ function fns( model ) {
   // Map `exprCtx` (is a param of traversal functions) to reference semantics
   const referenceSemantics = {
     // global: ------------------------------------------------------------------
-    using: {                    // only used to produce error message
-      isMainRef: 'all',
+    using: {                    // only used to produce warnings
+      isMainRef: 'no-leaf-gap',
       lexical: null,
       dynamic: modelDefinitions,
       notFound: undefinedDefinition,
+      messageMap: {
+        'ref-undefined-art': 'ref-undefined-using',
+        'ref-undefined-def': 'ref-undefined-using',
+      },
     },
     // scope:'global': for cds.Association and auto-redirected targets
     $global: {
@@ -58,14 +62,14 @@ function fns( model ) {
     },
     // only used for the main annotate/extend statements, not inner ones:
     annotate: {
-      isMainRef: 'all',
+      isMainRef: 'no-leaf-gap',
       lexical: userBlock,
       dynamic: modelDefinitions,
       notFound: undefinedForAnnotate,
       accept: extendableArtifact,
     },
     'annotate-sec': {
-      isMainRef: 'all',
+      isMainRef: 'no-leaf-gap',
       lexical: userBlock,
       dynamic: modelDefinitions,
       notFound: undefinedDefinition,
@@ -660,7 +664,6 @@ function fns( model ) {
     if (!root)
       return setArtifactLink( ref, root );
 
-    // how many path items are for artifacts (rest: elements)
     let art = getPathItem( ref, semantics, user );
     if (!art)
       return setArtifactLink( ref, art );
@@ -838,16 +841,19 @@ function fns( model ) {
     const dynamicDict = semantics.dynamic( ruser, user._user && user._artifact );
     if (!dynamicDict)                // avoid consequential errors
       return setArtifactLink( head, null );
+
     const isVar = (semantics.dollar && head.id.charAt( 0 ) === '$');
     const dict = (isVar) ? model.$magicVariables.elements : dynamicDict;
-    const r = dict[head.id];
+    const r = dict[head.id] ||  // or a ref like "MyEntity.texts" in CSN
+      isMainRef && Functions.generateOnDemand?.( head.id );
     if (r)
       return setArtifactLink( head, r );
 
     if (!semantics.dollar) {
       valid.push( dynamicDict );
+      const noGen = !definedViaCdl( ruser );
       if (isMainRef)            // eslint-disable-next-line no-return-assign
-        valid.forEach( ( d, idx ) => (valid[idx] = removeGapArtifact( d )) );
+        valid.forEach( ( d, idx ) => (valid[idx] = removeGapArtifact( d, noGen )) );
     }
     else {
       const filterFn = semantics.variableFilter || removeRestrictedVariables;
@@ -871,6 +877,7 @@ function fns( model ) {
   function getPathItem( ref, semantics, user ) {
     // let art = (headArt && headArt.kind === '$tableAlias') ? headArt._origin : headArt;
     const { path } = ref;
+    // how many path items are for artifacts (the rest are for elements):
     let artItemsCount = 0;
     const { isMainRef } = semantics;
     if (isMainRef) {
@@ -894,7 +901,10 @@ function fns( model ) {
       const envFn = (artItemsCount >= 0) ? artifactsEnv : elementsEnv;
       // TOOD: call envFn with location of last item (for dependency error)
       const env = envFn( art, path[index - 1].location, user );
-      const found = env && env[item.id];  // not env?.[item.id] ! …we want to keep the 0
+      let found = env && env[item.id];  // not env?.[…] - keep a `0`
+      if (!found && found !== 0 && artItemsCount >= 0)
+        found = Functions.generateOnDemand?.( `${ prev.name.id }.${ item.id }` );
+
       // Reject `$self.$_column_1`: TODO: necessary to do here again?
       art = setArtifactLink( item, (found?.name?.$inferred === '$internal') ? undefined : found );
 
@@ -904,24 +914,33 @@ function fns( model ) {
         const notFound = (artItemsCount >= 0) ? semantics.notFound : undefinedItemElement;
         // TODO: streamline function arguments (probably: user, path, semantics, prev )
         // false returned by semantics.navigation: no further error:
-        if (env !== false)
-          notFound( user, item, [ env ], null, prev, path, semantics );
+        if (env !== false) {
+          const exp = (artItemsCount >= 0)
+            ? removeGapArtifact( env, !definedViaCdl( user ) )
+            : env;
+          notFound( user, item, [ exp ], null, prev, path, semantics );
+        }
         return null;
       }
       // need to do that here, because we also need to disallow Service.AutoExposed:elem
       // TODO: but Service.AutoExposed.NotAuto should be fine
       if (isMainRef && isMainRef !== 'all' && artItemsCount === 0) {
         if (art.kind === 'namespace') {
+          if (Functions.generateOnDemand?.( art ) ||
+              isMainRef === 'no-leaf-gap' && art._subArtifacts)
+            continue;           // art is generated entity assigned to gap object
           if (env !== false) {
-            semantics.notFound( user, item, [ removeGapArtifact( env ) ],
+            semantics.notFound( user, item, [ removeGapArtifact( env, !definedViaCdl( user ) ) ],
                                 null, prev, path, semantics );
           }
           return null;
         }
-        else if (art.$inferred === 'autoexposed' && !user.$inferred) {
+        else if (art.$inferred === 'autoexposed' && !user.$inferred &&
+                 isMainRef !== 'no-leaf-gap') {
           // Depending on the processing sequence, the following could be a
           // simple 'ref-undefined-art'/'ref-undefined-def' - TODO: which we
           // could "change" to this message at the end of compile():
+          // HINT: this does not appear anymore
           error( 'ref-unexpected-autoexposed', [ item.location, user ], { art },
                  'An auto-exposed entity can\'t be referred to - expose entity $(ART) explicitly' );
           return null;            // continuation semantics: like “not found”
@@ -983,9 +1002,8 @@ function fns( model ) {
 
     switch (art.kind) {
       case 'using': {
-        const def = model.definitions[art.extern.id];
-        if (!def)
-          return def;
+        const def = model.definitions[art.extern.id] ||
+          Functions.createGapArtifact( art.extern.id, art.extern.location );
         if (def.$duplicates)
           return false;
         art = setArtifactLink( head, def ); // we do not want to see the using
@@ -994,15 +1012,21 @@ function fns( model ) {
       }
       /* FALLTHROUGH */
       case 'namespace': {
-        if (semantics.isMainRef === 'all' || path.length !== 1 && ref.scope !== 1)
+        if (semantics.isMainRef === 'all' ||
+            semantics.isMainRef === 'no-leaf-gap' && art._subArtifacts ||
+            path.length !== 1 && ref.scope !== 1 ||
+            // "MyEntity.texts" in CSN or via `using` which is (at the moment)
+            // just a gap artifact
+            Functions.generateOnDemand?.( art ))
           return art;
+
         const valid = [];
         const lexical = userBlock( user );
         if (lexical) {
           for (let env = lexical; env; env = env._block)
             valid.push( removeGapArtifact( env.artifacts || Object.create( null ) ) );
         }
-        valid.push( removeGapArtifact( model.definitions ) );
+        valid.push( removeGapArtifact( model.definitions, !definedViaCdl( user ) ) );
         semantics.notFound?.( user._user || user, head, valid, model.definitions,
                               null, path, semantics );
 
@@ -1488,7 +1512,7 @@ function fns( model ) {
     }
     else {
       const target = art._effectiveType?.target;
-      if (target?._artifact) {
+      if (resolvePath( target, 'target', art )) {
         signalNotFound( 'ref-undefined-element', [ item.location, user ], valid,
                         { '#': 'target', art: target, id: item.id }, semantics );
       }
@@ -1622,6 +1646,9 @@ function fns( model ) {
   }
 
   function acceptStructOrBare( art, user, ref ) { // for includes[]
+    // eslint-disable-next-line @stylistic/object-curly-newline
+    if (user.kind in { context: 1, service: 1, action: 1, function: 1 })
+      return false;
     // It had been checked before that `includes` is already forbidden for
     // non-entity/aspect/type/event.
     //
@@ -1650,6 +1677,9 @@ function fns( model ) {
       // We might allow includes with elements in the future, they'd probably
       // count as specified elements with lower priority, i.e. annos, types, key
       // etc on columns beat those inherited from the include.
+      // TODO v7 forbid `extend Proj with ZeroElemAspect` even if ZeroElemAspect has
+      // 0 elements.  Making the element-length check work requires that effectiveType()
+      // has been called on the include already before.
       if (art.kind === 'aspect' &&
           (!art.elements || base.query && !Object.keys( art.elements ).length))
         return art;
@@ -2181,12 +2211,14 @@ function removeDollarNames( dict ) {
   return r;
 }
 
-function removeGapArtifact( dict ) {
+function removeGapArtifact( dict, alsoRemoveInferred ) {
   const r = Object.create( null );
   for (const name in dict) {
     const art = dict[name];
-    // TODO: for gaps with sub artifacts, we use use `${name}.` as name
+    // TODO: for gaps with sub artifacts, use `${name}.` as name
     // TODO: clarify with LSP
+    if (alsoRemoveInferred && art.$inferred)
+      continue;
     if (art.kind !== 'namespace' || art._subArtifacts)
       r[name] = dict[name];
   }

package/lib/compiler/tweak-assocs.js

@@ -2,10 +2,6 @@
 
 'use strict';
 
-const {
-  forEachGeneric,
-  forEachInOrder,
-} = require('../base/model');
 const { dictLocation, weakLocation, weakRefLocation } = require('../base/location');
 
 const {
@@ -19,6 +15,8 @@ const {
   traverseQueryExtra,
   setExpandStatus,
   getUnderlyingBuiltinType,
+  forEachGeneric,
+  forEachInOrder,
 } = require('./utils');
 const { Location } = require('../base/location');
 const { CompilerAssertion } = require('../base/error');

package/lib/compiler/utils.js

@@ -10,7 +10,7 @@
 
 'use strict';
 
-const { dictAdd, pushToDict, dictFirst } = require('../base/dictionaries');
+const { dictAdd, dictFirst } = require('../base/dictionaries');
 const { Location, weakLocation } = require('../base/location');
 const { XsnName, XsnArtifact } = require('./xsn-model');
 
@@ -145,10 +145,11 @@ function proxyCopyMembers( art, dictProp, originDict, location, kind, tmpDepreca
  * @return {XSN.Artifact}
  */
 function initItemsLinks( obj, block ) {
+  const parent = obj._parent;
   let { items } = obj;
   while (items) {
     setLink( items, '_outer', obj );
-    setLink( items, '_parent', obj._parent );
+    setLink( items, '_parent', parent );
     setLink( items, '_block', block );
     obj = items;
     items = obj.items;
@@ -162,7 +163,7 @@ function initItemsLinks( obj, block ) {
  * is most often the property `elem.name.id`.
  *
  * If argument `prop` is provided, add `elem` to the dictionary of that name,
- * e.g. `elements`.
+ * e.g. `elements`.  TODO: remove `prop`.
 */
 function setMemberParent( elem, name, parent, prop ) {
   if (prop) {              // extension or structure include
@@ -286,21 +287,6 @@ function dependsOnSilent( user, art ) {
   user._deps.push( { art } );
 }
 
-function storeExtension( elem, name, prop, parent ) {
-  if (prop === 'enum')
-    prop = 'elements';
-  const kind = `_${ elem.kind }`; // _extend or _annotate
-  if (!parent[kind])
-    setLink( parent, kind, {} );
-  // if (name === '' && prop === 'params') {
-  //   pushToDict( parent[kind], 'returns', elem ); // not really a dict
-  //   return;
-  // }
-  if (!parent[kind][prop])
-    parent[kind][prop] = Object.create( null );
-  pushToDict( parent[kind][prop], name, elem );
-}
-
 /** @type {(a: any, b: any) => boolean} */
 const testFunctionPlaceholder = () => true;
 
@@ -348,11 +334,11 @@ function augmentPath( location, ...args ) {
   return { path: args.map( id => ({ id, location }) ), location };
 }
 
-function copyExpr( expr, location ) {
+function copyExpr( expr, location, noLinks = false ) {
   if (!expr || typeof expr !== 'object')
     return expr;
   else if (Array.isArray( expr ))
-    return expr.map( e => copyExpr( e, location ) );
+    return expr.map( e => copyExpr( e, location, noLinks ) );
 
   const proto = Object.getPrototypeOf( expr );
   if (proto && proto !== Object.prototype && proto !== XsnName.prototype &&
@@ -363,16 +349,21 @@ function copyExpr( expr, location ) {
   for (const prop of Object.getOwnPropertyNames( expr )) {
     const pd = Object.getOwnPropertyDescriptor( expr, prop );
     if (!proto)
-      r[prop] = copyExpr( pd.value, location );
-
-    else if (!pd.enumerable || prop.charAt(0) === '$')
-      Object.defineProperty( r, prop, pd );
+      r[prop] = copyExpr( pd.value, location, noLinks );
 
     else if (prop === 'location')
       r[prop] = location || pd.value;
 
-    else
-      r[prop] = copyExpr( pd.value, location );
+    else if (prop.charAt(0) === '$')
+      Object.defineProperty( r, prop, pd );
+
+    else if (pd.enumerable)
+      r[prop] = copyExpr( pd.value, location, noLinks );
+
+    else if (!noLinks)
+      Object.defineProperty( r, prop, pd );
+    // TODO: probably consider noLinks just for element references (_artifact of
+    // first path item has _main) - test calc element with `cast`
   }
   return r;
 }
@@ -660,22 +651,37 @@ function isDirectComposition( art ) {
   return path?.length === 1 && path[0].id === 'cds.Composition';
 }
 
-function targetCantBeAspect( elem, calledForTargetAspectProp ) {
+function targetCantBeAspect( elem, calledForTargetAspectProp, definitions ) { // see #11658
   // Remark: we do not check `on` and `keys` here - the error should complain
   // at the `on`/`keys`, not the aspect
   if (!isDirectComposition( elem ) || elem.targetAspect && !calledForTargetAspectProp)
     return (elem.type && !elem.type.$inferred) ? 'std' : 'redirected';
+  // TODO: better msg if due to calledForTargetAspectProp
   if (!elem._main)
     return elem.kind;           // type or annotation
   // TODO: extra for "in many"?
   let art = elem;
   while (art.kind === 'element')
     art = art._parent;
+  // Remark: if we include entity/aspect, we might still have a targetAspects in a
+  // type/event - see Error[type-managed-composition]
+  // With a future feature “managed compositions in sub elements“, we might allow
+  // moving an aspect to targetAspect independently from the main artifact
+  if (definitions && art.kind === 'extend')
+    art = definitions[art.name.id];
   if (![ 'entity', 'aspect', 'event' ].includes( art.kind ))
     return (art.kind !== 'mixin') ? art.kind : 'select';
-  return ((art.query || art.kind === 'event') && !(calledForTargetAspectProp && elem.target))
-    ? art.kind
-    : elem._parent.kind === 'element' && 'sub';
+  if ((art.query || art.kind === 'event') && !(calledForTargetAspectProp && elem.target))
+    return art.kind;
+  if (elem._parent.kind === 'element')
+    return 'sub';
+  if (!calledForTargetAspectProp) {
+    if (elem.on)
+      return 'on';
+    if (elem.foreignKeys)
+      return 'keys';
+  }
+  return null;
 }
 
 function userQuery( user ) {
@@ -781,6 +787,50 @@ function compositionTextVariant( art, composition, association = 'std' ) {
     : association;
 }
 
+// Looping: ---------------------------------------------------------------------
+
+/**
+ * Apply function `callback` to all artifacts in dictionary
+ * `model.definitions`.  See function `forEachGeneric` for details.
+ * TODO: should we skip "namespaces" already here?
+ */
+function forEachDefinition( model, callback ) {
+  forEachGeneric( model, 'definitions', callback );
+}
+
+/**
+ * Apply function `callback` to all members of object `construct` (main artifact
+ * or parent member).  Members are considered those in dictionaries `elements`,
+ * `enum`, `actions` and `params` of `obj`.
+ *
+ * @param {XSN.Artifact} construct
+ * @param {(member: XSN.Artifact, memberName: string, prop: string) => void} callback
+ * @param {XSN.Artifact} [target]
+ */
+function forEachMember( construct, callback ) {
+  forEachGeneric( construct, 'elements', callback );
+  forEachGeneric( construct, 'enum', callback );
+  forEachGeneric( construct, 'foreignKeys', callback );
+  forEachGeneric( construct, 'actions', callback );
+  forEachGeneric( construct, 'params', callback );
+  if (construct.returns)
+    callback( construct.returns, '', 'params' );
+}
+
+// Apply function `callback` to all objects in dictionary `parent[prop]`,
+// including all duplicates (found under the same name).  Function `callback` is
+// called with the following arguments: the object, the name and `prop`.
+function forEachGeneric( parent, prop, callback ) {
+  const dict = parent[prop];
+  for (const name in dict) {
+    const obj = dict[name];
+    const { $duplicates } = obj;
+    callback( obj, name, prop );
+    if (Array.isArray( $duplicates )) // redefinitions
+      $duplicates.forEach( o => callback( o, name, prop ) );
+  }
+}
+
 module.exports = {
   pushLink,
   annotationVal,
@@ -801,7 +851,6 @@ module.exports = {
   initDollarSelf,
   initDollarParameters,
   initBoundSelfParam,
-  storeExtension,
   withAssociation,
   pathName,
   augmentPath,
@@ -827,4 +876,8 @@ module.exports = {
   definedViaCdl,
   artifactRefLocation,
   compositionTextVariant,
+  forEachDefinition,
+  forEachMember,
+  forEachGeneric,
+  forEachInOrder: forEachGeneric,
 };

package/lib/edm/edmAnnoPreprocessor.js

@@ -49,7 +49,7 @@ function addToSetAttr( carrier, propName, propValue, removeFromType = true ) {
 
 function applyAppSpecificLateCsnTransformationOnElement( options, element, struct, error ) {
   if (options.isV2() && struct['@Aggregation.ApplySupported.PropertyRestrictions'])
-    mapAnnotationAssignment(element, struct, AnalyticalAnnotations());
+    mapAnnotationAssignment(element, struct, GenerateAnalyticalAnnotations());
 
 
   // etag requires Core.OptimisticConcurrency to be set in V4 (cap/issues#2641)
@@ -66,7 +66,7 @@ function applyAppSpecificLateCsnTransformationOnElement( options, element, struc
                               (struct['@Core.OptimisticConcurrency'] || [])/* .push(element.name) */);
   }
 
-  function AnalyticalAnnotations() {
+  function GenerateAnalyticalAnnotations() {
     function mapCommonAttributes( elt, structure, prop ) {
       const CommonAttributes = elt[prop];
       if (!Array.isArray(CommonAttributes)) {