@sap/cds-compiler 2.11.2 → 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 } = require('./utils');
+const {
+  setLink,
+  setArtifactLink,
+  dependsOn,
+  pathName,
+} = require('./utils');
 
 function artifactsEnv( art ) {
   return art._subArtifacts || Object.create(null);
@@ -26,7 +30,6 @@ function artifactsEnv( art ) {
  */
 // TODO: yes, this function will be renamed
 function fns( model ) {
-  /** @type {CSN.Options} */
   const { options } = model;
   const {
     info, warning, error, message,
@@ -162,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 ) {
@@ -173,16 +176,25 @@ function fns( model ) {
     return !(art.elements && !art.query && !art.type && !art.params);
   }
 
+  /**
+   * @returns {boolean|string}
+   */
   function checkTypeRef( art ) {
     if (art.kind === 'type' || art.kind === 'element')
       return false;
     return ![ 'entity', 'aspect', 'event' ].includes( art.kind ) || 'sloppy';
   }
 
+  /**
+   * @returns {boolean|string}
+   */
   function checkActionParamTypeRef( art ) {
     return !(art.kind === 'entity' && art._service) && checkTypeRef( art );
   }
 
+  /**
+   * @returns {boolean|string}
+   */
   function checkEventTypeRef( art ) {
     return art.kind !== 'event' && checkActionParamTypeRef( art );
   }
@@ -191,6 +203,9 @@ function fns( model ) {
     return art.kind !== 'entity';
   }
 
+  /**
+   * @returns {boolean|string}
+   */
   function checkTargetRef( art ) {
     if (art.kind === 'entity' || art.kind === 'aspect')
       return false;
@@ -254,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;
@@ -269,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
@@ -287,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' &&
@@ -303,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) {
@@ -322,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') {
@@ -338,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)
@@ -354,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 );
@@ -399,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
@@ -464,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)
@@ -490,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')
@@ -501,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 );
         }
       }
     }
@@ -529,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)
@@ -587,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
@@ -595,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];
@@ -611,29 +649,24 @@ function fns( model ) {
 
       const fn = (spec.envFn && artItemsCount >= 0) ? spec.envFn : VolatileFns.environment;
       const env = fn( art, item.location, user, spec.assoc );
-
-      // do not check any elements of the path, e.g. $session - but still don't return path-head
-      if (art && art.$uncheckedElements) {
-        if (env && env[item.id]) // something like $user.id/$user.locale
-          return env[item.id];
-
-        // $user.foo - build our own valid path step obj
-        // Important: Don't directly modify item!
-        const obj = {
-          location: item.location,
-          kind: 'builtin',
-          name: { id: item.id, element: path.map(p => p.id).join('.') },
-        };
-        setLink(obj, art, '_parent');
-        return obj;
+      const sub = setArtifactLink( item, env && env[item.id] );
+
+      if (!sub) {
+        // element was not found in environment
+        if (sub === 0)
+          return 0;
+        if (art.$uncheckedElements) { // magic variable / replacement variable
+          signalNotFound( 'ref-unknown-var', [ item.location, user ], [ env ],
+                          { id: path.map(n => n.id).join('.') } );
+        }
+        else {
+          errorNotFound( item, env );
+        }
+        return null;
       }
-
-      const sub = setLink( item, env && env[item.id] );
-
-      if (!sub)
-        return (sub === 0) ? 0 : errorNotFound( item, env );
-      else if (Array.isArray(sub)) // redefinitions
+      else if (Array.isArray(sub)) { // redefinitions
         return false;
+      }
 
       if (nav) {              // we have already "pseudo-followed" a managed association
         // We currently rely on the check that targetElement references do
@@ -678,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;
         }
@@ -715,7 +748,7 @@ function fns( model ) {
                         { param: 'Entity $(ART) has no parameter $(MEMBER)' } );
       }
       else {
-        signalNotFound( 'ref-undefined-element', [ item.location, user ],
+        signalNotFound( spec.undefinedDef || 'ref-undefined-element', [ item.location, user ],
                         [ env ], { art: searchName( art, item.id, 'element' ) } );
       }
       return null;
@@ -811,10 +844,10 @@ 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)
-              dictAddArray( art, annoProp, a );
+              addAnnotation( art, annoProp, a );
           }
         }
       }
@@ -861,19 +894,21 @@ 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;
-      dictAddArray( art, annoProp, anno );
+      addAnnotation( art, annoProp, anno );
     }
   }
 }
 
-// Return string 'A.B.C' for parsed source `A.B.C` (is vector of ids with
-// locations):
-function pathName(path) {
-  return (path.broken) ? '' : path.map( id => id.id ).join('.');
+// Add annotation to definition - overwriting $inferred annos
+function addAnnotation( art, annoProp, anno ) {
+  const old = art[annoProp];
+  if (old && old.$inferred)
+    delete art[annoProp];
+  dictAddArray( art, annoProp, anno );
 }
 
 module.exports = {