@sap/cds-compiler 2.12.0 → 2.15.2

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);
@@ -153,15 +157,15 @@ function fns( model ) {
   const VolatileFns = model.$volatileFunctions;
   Object.assign( model.$functions, {
     resolveUncheckedPath,
+    resolveTypeArgumentsUnchecked,
     resolvePath,
-    resolveTypeArguments,
     defineAnnotations,
     attachAndEmitValidNames,
   } );
   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
@@ -435,35 +459,64 @@ function fns( model ) {
     }
   }
 
-  // Resolve the type arguments provided with a type referenced for artifact or
-  // element `artifact`.  This function does nothing if the referred type
-  // `typeArtifact` does not have a `parameters` property (currently, only
-  // builtin-types have it, see ./builtins.js).
-  //
-  // For each property name `<prop>` in `typeArtifact.parameters`, we move a number
-  // in art.$typeArgs (a vector of numbers with locations) to `artifact.<prop>`.
-  // TODO: error if no parameters applicable
-  // TODO: also check for number
-  function resolveTypeArguments(artifact, typeArtifact, user) {
-    const args = artifact.$typeArgs || [];
+  /**
+   * Resolve the type arguments of `artifact` according to the type `typeArtifact`.
+   * User is used for semantic message location.
+   *
+   * For builtins, for each property name `<prop>` in `typeArtifact.parameters`, we move a value
+   * in art.$typeArgs (a vector of numbers with locations) to `artifact.<prop>`.
+   *
+   * For non-builtins, we take either one or two arguments and interpret them
+   * as `length` or `precision`/`scale`.
+   *
+   * Left-over arguments are errors for non-builtins and warnings for builtins.
+   *
+   * @param {object}  artifact
+   * @param {object} typeArtifact
+   * @param {CSN.Artifact} user
+   */
+  function resolveTypeArgumentsUnchecked(artifact, typeArtifact, user) {
+    let args = artifact.$typeArgs || [];
     const parameters = typeArtifact.parameters || [];
-    const parLength = parameters.length;
 
-    for (let i = 0; i < parLength; ++i) {
-      let par = parameters[i];
-      if (!(par instanceof Object))
-        par = { name: par };
-      if (!artifact[par.name] && i < args.length)
-        artifact[par.name] = args[i];
-    }
-    if (args.length > parLength) {
-      artifact.$typeArgs = artifact.$typeArgs.slice(parLength);
-      warning( 'unexpected-type-arg', [ artifact.$typeArgs[0].location, user ],
-               { art: typeArtifact }, 'Too many arguments for type $(ART)' );
+    if (parameters.length > 0) {
+      // For Builtins
+      for (let i = 0; i < parameters.length; ++i) {
+        let par = parameters[i];
+        if (!(par instanceof Object))
+          par = { name: par };
+        if (!artifact[par.name] && i < args.length)
+          artifact[par.name] = args[i];
+      }
+      args = args.slice(parameters.length);
+    }
+    else if (args.length > 0 && !typeArtifact.builtin) {
+      // One or two arguments are interpreted as either length or precision/scale.
+      // For builtins, we know what arguments are expected, and we do not need this mapping.
+      // Also, we expect non-structured types.
+      if (args.length === 1) {
+        artifact.length = args[0];
+        args = args.slice(1);
+      }
+      else if (args.length === 2) {
+        artifact.precision = args[0];
+        artifact.scale = args[1];
+        args = args.slice(2);
+      }
     }
-    else if (artifact.$typeArgs) {
-      delete artifact.$typeArgs;
+
+    if (!artifact.$typeArgs)
+      return;
+
+    // Warn about left-over arguments.
+    if (args.length > 0) {
+      const loc = [ args[args.length - 1].location, user ];
+      if (typeArtifact.builtin)
+        warning( 'type-ignoring-argument', loc, { art: typeArtifact } );
+      else
+        error( 'type-unexpected-argument', loc, { '#': 'std', art: typeArtifact });
     }
+    artifact.$typeArgs = undefined;
   }
 
   // Return artifact or element referred by name `head`.  The first environment
@@ -475,6 +528,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 +556,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 +567,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 +595,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 +653,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 +661,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 +678,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 +740,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;
         }
@@ -705,7 +761,7 @@ function fns( model ) {
         signalNotFound( spec.undefinedDef || 'ref-undefined-def', [ item.location, user ],
                         [ env ], { art: a } );
       }
-      else if (art.name.select && art.name.select > 1) {
+      else if (art.name && art.name.select && art.name.select > 1) {
         // TODO: 'The current query has no element $(MEMBER)' with $self.MEMBER
         // and 'The sub query for alias $(ALIAS) has no element $(MEMBER)'
         // TODO: probably not extra messageId, but text variant
@@ -721,8 +777,13 @@ function fns( model ) {
                         { param: 'Entity $(ART) has no parameter $(MEMBER)' } );
       }
       else {
+        const variant = art.kind === 'aspect' && !art.name && 'aspect';
         signalNotFound( spec.undefinedDef || 'ref-undefined-element', [ item.location, user ],
-                        [ env ], { art: searchName( art, item.id, 'element' ) } );
+                        [ env ], {
+                          '#': variant,
+                          art: (variant ? '' : searchName( art, item.id, 'element' )),
+                          id: item.id,
+                        } );
       }
       return null;
     }
@@ -817,7 +878,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 +928,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;