@sap/cds-compiler 3.6.2 → 3.8.0

package/lib/compiler/shared.js

@@ -4,7 +4,6 @@
 'use strict';
 
 const { searchName } = require('../base/messages');
-const { dictAddArray } = require('../base/dictionaries');
 const { isDeprecatedEnabled } = require('../base/model');
 
 const {
@@ -183,8 +182,6 @@ function fns( model ) {
     resolveUncheckedPath,
     resolveTypeArgumentsUnchecked,
     resolvePath,
-    checkAnnotate,
-    copyAnnotationsForExtensions,
     attachAndEmitValidNames,
   } );
   return;
@@ -253,16 +250,12 @@ function fns( model ) {
   }
 
   function checkSourceRef( art, path ) { // for FROM
-    if (art.kind === 'entity' )
-      return false;
-    if (art.kind !== 'element')
-      return true;
+    if (!art._main)
+      return (art.kind !== 'entity');
     const elem = path.find( item => item._artifact._main )._artifact;
-    // TODO: better error location if error for main
-    if (elem._main.kind !== 'entity' )
-      return true;              // elem not starting at entity
-    VolatileFns.environment( art );         // sets _effectiveType on art
-    return !(art._effectiveType || art).target;
+    // at least the last main definition should be an entity
+    // an additional check for target would need effectiveType()
+    return (elem && elem._main.kind !== 'entity');
   }
 
   // Return absolute name for unchecked path `ref`.  We first try searching for
@@ -307,13 +300,12 @@ function fns( model ) {
   function resolvePath( ref, expected, user, extDict, msgArt ) {
     if (ref == null)       // no references -> nothing to do
       return undefined;
-    if ('_artifact' in ref)     // also true for _artifact: undefined
+    if (ref._artifact !== undefined)
       return ref._artifact;
     if (!ref.path || ref.path.broken || !ref.path.length) {
       // incomplete type AST or empty env (already reported)
       return setArtifactLink( ref, undefined );
     }
-    setArtifactLink( ref, 0 );   // avoid cycles for  type T: association to T.m;
 
     let spec = specExpected[expected];
     const { path } = ref;
@@ -324,10 +316,12 @@ function fns( model ) {
 
     if (ref.scope === 'param') {
       if (!spec.escape) {
-        error( 'ref-unexpected-scope', [ ref.location, user ], {},
-               'Unexpected parameter reference' );
+        error( 'ref-unexpected-scope', [ ref.location, user ], { '#': 'std' } );
         return setArtifactLink( ref, null );
       }
+      if (user.$syntax === 'calc')
+        error('ref-unexpected-scope', [ ref.location, user ], { '#': 'calc' } );
+
       spec = specExpected[spec.escape];
       // In queries and query entities, the first lexical search environment
       // are the parameters, otherwise the block.  It is currently ensured that
@@ -363,8 +357,12 @@ function fns( model ) {
       return setArtifactLink( ref, art );
     }
     else if (!spec.envFn && user._pathHead) {
-      if (art.kind === '$self')
-        rejectBareSelf( spec, path, user, extDict );
+      if (art.kind === '$self') {
+        const headEnv = VolatileFns.environment( user._pathHead ) &&
+              user._pathHead._origin &&
+              VolatileFns.environment( user._pathHead._origin );
+        rejectBareSelf( spec, path, user, headEnv );
+      }
     }
     else if (art.kind === 'using') {
       const def = model.definitions[art.name.absolute];
@@ -464,13 +462,13 @@ function fns( model ) {
                  spec.noDep === 'only-entity' && art.kind !== 'entity')) {
       const { location } = ref; // || combinedLocation( head, path[tail.length] );
       // TODO: location of last path item if not main artifact
-      if (!art._main || spec.assoc !== 'from') {
-        dependsOn( user, art, location );
-      }
-      else {
+      if (spec.assoc === 'from' && art._main) {
         dependsOn( user, art._main, location );
         VolatileFns.environment( art, location, user );
-      // Without on-demand resolve, we can simply signal 'undefined "x"'
+      }
+      else if (art.kind !== 'select') { // no real dependency to bare $self
+        dependsOn( user, art, location );
+        // Without on-demand resolve, we can simply signal 'undefined "x"'
       // instead of 'illegal cycle' in the following case:
       //    element elem: type of elem.x;
       }
@@ -599,7 +597,7 @@ function fns( model ) {
     // if (head.id === 'k') {console.log(Object.keys(user));
     // throw new CompilerAssertion(JSON.stringify(user.name))}
     // if head._artifact is set or is null then it was already computed once
-    if ('_artifact' in head)
+    if (head._artifact !== undefined)
       return Array.isArray(head._artifact) ? false : head._artifact;
     // console.log(pathName(path), !spec.next && !extDict &&
     //   (spec.useDefinitions || env.$frontend === 'json' || env))
@@ -617,7 +615,7 @@ function fns( model ) {
         break;                    // TODO: probably remove _$next link
       const e = art.artifacts || art.$tableAliases || Object.create(null);
       const r = e[head.id];
-      if (r) {
+      if (r && r.$inferred !== '$internal') {
         if (Array.isArray(r)) { // redefinitions
           setArtifactLink( head, r );
           return false;
@@ -651,11 +649,14 @@ function fns( model ) {
         if (r[0].kind === '$navElement' && r.every( e => !e._parent.$duplicates )) {
           // only complain about ambiguous source elements if we do not have
           // duplicate table aliases, only mention non-ambiguous source elems
-          const names = r.filter( e => !e.$duplicates )
-            .map( e => `${ e.name.alias }.${ e.name.element }` );
-          if (names.length) {
-            error( 'ref-ambiguous', [ head.location, user ], { id: head.id, names },
-                   'Ambiguous $(ID), replace by $(NAMES)' );
+          const uniqueNames = r.filter( e => !e.$duplicates);
+          if (uniqueNames.length) {
+            const names = uniqueNames.filter( e => e._parent.$inferred !== '$internal' )
+              .map( e => `${ e.name.alias }.${ e.name.element }` );
+            let variant = names.length === uniqueNames.length ? 'std' : 'few';
+            if (names.length === 0)
+              variant = 'none';
+            error( 'ref-ambiguous', [ head.location, user ], { '#': variant, id: head.id, names });
           }
         }
         setArtifactLink( head, r );
@@ -772,12 +773,13 @@ function fns( model ) {
 
       const fn = (spec.envFn && artItemsCount >= 0) ? spec.envFn : VolatileFns.environment;
       const env = fn( art, item.location, user, spec.assoc );
-      const sub = setArtifactLink( item, env && env[item.id] );
+      const sub = setArtifactLink( item, env?.[item.id] );
 
       if (!sub) {
         // element was not found in environment
-        if (sub === 0)
-          return 0;
+
+        // TODO (done?): if `env` was 0, we might set a dependency to induce an
+        // illegal-cycle error instead of reporting via `errorNotFound`.
         if (art.$uncheckedElements) { // magic variable / replacement variable
           signalNotFound( 'ref-unknown-var', [ item.location, user ], [ env ],
                           { id: pathName( path ) } );
@@ -935,7 +937,7 @@ function fns( model ) {
     msg.validNames = Object.create( null );
     for (const name of Object.keys( valid )) {
       // ignore internal types such as cds.Association
-      if (valid[name].internal || valid[name].deprecated)
+      if (valid[name].internal || valid[name].deprecated || valid[name].$inferred === '$internal')
         continue;
       msg.validNames[name] = valid[name];
     }
@@ -949,51 +951,6 @@ function fns( model ) {
             { std: `Valid: ${ names.sort().join(', ') }`, zero: 'No valid names' });
     }
   }
-
-  // Issue messages for annotations on namespaces and builtins
-  // (TODO: really here?, probably split main artifacts vs returns)
-  // see also lateExtensions() where similar messages are reported
-  function checkAnnotate( construct, art ) {
-    // TODO: Handle extend statements properly: Different message for empty extend?
-
-    // Namespaces cannot be annotated in CSN but because they exist as XSN artifacts
-    // they can still be applied. Namespace annotations are extracted in to-csn.js
-    // In parseCdl mode USINGs and other unknown references are generated as
-    // namespaces which would lead to false positives.
-    // TODO: should this really be different to annotate-unknown?
-    if (art.kind === 'namespace') {
-      info( 'anno-namespace', [ construct.name.location, construct ], {},
-            'Namespaces can\'t be annotated' );
-    }
-    // Builtin annotations would also get lost. Same as for namespaces:
-    // extracted in to-csn.js
-    else if (art.builtin === true) {
-      info( 'anno-builtin', [ construct.name.location, construct ], {},
-            'Builtin types should not be annotated. Use custom type instead' );
-    }
-    else if (construct.$syntax === 'returns' && art._block && art.kind !== 'action' &&
-             art.kind !== 'function' ) {
-      // `annotate ABC with returns {}` is handled just like `elements`. Warn if it is used
-      // for non-actions.  We can't only check for !art.returns, because `action A();` is valid.
-      // `art._block` ensures that `art` is a defined def.
-      warning('anno-unexpected-returns', [ construct.name.location, construct ],
-              { keyword: 'returns', meta: art.kind }, 'Unexpected $(KEYWORD) for $(META)');
-    }
-  }
-
-  // Copy annotations from `ext` to `art`, overwriting inferred ones.
-  // TODO: move to extend.js if not used anymore in define.js
-  function copyAnnotationsForExtensions( ext, art ) {
-    for (const annoProp in ext) {
-      if (annoProp.charAt(0) === '@' || annoProp === 'doc') {
-        const extAnno = ext[annoProp];
-        if (art[annoProp]?.$inferred)
-          art[annoProp] = extAnno; // overwrite $inferred annos
-        else
-          dictAddArray( art, annoProp, extAnno );
-      }
-    }
-  }
 }
 
 module.exports = {

package/lib/compiler/tweak-assocs.js

@@ -3,7 +3,6 @@
 'use strict';
 
 const {
-  forEachDefinition,
   forEachGeneric,
   forEachInOrder,
 } = require('../base/model');
@@ -31,19 +30,13 @@ function tweakAssocs( model ) {
   } = model.$messageFunctions;
   const {
     effectiveType,
-    directType,
+    getOrigin,
     resolveExpr,
   } = model.$functions;
   const { environment } = model.$volatileFunctions;
 
   // Phase 5: rewrite associations
-  forEachDefinition( model, rewriteSimple );
-  // TODO: sequence not good enough with derived type of structure with
-  // includes: first "direct" structures, then _entities, then the rest.
-  // v2: We might run a silent cycle detection earlier, then we could use the
-  // SCC number (_scc.lowlink) to sort.
-  model._entities.forEach( rewriteView );
-  model._entities.forEach( rewriteViewCheck );
+  model._entities.forEach( rewriteArtifact );
   // Think hard whether an on condition rewrite can lead to a new cylcic
   // dependency.  If so, we need other messages anyway.  TODO: probably do
   // another cyclic check with testMode.js
@@ -55,33 +48,41 @@ function tweakAssocs( model ) {
   //--------------------------------------------------------------------------
   // Only top-level queries and sub queries in FROM
 
-  function rewriteSimple( art ) {
+  function rewriteArtifact( art ) {
     // return;
-    if (!art.includes && !art.query) {
+    if (!art.query) {
       // console.log(message( null, art.location, art, {target:art._target},
       //   'Info','RAS').toString())
       rewriteAssociation( art );
       forEachGeneric( art, 'elements', rewriteAssociation );
     }
+    else {
+      traverseQueryExtra( art, ( query ) => {
+        forEachGeneric( query, 'elements', rewriteAssociation );
+      } );
+    }
     if (art._service)
       forEachGeneric( art, 'elements', excludeAssociation );
-  }
 
-  function rewriteView( view ) {
-    traverseQueryExtra( view, ( query ) => {
-      forEachGeneric( query, 'elements', rewriteAssociation );
+    traverseQueryPost( art.query, false, ( query ) => {
+      forEachGeneric( query, 'elements', rewriteAssociationCheck );
     } );
-    if (view.includes)          // entities with structure includes:
-      forEachGeneric( view, 'elements', rewriteAssociation );
   }
 
+  // function rewriteView( view ) {
+  //   // TODO: we could sort according to the $effectiveSeqNo instead
+  //   // (and then remove traverseQueryExtra)
+  //   if (view.includes)          // entities with structure includes:
+  //     forEachGeneric( view, 'elements', rewriteAssociation );
+  // }
+
   // Check explicit ON / keys with REDIRECTED TO
   // TODO: run on all queries, but this is potentially incompatible
-  function rewriteViewCheck( view ) {
-    traverseQueryPost( view.query, false, ( query ) => {
-      forEachGeneric( query, 'elements', rewriteAssociationCheck );
-    } );
-  }
+  // function rewriteViewCheck( view ) {
+  //   traverseQueryPost( view.query, false, ( query ) => {
+  //     forEachGeneric( query, 'elements', rewriteAssociationCheck );
+  //   } );
+  // }
 
   function excludeAssociation( elem ) {
     const target = elem.target && elem.target._artifact;
@@ -112,7 +113,7 @@ function tweakAssocs( model ) {
     if (!elem.target)
       return;
     if (elem.on && !elem.on.$inferred) {
-      const assoc = directType( elem );
+      const assoc = getOrigin( elem );
       if (assoc && assoc.foreignKeys) {
         error( 'rewrite-key-for-unmanaged', [ elem.on.location, elem ],
                { keyword: 'on', art: assocWithExplicitSpec( assoc ) },
@@ -121,7 +122,7 @@ function tweakAssocs( model ) {
       }
     }
     else if (elem.foreignKeys && !inferredForeignKeys( elem.foreignKeys )) {
-      const assoc = directType( elem );
+      const assoc = getOrigin( elem );
       if (assoc && assoc.on) {
         error( 'rewrite-on-for-managed',
                [ elem.foreignKeys[$location] || dictLocation( elem.foreignKeys ), elem ],
@@ -195,7 +196,7 @@ function tweakAssocs( model ) {
   function assocWithExplicitSpec( assoc ) {
     while (assoc.foreignKeys && inferredForeignKeys( assoc.foreignKeys, 'keys') ||
            assoc.on && assoc.on.$inferred)
-      assoc = directType( assoc );
+      assoc = getOrigin( assoc );
     return assoc;
   }
 
@@ -211,6 +212,7 @@ function tweakAssocs( model ) {
     // With cyclic dependencies on select items, testing for the _effectiveType to
     // be 0 (test above) is not enough if we we have an explicit redirection
     // target -> avoid infloop ourselves with _status.
+    // TODO: this should be good now
     const chain = [];
     while (!elem.on && !elem.foreignKeys) {
       chain.push( elem );
@@ -220,7 +222,7 @@ function tweakAssocs( model ) {
         return;
       }
       setLink( elem, '_status', 'rewrite' );
-      elem = directType( elem );
+      elem = getOrigin( elem );
       if (!elem || elem.builtin) // safety
         return;
     }
@@ -236,7 +238,7 @@ function tweakAssocs( model ) {
   }
 
   function originTarget( elem ) {
-    const assoc = !elem.expand && directType( elem );
+    const assoc = !elem.expand && getOrigin( elem );
     const ftype = assoc && effectiveType( assoc );
     return ftype && ftype.target && ftype.target._artifact;
   }
@@ -254,7 +256,7 @@ function tweakAssocs( model ) {
       const fk = linkToOrigin( orig, name, elem, 'foreignKeys', elem.location );
       fk.$inferred = 'rewrite'; // Override existing value; TODO: other $inferred value?
       // TODO: re-check for case that foreign key is managed association
-      if ('_effectiveType' in orig)
+      if (orig._effectiveType !== undefined)
         setLink( fk, '_effectiveType', orig._effectiveType);
       const te = copyExpr( orig.targetElement, elem.location );
       if (elem._redirected) {

package/lib/compiler/utils.js

@@ -10,7 +10,7 @@
 
 'use strict';
 
-const { dictAdd, pushToDict } = require('../base/dictionaries');
+const { dictAdd, pushToDict, dictFirst } = require('../base/dictionaries');
 const { kindProperties } = require('./base');
 
 // for links, i.e., properties starting with an underscore '_':
@@ -55,7 +55,7 @@ function annotationLocation( anno ) {
  * @param {*} [val]
  * @param {string} [literal]
  */
-function annotateWith( art, anno, location = art.location, val = true, literal = 'boolean' ) {
+function setAnnotation( art, anno, location = art.location, val = true, literal = 'boolean' ) {
   if (art[anno])  // do not overwrite user-defined including null
     return;
   art[anno] = {
@@ -71,10 +71,11 @@ function annotateWith( art, anno, location = art.location, val = true, literal =
 
 // The link (_artifact,_effectiveType,...) usually has the artifact as value.
 // Falsy values are:
-// - undefined: not computed yet, parse error, no ref
-// - null: no valid reference, param:true if that is not allowed
+// - undefined: not computed yet, parse error (TODO: null), no ref
+// - null: ref to unknown, param:true if that is not allowed (TODO: false)
 // - false (only complete ref): multiple definitions, rejected
 // - 0 (for _effectiveType only): circular reference
+// - '' (for _origin only): no origin provided
 function setLink( obj, prop, value ) {
   Object.defineProperty( obj, prop, { value, configurable: true, writable: true } );
   return value;
@@ -105,6 +106,20 @@ function linkToOrigin( origin, name, parent, prop, location, silentDep ) {
   return elem;
 }
 
+function proxyCopyMembers( art, dictProp, originDict, location, kind ) {
+  art[dictProp] = Object.create( null );
+  for (const name in originDict) {
+    const origin = originDict[name];
+    const member = linkToOrigin( origin, name, art, dictProp,
+                                 location || origin.location, true );
+    member.$inferred = 'expanded';
+    if (kind)
+      member.kind = kind;
+    if (kind && origin.masked)  // TODO: remove!
+      member.masked = Object.assign( { $inferred: 'nav' }, origin.masked );
+  }
+}
+
 /**
  * Set the member `elem` to have a _parent link to `parent` and a corresponding
  * _main link.  Also set the member's name accordingly, where argument `name`
@@ -370,6 +385,15 @@ function traverseQueryExtra( main, callback ) {
   }
 }
 
+// Returns what was available at view._from[0] before:
+// (think first whether to really use this function)
+function viewFromPrimary( view ) {
+  let query = view.$queries?.[0];
+  while (query?._origin?.kind === 'select') // sub query in from
+    query = query._origin;
+  return dictFirst( query?.$tableAliases );
+}
+
 // About Helper property $expand for faster the XSN-to-CSN transformation
 // - null/undefined: artifact, member, items does not contain expanded members
 // - 'origin': all expanded (sub) elements have no new target/on and no new annotations
@@ -424,10 +448,11 @@ module.exports = {
   annotationIsFalse,
   annotationHasEllipsis,
   annotationLocation,
-  annotateWith,
+  setAnnotation,
   setLink,
   setArtifactLink,
   linkToOrigin,
+  proxyCopyMembers,
   dependsOn,
   dependsOnSilent,
   setMemberParent,
@@ -441,6 +466,7 @@ module.exports = {
   targetMaxNotOne,
   traverseQueryPost,
   traverseQueryExtra,
+  viewFromPrimary,
   setExpandStatus,
   setExpandStatusAnnotate,
   isDirectComposition,