@sap/cds-compiler 6.9.3 → 7.0.1

package/lib/compiler/resolve.js

@@ -59,6 +59,7 @@ const {
   compositionTextVariant,
   targetCantBeAspect,
   userParam,
+  userQuery,
   forEachDefinition,
   forEachMember,
   forEachGeneric,
@@ -96,11 +97,15 @@ function resolve( model ) {
     getInheritedProp,
     hasTruthyProp,              // limited inheritance
     resolveTypeArgumentsUnchecked,
+    userTargetElementPathIndex,
+    getQueryOperatorName,
+    traverseDollarSelfPairs,
   } = model.$functions;
   Object.assign( model.$functions, {
     addForeignKeyNavigations,
     redirectionChain,
     resolveExprInAnnotations,
+    checkBacklinkPartner,
   } );
 
   const ignoreSpecifiedElements
@@ -154,6 +159,8 @@ function resolve( model ) {
     // Phase 4: resolve all artifacts:
     forEachDefinition( model, resolveRefs );
     forEachGeneric( model, 'vocabularies', resolveRefs );
+    forEachDefinition( model, checkOpenBacklinkTargets ); // after checkBacklinkPartner()
+
     if (options.lspMode) {
       for (const name in model.sources)
         resolveDefinitionName( model.sources[name].namespace );
@@ -287,7 +294,7 @@ function resolve( model ) {
     }
     // Second argument controls whether `key` is only propagated along simple
     // view, i.e. ref or subquery in FROM, not UNION or JOIN.
-    traverseQueryPost( view.query, !options.v7KeyPropagation, ( query ) => {
+    traverseQueryPost( view.query, !!options.v6KeyPropagation, ( query ) => {
       if (!withExplicitKeys( query ) && inheritKeyProp( query ) &&
           withKeyPropagation( query )) // now the part with messages
         inheritKeyProp( query, true );
@@ -357,10 +364,10 @@ function resolve( model ) {
               one: 'Key $(NAMES) has not been projected - key properties are not propagated',
             } );
     }
-    if (options.v7KeyPropagation)
+    if (!options.v6KeyPropagation)
       return propagateKeys;
 
-    // Check that there is no to-many assoc in the FROM reference or in the select
+    // v6: check that there is no to-many assoc in the FROM reference or in the select
     // item reference (references in expressions are not checked,
     // withAssociation() will see no _artifact links anyway)
     const toMany = withAssociation( from, targetMaxNotOne, true );
@@ -548,6 +555,7 @@ function resolve( model ) {
       }
     }
     if (obj.target) {
+      // TODO: introduce some resolveAssociation()
       if (!obj.target.$inferred || obj.target.$inferred === 'aspect-composition')
         resolveTarget( art, obj );
       else
@@ -1079,6 +1087,9 @@ function resolve( model ) {
     }
   }
 
+  /**
+   * Resolve user-provided target.
+   */
   function resolveTarget( art, obj ) {
     if (art !== obj && obj.on) {
       // Unmanaged assoc inside items.  Unmanaged assoc in param handled in resolveRefs()
@@ -1110,8 +1121,8 @@ function resolve( model ) {
         // TODO: also warning if inside structure
       }
       else {                    // if (obj.target._artifact)
-        // TODO: extra with $inferred (to avoid messages)?
         resolveExpr( obj.on, art.kind === 'mixin' ? 'mixin-on' : 'on', art );
+        checkBacklinkPartner( obj );
       }
     }
     else if (art.kind === 'mixin') {
@@ -1138,6 +1149,187 @@ function resolve( model ) {
     }
   }
 
+  function checkBareDollarSelf( assoc ) {
+    traverseDollarSelfPairs( assoc.on, assoc, ( item, right, itemIsPath ) => {
+      registerBacklink( item, right, itemIsPath );
+      checkAssocOnSelf( item );
+      checkAssocOnSelf( right );
+    } );
+    return;
+
+    function registerBacklink( item, right, itemIsPath ) {
+      const backlinkPath = itemIsPath ? item : right;
+      const last = backlinkPath.path[backlinkPath.path.length - 1];
+      if (assoc.$backlink) {
+        const location = combinedLocation( item.path[0], right.path[right.path.length - 1] );
+        message( 'ref-duplicate-self-comparison', [ location, assoc ], { id: '$self' },
+                 'Duplicate comparison with a bare $(ID) reference in an ON-condition' );
+        return;
+      }
+      const backlinkRef = last?._artifact;
+      if (backlinkRef?.target) {
+        const backlink = { location: last.location, target: {} };
+        setLink( backlink, '_origin', backlinkRef );
+        setLink( backlink, '_outer', assoc );
+        assoc.$backlink = backlink;
+      }
+    }
+
+    function checkAssocOnSelf( ref ) {
+      // TODO: fully specify what `‹current_assoc›.‹backlink› = $self` means if the
+      // target of ‹backlink› is not the current entity.
+      // - what does it mean in an aspect
+      // - how about auto-redirections/rewrite
+      // TODO: also disallow if not in entity (
+      const { path } = ref;
+      if (path.length === 1 && path[0]._navigation?.kind === '$self') {
+        if (assoc.on.$inferred)
+          return;
+        const query = userQuery( assoc );
+        const main = query?._main;
+        if (query && query !== main._leadingQuery) {
+          const { txt, op } = getQueryOperatorName( query );
+          const { location, id } = path[0];
+          error( 'ref-unexpected-self', [ location, assoc ], { '#': txt, id, op } );
+        }
+        return;
+      }
+      const index = userTargetElementPathIndex( assoc, path );
+      const target = index > 0 && index < path.length && ref._artifact?.target;
+      if (!target && ref._artifact) {
+        const last = path[path.length - 1];
+        error( 'ref-expecting-target-assoc', [ last.location, assoc ], { id: '$self' },
+               'Only an association of the target side can be compared to $(ID)' );
+        // TODO: ref-expecting-backlink 'Only a backlink association can ...'
+      }
+    }
+  }
+
+  /**
+   * Check that the target T of the backlink association is related to the entity
+   * (or other structure) E where `assoc` is embedded in: E is a valid redirection
+   * target (without E having to be an entity) for T (or the "simple projection
+   * ancestor" of T if `assoc` is managed, see below).
+   *
+   * Note: we do not forbid backlink comparisons in non-entities, because:
+   *
+   * - they might appear during recompilation case when including an entity,
+   * - they are ok in an aspect used as target of a composition.
+   *
+   * Aspects can have _one_ "open backlink target", i.e. a target T which does not
+   * fulfil the above condition. The check is then performed for all definitions
+   * which include the aspect, see function checkOpenBacklinkTargets().
+   *
+   * A "simple projection ancestor" is the (recursive) query source of a simple
+   * projection (one source, no assoc navigation, no query in FROM).
+   *
+   * If the condition is fulfilled, we can properly expand a backlink comparison,
+   * taking potential renamings of source elements into account.
+   */
+  function checkBacklinkPartner( assoc ) {
+    checkBareDollarSelf( assoc );
+    // console.log('CBP:',assoc.kind,assoc._main?.name?.id,assoc.name.id,!!assoc.$backlink)
+    const target = assoc.$backlink?._origin?.target?._artifact;
+    if (!target)
+      return;
+    const main = assoc._main;
+    const chain = main.name && redirectionChain( null, main, target, true );
+    // Remark: an anonymous target in `targetAspect` does not have a name
+    setLink( assoc.$backlink, '_redirected', chain );
+    if (chain)                  // standard correct case
+      return;
+
+    if (target._ancestors) { // && assocHasForeignKeys( assoc.$backlink?._origin )) {
+      // with non-cyclic projection ancestors, not only for managed assoc, but also
+      // unmanaged, see test3/Associations/Backlinks/CrossEyedBacklink.sql-err.cds
+      // Current entity is no valid redirection target for the backlink association
+      // → try whether it would be if its target is replaced with its “simple ancestor”
+      // (simple projection, only managed assoc - TODO for tweak-assoc.js).
+      // TODO: include this "go to ancestor" logic into redirectionChain()?
+      // ...probably just if implicit key calculation is part of populate.js
+      let ancestor = target;
+      // TODO: warning!!!
+      while (ancestor?.query?.from?._artifact?.kind === 'entity')
+        ancestor = ancestor.query.from._artifact;
+      // TODO: we should do the "simple projection ancestor" probably only if no
+      // include is involved in the redirection chain
+      if (redirectionChain( null, main, ancestor, true )) {
+        warning( 'ref-dubious-backlink', [ assoc.$backlink.location, assoc ],
+                 { target },
+                 // eslint-disable-next-line @stylistic/max-len
+                 'The target $(TARGET) of the backlink association has just a distant relationship to the current entity' );
+        return;
+      }
+    }
+    if (main.kind !== 'aspect') {
+      message( 'ref-invalid-backlink', [ assoc.$backlink.location, assoc ], { target } );
+      return;
+    }
+    if (!main.$backlink) {
+      main.$backlink = { target: {} };
+      setLink( main.$backlink.target, '_artifact', target );
+      setLink( main.$backlink, '_associations', [] );
+    }
+    else if (target !== main.$backlink.target?._artifact) {
+      message( 'ref-invalid-backlink', [ assoc.$backlink.location, assoc ],
+               { '#': 'aspect', target } );
+      if (main.$backlink.target) { // had been ok so far → complain about all
+        for (const a of main.$backlink._associations) {
+          message( 'ref-invalid-backlink', [ a.$backlink.location, a ],
+                   { '#': 'aspect', target: a.$backlink._origin.target._artifact } );
+        }
+        main.$backlink.target = undefined;
+      }
+    }
+    main.$backlink._associations.push( assoc );
+  }
+
+  /**
+   * Check potential "open backlink target" of an aspect which is included into
+   * `art`, see function checkBacklinkPartner().  Entities generated for managed
+   * composition of anonymous aspects also check open backlink targets.
+   */
+  function checkOpenBacklinkTargets( art ) {
+    const includes = art.includes ||
+      art.$inferred === 'composition-entity' && [ anonymousAspectAsInclude( art._origin ) ];
+    // Remark: how to detect wrong open backlink target inside an anonymous target aspect:
+    // - direct: the pseudo include of the anonymous aspect is checked via this function
+    // - recompilation: is not checked directly, but condition is copied to generated entity
+    if (!includes)
+      return;
+    for (const incl of includes) {
+      const backlink = incl._artifact?.$backlink;
+      if (backlink?.target && !redirectionChain( null, art, backlink.target._artifact, true )) {
+        message( 'ref-invalid-backlink', [ incl.location, art ],
+                 { '#': 'include', target: backlink.target } );
+      }
+    }
+  }
+
+  function anonymousAspectAsInclude( aspect ) {
+    return { _artifact: aspect, location: aspect.location };
+  }
+
+  // /**
+  //  * Return true if the association `assoc` is managed.  Note: the foreign keys
+  //  * have not been calculated and propagated/rewritten yet.
+  //  */
+  // function assocHasForeignKeys( assoc ) {
+  //   if (!assoc._effectiveType)
+  //     return null;
+  //   do {
+  //     if (assoc.foreignKeys)
+  //       return true;
+  //     if (assoc.on)
+  //       return false;
+  //     const max = assoc.cardinality?.targetMax;
+  //     if (max && (typeof max.val !== 'number' || max.val > 1))
+  //       return false;
+  //     // TODO: check newAssoc = managed[filter]
+  //     assoc = getOrigin( assoc );
+  //   } while (assoc);
+  //   return true;
+  // }
 
   function checkRedirectedUserTarget( art ) {
     const issue = { target: art.target._artifact };
@@ -1326,6 +1518,11 @@ function resolve( model ) {
     }
   }
 
+  /**
+   * Check whether it is correct to redirect assoc `elem` to `target` (will always
+   * be the case for auto-redirected assocs).  Finally, set the `elem._redirected`
+   * to the "redirection chain", i.e. an array of all entities involved.
+   */
   // TODO: add this somehow to tweak-assocs.js ?
   function resolveRedirected( elem, target ) {
     setLink( elem, '_redirected', null ); // null = do not touch path steps after assoc
@@ -1508,7 +1705,7 @@ function resolve( model ) {
   }
 
   function resolveAnnoExpr( expr, art, anno = expr, topItem = false ) {
-    if (expr.$tokenTexts) {
+    if (expr.$tokenTexts || expr.sym) {
       if (anno === expr) {
         initAnnotationForExpression( anno, art );
       }
@@ -1526,7 +1723,7 @@ function resolve( model ) {
       const withExpr = anno === expr &&
         // the following is needed for checkAnnotationAcceptsExpressions(),
         // otherwise @cds.persistence.skip: [hdi, hdbcds, sql.postgres] fails
-        expr.val.some( item => item.$tokenTexts || item.literal === 'struct');
+        expr.val.some( item => item.$tokenTexts || item.sym || item.literal === 'struct');
       if (withExpr)
         initAnnotationForExpression( anno, art );
       expr.val.forEach( val => resolveAnnoExpr( val, art, anno, withExpr ) );
@@ -1725,7 +1922,8 @@ function resolve( model ) {
       setLink( sym, '_artifact', symbols[sym.id] );
     }
     else {
-      // inferred enums can't be extended (yet): show underlying enum
+      setLink( sym, '_artifact', null );
+      // inferred enums can't be extended (yet): show underlying enum - TODO: now possible
       while (type.enum[$inferred])
         type = getOrigin( type );
       const err = message( 'ref-undefined-enum', [ sym.location, user ],

package/lib/compiler/shared.js

@@ -48,10 +48,7 @@ function fns( model ) {
       lexical: null,
       dynamic: modelDefinitions,
       notFound: undefinedDefinition,
-      messageMap: {
-        'ref-undefined-art': 'ref-undefined-using',
-        'ref-undefined-def': 'ref-undefined-using',
-      },
+      messageMap: { 'ref-undefined-def': 'ref-undefined-using' },
     },
     // scope:'global': for cds.Association and auto-redirected targets
     $global: {
@@ -73,10 +70,7 @@ function fns( model ) {
       lexical: userBlock,
       dynamic: modelDefinitions,
       notFound: undefinedDefinition,
-      messageMap: {
-        'ref-undefined-art': 'ext-undefined-art-sec',
-        'ref-undefined-def': 'ext-undefined-def-sec',
-      },
+      messageMap: { 'ref-undefined-def': 'ext-undefined-def-sec' },
       accept: extendableArtifact,
     },
     extend: {
@@ -353,6 +347,9 @@ function fns( model ) {
     navigationEnv,
     nestedElements,
     attachAndEmitValidNames,
+    userTargetElementPathIndex,
+    getQueryOperatorName,
+    traverseDollarSelfPairs,
   } );
   traverseExpr.STOP = Symbol( 'STOP' );
   traverseExpr.SKIP = Symbol( 'SKIP' );
@@ -942,7 +939,7 @@ function fns( model ) {
         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
+          // simple '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 },
@@ -1028,7 +1025,8 @@ function fns( model ) {
           for (let env = lexical; env; env = env._block)
             valid.push( removeGapArtifact( env.artifacts || Object.create( null ) ) );
         }
-        valid.push( removeGapArtifact( model.definitions, !definedViaCdl( user ) ) );
+        const dynamicDict = semantics.dynamic( user );
+        valid.push( removeGapArtifact( dynamicDict, !definedViaCdl( user ) ) );
         semantics.notFound?.( user._user || user, head, valid, model.definitions,
                               null, path, semantics );
 
@@ -1373,10 +1371,14 @@ function fns( model ) {
   // Functions called via semantics.notFound: -----------------------------------
 
   function undefinedDefinition( user, item, valid, _dict, prev, _path, semantics ) {
-    // in a CSN source or for `using`, only one env was tested (valid.length 1) :
-    const art = (!prev) ? item.id : searchName( prev, item.id, 'absolute' );
-    signalNotFound( (valid.length > 1 ? 'ref-undefined-art' : 'ref-undefined-def'),
-                    [ item.location, user ], valid, { art }, semantics );
+    // in a CSN source, for `using`, or if not the first path item, only one env
+    // was tested (valid.length 1) → don't mention `using` declaration
+    const name = (prev) ? `${ prev.name.id }.${ item.id }` : item.id;
+    const msg = (valid.length > 1 && proposeUsingDecl( name, valid.at( -2 ) ))
+      ? 'using'
+      : 'std';
+    signalNotFound( 'ref-undefined-def', [ item.location, user ], valid,
+                    { '#': msg, art: name, keyword: 'using' }, semantics );
     // TODO: improve text, use text variant for: "or builtin" or "definitions" or none
   }
 
@@ -1405,21 +1407,17 @@ function fns( model ) {
         name === 'DRAFT' && path?.length === 2 && path[1].id === 'DraftAdministrativeData' ||
         name.startsWith( 'localized.' )) // TODO: only if suffix is defined
       return;
-    signalNotFound( (valid.length > 1 ? 'ext-undefined-art' : 'ext-undefined-def'),
-                    // TODO: ext-undefined-xyz
+    signalNotFound( 'ext-undefined-def', // TODO: ext-undefined-xyz
                     [ item.location, user ], valid, { art: name } );
   }
 
   function undefinedForExtend( user, item, valid, _dict, prev ) {
     // in a CSN source, only one env was tested (valid.length 1):
     const name = (prev) ? `${ prev.name.id }.${ item.id }` : item.id;
-    if (name.startsWith( 'localized.' )) {
-      error( 'ref-undefined-art', [ user.name.location || user.location, user ],
-             { '#': 'localized', keyword: 'annotate' } );
-    }
-    else {
-      undefinedDefinition( user, item, valid, _dict, prev );
-    }
+    // TODO: do not “accept” `localized` as first path item for `extend`
+    const msg = (name.startsWith( 'localized.' )) ? 'localized' : 'std';
+    signalNotFound( 'ref-undefined-def', [ item.location, user ],
+                    valid, { '#': msg, art: name } );
   }
 
   function signalElementHint( user, item, valid, prev, semantics, path ) {
@@ -1879,35 +1877,26 @@ function fns( model ) {
   }
 
   // TODO: Don't allow path args and filter!
-  function checkOnCondition( expr, exprCtx, user ) {
-    if (!expr || expr.$inferred)
-      return;
-    const { op } = expr;
-    let { args } = expr;
-    if (!op || !args) {
-      checkExpr( expr, exprCtx, user );
-      return;
-    }
-    if (op?.val === '=')        // TMP
-      args = [ args[0], { val: '=', literal: 'token' }, args[1] ];
+  function checkOnCondition( expr, exprCtx, user ) { // TODO: move to tweak-assoc.js (or resolve.js)
+    traverseDollarSelfPairs( expr, user, onPair, onLeaf );
 
-    for (let index = 0; index < args.length; ++index) {
-      const item = args[index];
-      const eq = args[index + 1];
-      if (eq?.val === '=' && eq.literal === 'token' && item.path && !item.scope) {
-        const right = args[index + 2];
-        if (right?.path && !right.scope &&
-            (isDollarSelfPair( item, right, user ) || isDollarSelfPair( right, item, user ))) {
-          checkAssocOnSelf( item, exprCtx, user );
-          checkAssocOnSelf( right, exprCtx, user );
-          index += 2;
-          continue;
-        }
-      }
-      checkOnCondition( item, exprCtx, user );
+    function onPair( item, right ) {
+      checkDollarSelfPairNavigation( item, user );
+      checkDollarSelfPairNavigation( right, user );
+    }
+    function onLeaf( leaf ) {
+      checkExpr( leaf, exprCtx, user );
     }
   }
 
+  function checkDollarSelfPairNavigation( ref, user ) {
+    const { path } = ref;
+    if (path.length === 1 && path[0]._navigation?.kind === '$self')
+      return;
+    const index = userTargetElementPathIndex( user, path );
+    checkOnlyForeignKeyNavigation( user, path, index );
+  }
+
   // // standard element reference check;
   // function checkElementStd( art, _user, ref, semantics ) {
   //   // No further checks on navigation: nothing to do
@@ -1982,6 +1971,36 @@ function fns( model ) {
     return userTargetElementPathIndex( user, path ) > 0;
   }
 
+  function traverseDollarSelfPairs( expr, user, onPair, onLeaf ) {
+    const { op } = expr;
+    let { args } = expr;
+    if (!op || !args) {
+      if (onLeaf)
+        onLeaf( expr );
+      return;
+    }
+    if (op.val === '=')         // TMP
+      args = [ args[0], { val: '=', literal: 'token' }, args[1] ];
+
+    for (let index = 0; index < args.length; ++index) {
+      const item = args[index];
+      const eq = args[index + 1];
+      if (eq?.val === '=' && eq.literal === 'token' && item.path && !item.scope) {
+        const right = args[index + 2];
+        if (right?.path && !right.scope) {
+          const itemIsPath = isDollarSelfPair( item, right, user );
+          const rightIsPath = !itemIsPath && isDollarSelfPair( right, item, user );
+          if (itemIsPath || rightIsPath) {
+            onPair( item, right, itemIsPath );
+            index += 2;
+            continue;
+          }
+        }
+      }
+      traverseDollarSelfPairs( item, user, onPair, onLeaf );
+    }
+  }
+
   function checkAssocOn( ref, exprCtx, user ) {
     const { path } = ref;
     if (!path)
@@ -2004,40 +2023,6 @@ function fns( model ) {
     }
   }
 
-  function checkAssocOnSelf( ref, exprCtx, user ) {
-    // TODO: fully specify what `‹current_assoc›.‹backlink› = $self` means if the
-    // target of ‹backlink› is not the current entity.
-    // - what does it mean in an aspect
-    // - how about auto-redirections/rewrite
-    const { path } = ref;
-    if (path.length === 1 && path[0]._navigation?.kind === '$self') {
-      const query = userQuery( user );
-      const main = query?._main;
-      if (query && query !== main._leadingQuery) {
-        const { txt, op } = getQueryOperatorName( query );
-        const { location, id } = path[0];
-        error( 'ref-unexpected-self', [ location, user ], { '#': txt, id, op } );
-      }
-      return;
-    }
-    const index = userTargetElementPathIndex( user, path );
-    checkOnlyForeignKeyNavigation( user, path, index );
-    const target = index > 0 && index < path.length && ref._artifact?.target;
-    if (!target) {
-      const last = path[path.length - 1];
-      error( 'ref-expecting-target-assoc', [ last.location, user ], { id: '$self' },
-             'Only an association of the target side can be compared to $(ID)' );
-    }
-    // in entity: target must match
-    // in aspect: must end with assoc, TODO: target must include aspect (+ add/ check)
-    else if (target._artifact && target._artifact !== user._main && user._main.kind === 'entity') {
-      const last = path[path.length - 1];
-      warning( 'ref-invalid-backlink', [ last.location, user ], { art: target, id: '$self' },
-               // eslint-disable-next-line @stylistic/max-len
-               'The target $(ART) of the association is not the current entity represented by $(ID)' );
-    }
-  }
-
 
   // right of union: parent = main → get correct operator
   // FROM subquery: parent = tab alias of outer query
@@ -2147,6 +2132,15 @@ function fns( model ) {
 
   // Low-level functions --------------------------------------------------------
 
+  function proposeUsingDecl( name, sourceArtifacts ) {
+    const art = model.definitions[name];
+    // TODO: if there are sub artifacts, test whether at least one of them is real
+    return art &&
+      (art.kind !== 'namespace' || art._subArtifacts) &&
+      !sourceArtifacts?.[name];
+    ;
+  }
+
   /**
    * Make a "not found" error and optionally attach valid names.
    *