@sap/cds-compiler 2.12.0 → 2.13.6

package/lib/compiler/shared.js

@@ -5,9 +5,13 @@
 
 const { searchName } = require('../base/messages');
 const { dictAddArray } = require('../base/dictionaries');
-const { setProp } = require('../base/model');
 
-const { setLink, dependsOn, pathName } = require('./utils');
+const {
+  setLink,
+  setArtifactLink,
+  dependsOn,
+  pathName,
+} = require('./utils');
 
 function artifactsEnv( art ) {
   return art._subArtifacts || Object.create(null);
@@ -161,7 +165,7 @@ function fns( model ) {
   return;
 
   function checkConstRef( art ) {
-    return ![ 'builtin', 'param' ].includes( art.kind );
+    return art.kind !== 'builtin' && art.kind !== 'param';
   }
 
   function checkIncludesRef( art ) {
@@ -265,9 +269,9 @@ function fns( model ) {
       return ref._artifact;
     if (!ref.path || ref.path.broken || !ref.path.length) {
       // incomplete type AST or empty env (already reported)
-      return setLink( ref, undefined );
+      return setArtifactLink( ref, undefined );
     }
-    setLink( ref, 0 );   // avoid cycles for  type T: association to T.m;
+    setArtifactLink( ref, 0 );   // avoid cycles for  type T: association to T.m;
 
     let spec = specExpected[expected];
     const { path } = ref;
@@ -280,7 +284,7 @@ function fns( model ) {
       if (!spec.escape) {
         error( 'ref-unexpected-scope', [ ref.location, user ], {},
                'Unexpected parameter reference' );
-        return setLink( ref, null );
+        return setArtifactLink( ref, null );
       }
       spec = specExpected[spec.escape];
       // In queries and query entities, the first lexical search environment
@@ -298,7 +302,7 @@ function fns( model ) {
       const query = (spec.lexical === 'main') ? user._main : userQuery( user );
       // in path filter, just $magic (and $parameters)
       env = (spec.lexical === 'from') ? query._parent : query || user._main || user;
-      // queries: first tabaliases, then $magic - value refs: first $self, then $magic
+      // queries: first table aliases, then $magic - value refs: first $self, then $magic
       if (!extDict && !spec.noExt) {
         // TODO: change to name restriction for $joins, not own environments
         extDict = query && spec.rootEnv !== 'elements' &&
@@ -314,18 +318,34 @@ function fns( model ) {
       ? getPathRoot( path, spec, user, {}, model[spec.global || 'definitions'] )
       : getPathRoot( path, spec, user, env, extDict, msgArt || 0 );
     if (!art) {
-      return setLink( ref, art );
+      return setArtifactLink( ref, art );
     }
     else if (!spec.envFn && user._pathHead) {
       // eslint-disable-next-line no-empty
     }
     else if (art.kind === 'using') {
-      art = model.definitions[art.name.absolute];
-      if (!art)
-        return setLink( ref, art );
-      else if (art.$duplicates)  // redefined art referenced by using proxy
-        return setLink( ref, false );
-      setLink( head, art );     // we do not want to see the using
+      const def = model.definitions[art.name.absolute];
+      if (!def) {
+        // It could be that the artifact was removed and that the using-proxy needs to be reported.
+        // The check for $inferred is required to avoid consequential errors for cases such as:
+        //   using unknown.abc;
+        //   entity P as projection on abc; // <-- no consequential error here
+        if (art.$inferred === 'path-prefix') {
+          // head._artifact referred to the `using`.  Remove the reference,
+          // so that getPathItem() below emits an error.
+          setArtifactLink( head, false );
+          setArtifactLink( ref, false );
+        }
+        else {
+          return setArtifactLink( ref, false );
+        }
+      }
+      else if (def.$duplicates) { // redefined art referenced by using proxy
+        return setArtifactLink( ref, false );
+      }
+      else {
+        setArtifactLink( head, def ); // we do not want to see the using
+      }
     }
     else if (art.kind === 'mixin') {
       if (spec.noAliasOrMixin) {
@@ -333,14 +353,14 @@ function fns( model ) {
         signalNotFound( 'ref-rejected-on', [ head.location, user ], extDict && [ extDict ],
                         { '#': 'mixin', id: head.id } );
         // also set link on head?
-        return setLink( ref, false );
+        return setArtifactLink( ref, false );
       }
       // console.log(message( null, art.location, art, {}, 'Info','MIX').toString())
-      setLink( head, art, '_navigation' );
+      setLink( head, '_navigation', art );
     }
     else if (art.kind === '$navElement') {
-      setLink( head, art, '_navigation' );
-      setLink( head, art._origin );
+      setLink( head, '_navigation', art );
+      setArtifactLink( head, art._origin );
       // TODO: set art?
     }
     else if (art.kind === '$tableAlias' || art.kind === '$self') {
@@ -349,13 +369,17 @@ function fns( model ) {
         signalNotFound( 'ref-rejected-on', [ head.location, user ], extDict && [ extDict ],
                         { '#': 'alias', id: head.id } );
         // also set link on head?
-        return setLink( ref, false );
+        return setArtifactLink( ref, false );
       }
-      setLink( head, art, '_navigation' );
-      setLink( head, art._origin ); // query source or leading query in FROM
+      setLink( head, '_navigation', art );
+      setArtifactLink( head, art._origin ); // query source or leading query in FROM
       // require('../model/revealInternalProperties').log(model, 'foo.bar.S.V1a')
       if (!art._origin)
-        return setLink( ref, art._origin );
+        return setArtifactLink( ref, art._origin );
+      // if just table alias (with expand), mark `user` with `$noOrigin` to indicate
+      // that the corresponding entity should not be put as $origin into the CSN
+      if (path.length === 1 && user && art.kind === '$tableAlias')
+        user.$noOrigin = true;
     }
 
     // how many path items are for artifacts (rest: elements)
@@ -365,20 +389,20 @@ function fns( model ) {
     // console.log(expected, ref.path.map(a=>a.id),artItemsCount)
     art = getPathItem( path, spec, user, artItemsCount, !spec.envFn && user._pathHead && art);
     if (!art)
-      return setLink( ref, art );
+      return setArtifactLink( ref, art );
 
     if (art.$autoElement) {
       const { location } = path[path.length - 1];
       const step = { id: art.$autoElement, $inferred: '$autoElement', location };
       art = art.elements[step.id];
-      setLink( step, art );
+      setArtifactLink( step, art );
       path.push( step );
     }
     if (spec.check) {
       const fail = spec.check( art, path );
       if (fail === true) {
         signalNotFound( spec.expectedMsgId, [ ref.location, user ], null );
-        return setLink( ref, false );
+        return setArtifactLink( ref, false );
       }
       else if (fail) {
         signalNotFound( spec.sloppyMsgId, [ ref.location, user ], null );
@@ -410,7 +434,7 @@ function fns( model ) {
         !(env.$frontend && env.$frontend !== 'cdl'))
       deprecateSmart( ref, art, user );
     // TODO: follow FROM here, see csnRef - fromRef
-    return setLink( ref, art );
+    return setArtifactLink( ref, art );
   }
 
   // Issue errors for "smart" element-in-artifact references
@@ -475,6 +499,8 @@ function fns( model ) {
       // TODO: not necessarily for explicit ON condition in expand
       VolatileFns.environment( user._pathHead ); // make sure _origin is set
       return user._pathHead._origin;
+      // const { _origin } = user._pathHead;
+      // return (_origin && _origin.kind === '$tableAlias') ? _origin._origin : _origin;
     }
     const head = path[0];
     if (!head || !head.id || !env)
@@ -501,7 +527,7 @@ function fns( model ) {
       const r = e[head.id];
       if (r) {
         if (Array.isArray(r)) { // redefinitions
-          setLink( head, r );
+          setArtifactLink( head, r );
           return false;
         }
         // if (head.$delimited && r.kind !== '$tableAlias' && r.kind !== 'mixin')
@@ -512,18 +538,18 @@ function fns( model ) {
                      { code: `$parameters.${ path[1].id }`, newcode: `:${ path[1].id }` },
                      'Obsolete $(CODE) - replace by $(NEWCODE)' );
             // TODO: replace it in to-csn correspondingly
-            return setLink( head, r );
+            return setArtifactLink( head, r );
           }
         }
         else if (r.kind === '$self') {
           // TODO: handle $delimited differently
           // TODO: $projection only if not delimited _and_ length > 1
-          return setLink( head, r );
+          return setArtifactLink( head, r );
         }
         else if (r.kind !== '$tableAlias' || path.length > 1 || user.expand || user.inline) {
           // except "real" table aliases (not $self) with path len 1
           // TODO: $projection only if not delimited _and_ length > 1
-          return setLink( head, r );
+          return setArtifactLink( head, r );
         }
       }
     }
@@ -540,11 +566,11 @@ function fns( model ) {
                    'Ambiguous $(ID), replace by $(NAMES)' );
           }
         }
-        setLink( head, r );
+        setArtifactLink( head, r );
         return false;
       }
       else if (r) {
-        return setLink( head, r );
+        return setArtifactLink( head, r );
       }
     }
     if (spec.noMessage || msgArt === true && extDict === model.definitions)
@@ -598,7 +624,7 @@ function fns( model ) {
       signalNotFound( spec.undefinedArt || 'ref-undefined-art', [ head.location, user ],
                       valid, { name: head.id } );
     }
-    return setLink( head, null );
+    return setArtifactLink( head, null );
   }
 
   // Return artifact or element referred by path (array of ids) `tail`.  The
@@ -606,6 +632,7 @@ function fns( model ) {
   // missing artifacts (as opposed to elements), provide the `head` (first
   // element item in the path)
   function getPathItem( path, spec, user, artItemsCount, headArt ) {
+    // let art = (headArt && headArt.kind === '$tableAlias') ? headArt._origin : headArt;
     let art = headArt;
     let nav = spec.assoc !== '$keys' && null; // false for '$keys'
     const last = path[path.length - 1];
@@ -622,7 +649,7 @@ function fns( model ) {
 
       const fn = (spec.envFn && artItemsCount >= 0) ? spec.envFn : VolatileFns.environment;
       const env = fn( art, item.location, user, spec.assoc );
-      const sub = setLink( item, env && env[item.id] );
+      const sub = setArtifactLink( item, env && env[item.id] );
 
       if (!sub) {
         // element was not found in environment
@@ -684,7 +711,7 @@ function fns( model ) {
         if (node._artifact) {
           // set the original(!) foreign key for the assoc - the "right" ones
           // after rewriteKeys() is the one with the same name.id
-          setLink( item, node._artifact, '_navigation' );
+          setLink( item, '_navigation', node._artifact );
           if (item === last)
             return;
         }
@@ -817,7 +844,7 @@ function fns( model ) {
           if (!(Array.isArray(annos)))
             annos = [ annos ];
           for (const a of annos) {
-            setProp( a, '_block', block );
+            setLink( a, '_block', block );
             a.$priority = priority;
             if (construct !== art)
               addAnnotation( art, annoProp, a );
@@ -867,7 +894,7 @@ function fns( model ) {
           value.name && value.name.location ||
           value.path && value.path.location,
       };
-      setProp( anno, '_block', block );
+      setLink( anno, '_block', block );
       // TODO: _parent, _main is set later (if we have ElementRef), or do we
       // set _artifact?
       anno.$priority = priority;