@sap/cds-compiler 2.10.2 → 2.11.4

package/lib/compiler/resolver.js

@@ -47,25 +47,29 @@ const {
 const { dictLocation } = require('../base/location');
 const { searchName, weakLocation } = require('../base/messages');
 const { combinedLocation } = require('../base/location');
-const { pushLink } = require('./utils');
+
+const { kindProperties } = require('./base');
 const {
-  getDefinerFunctions,
+  pushLink,
+  setLink,
+  annotationVal,
   augmentPath,
   splitIntoPath,
-} = require('./definer');
+  linkToOrigin,
+  setMemberParent,
+  withAssociation,
+  storeExtension,
+  dependsOn,
+  dependsOnSilent,
+} = require('./utils');
 
 const detectCycles = require('./cycle-detector');
 const layers = require('./moduleLayers');
 
-const {
-  kindProperties, fns, setLink, linkToOrigin, setMemberParent, withAssociation, storeExtension,
-  dependsOn, dependsOnSilent,
-} = require('./shared');
-
 const annotationPriorities = {
   define: 1, extend: 2, annotate: 2, edmx: 3,
 };
-
+const $inferred = Symbol.for('cds.$inferred');
 
 // Export function of this file.  Resolve type references in augmented CSN
 // `model`.  If the model has a property argument `messages`, do not throw
@@ -73,21 +77,21 @@ const annotationPriorities = {
 // that property (should be a vector).
 function resolve( model ) {
   const { options } = model;
-  // Get shared "resolve" functionality and the message function:
+  // Get shared functionality and the message function:
+  const {
+    info, warning, error, message,
+  } = model.$messageFunctions;
   const {
     resolvePath,
     resolveTypeArguments,
     defineAnnotations,
     attachAndEmitValidNames,
-  } = fns( model, environment );
-  const {
-    info, warning, error, message,
-  } = model.$messageFunctions;
-  const {
     initArtifact,
     lateExtensions,
     projectionAncestor,
-  } = getDefinerFunctions(model);
+  } = model.$functions;
+  model.$volatileFunctions.environment = environment;
+
   /** @type {any} may also be a boolean */
   let newAutoExposed = [];
 
@@ -242,6 +246,7 @@ function resolve( model ) {
     const chain = [];
     while (art && !('_effectiveType' in art) &&
            (art.type || art._origin || art.value && art.value.path) &&
+           // TODO: really stop at art.enum?
            !art.target && !art.enum && !art.elements && !art.items) {
       chain.push( art );
       setProp( art, '_effectiveType', 0 ); // initial setting in case of cycles
@@ -273,13 +278,17 @@ function resolve( model ) {
       // collect the "latest" cardinality (calculate lazyly if necessary)
       let cardinality = art.cardinality ||
           art._effectiveType && (() => getCardinality( art._effectiveType ));
+      let prev = art;
       for (const a of chain) {
         if (a.cardinality)
           cardinality = a.cardinality;
         if (a.expand && expandFromColumns( a, art, cardinality ) ||
             art.target && redirectImplicitly( a, art ) ||
-            art.elements && expandElements( a, art, eType ))
+            art.elements && expandElements( a, art, eType ) ||
+            art.items && expandItems( a, art, eType ))
           art = a;
+        else if (art.enum && expandEnum( a, prev ))
+          prev = a;             // do not set art - effective type is base
         setProp( a, '_effectiveType', art );
       }
     }
@@ -351,13 +360,13 @@ function resolve( model ) {
       while (struct.kind === 'element')
         struct = struct._parent;
       if (struct.kind === 'select') {
-        message( 'ref-invalid-typeof', [ ref.location, user ],
+        message( 'type-unexpected-typeof', [ ref.location, user ],
                  { keyword: 'type of', '#': struct.kind } );
         // we actually refer to an element in _combined; TODO: return null if
         // not configurable; would produce illegal CSN with sub queries in FROM
       }
       else if (struct !== user._main) {
-        message( 'ref-invalid-typeof', [ ref.location, user ],
+        message( 'type-unexpected-typeof', [ ref.location, user ],
                  { keyword: 'type of', '#': struct.kind } );
         return setProp( ref, '_artifact', null );
       }
@@ -405,7 +414,8 @@ function resolve( model ) {
     for (const view of resolveChain.reverse()) {
       if (view._status !== '_query' ) { // not already resolved
         setProp( view, '_status', '_query' );
-        traverseQueryPost( view.query, false, populateQuery );
+        // must be run in order “sub query in FROM first”:
+        traverseQueryPost( view.query, null, populateQuery );
         if (view.elements$)     // specified elements
           mergeSpecifiedElements( view );
         if (!view.$entity) {
@@ -494,7 +504,8 @@ function resolve( model ) {
         });
       }
       forEachGeneric( { elements: alias.elements }, 'elements', ( elem, name ) => {
-        dictAddArray( query._combined, name, elem, null ); // not dictAdd()
+        if (elem.$duplicates !== true)
+          dictAddArray( query._combined, name, elem, null ); // not dictAdd()
       });
     }
   }
@@ -535,13 +546,31 @@ function resolve( model ) {
     setMemberParent( key, name, elem ); // TODO: set _block here if not present?
   }
 
+  function expandItems( art, origin, eType ) {
+    if (!enableExpandElements || art.items)
+      return false;
+    if (isInParents( art, eType )) {
+      art.items = 0;            // circular
+      return true;
+    }
+    const ref = art.type || art.value || art.name;
+    const location = ref && ref.location || art.location;
+    art.items = { $inferred: 'expand-element', location };
+    setProp( art.items, '_outer', art );
+    setProp( art.items, '_origin', origin.items );
+    if (!art.$expand)
+      art.$expand = 'origin';   // if value stays, elements won't appear in CSN
+    return true;
+  }
+
   function expandElements( art, struct, eType ) {
     if (!enableExpandElements)
       return false;
     if (art.elements || art.kind === '$tableAlias' ||
         // no element expansions for "non-proper" types like
         // entities (as parameter types) etc:
-        struct.kind !== 'type' && struct.kind !== 'element' && !struct._outer)
+        struct.kind !== 'type' && struct.kind !== 'element' && struct.kind !== 'param' &&
+        !struct._outer)
       return false;
     if (struct.elements === 0 || isInParents( art, eType )) {
       art.elements = 0;         // circular
@@ -565,7 +594,28 @@ function resolve( model ) {
     // member property):
     if (!art.$expand)
       art.$expand = 'origin';   // if value stays, elements won't appear in CSN
-    // TODO: have some art.elements[SYM.$inferred] = 'expand-elements';
+    // TODO: have some art.elements[SYM.$inferred] = 'expand-element';
+    return true;
+  }
+
+  function expandEnum( art, origin ) {
+    if (!enableExpandElements || art.enum)
+      return false;
+    const ref = art.type || art.value || art.name;
+    const location = weakLocation( ref && ref.location || art.location );
+    art.enum = Object.create(null);
+    for (const name in origin.enum) {
+      const orig = origin.enum[name];
+      linkToOrigin( orig, name, art, 'enum', location, true )
+        // or should we use orig.location? - TODO: try to find test to see message
+        .$inferred = 'expand-element';
+    }
+    // Set elements expansion status (the if condition is always true, as no
+    // elements expansion will take place on artifact with existing other
+    // member property):
+    if (!art.$expand)
+      art.$expand = 'origin';   // if value stays, elements won't appear in CSN
+    art.enum[$inferred] = 'expand-element';
     return true;
   }
 
@@ -603,7 +653,7 @@ function resolve( model ) {
   //               not counting propagated ones; set up to the definition (main artifact)
   //               (only set with anno on $inferred elem)
   // Usage according to CSN flavor:
-  // - gensrc: do not render enferred elements (including expanded elements),
+  // - gensrc: do not render inferred elements (including expanded elements),
   //           collect annotate statements with value 'annotate'
   // - client: do not render expanded sub elements if artifact/member is no type, has a type,
   //           has $expand = 'origin', and all its _origin also have $expand = 'origin'
@@ -671,35 +721,69 @@ function resolve( model ) {
       else if (exposed.length === 1) {
         target = exposed[0];
       }
-      else {
-        message( (elem !== assoc ? 'redirected-implicitly-ambiguous' : 'type-ambiguous-target'),
-                 [ (elem.value || elem.name).location, elem ],
+      else if (elem === assoc) {
+        // `assoc: Association to ModelEntity`: user-provided target is to be auto-redirected
+        warning( 'type-ambiguous-target',
+                 [ elem.target.location, elem ],
                  {
                    target,
-                   service,
-                   art: definitionScope( target ),
+                   // art: definitionScope( target ), - TODO extra debug info in message
                    sorted_arts: exposed,
-                   '#': ( elemScope !== true ? 'std' : 'scoped' ),
                  }, {
                    // eslint-disable-next-line max-len
-                   std: 'Target $(TARGET) is exposed in service $(SERVICE) by multiple projections $(SORTED_ARTS) - no implicit redirection',
+                   std: 'Replace target $(TARGET) by one of $(SORTED_ARTS); can\'t auto-redirect this association if multiple projections exist in this service',
                    // eslint-disable-next-line max-len
-                   scoped: 'Target $(TARGET) is defined in scope $(ART) which exposed in service $(SERVICE) by multiple projections - no implicit redirection',
+                   two: 'Replace target $(TARGET) by $(SORTED_ARTS) or $(SECOND); can\'t auto-redirect this association if multiple projections exist in this service',
                  });
+        // continuation semantics: no auto-redirection
+      }
+      else {
+        // referred (and probably inferred) assoc (without a user-provided target at that place)
+        // HINT: consider bin/cdsv2m.js when changing the following message text
+        // No grouped and sub messages yet (TODO v3): mention at all target places with all assocs
+        const withAnno = annotationVal( exposed[0]['@cds.redirection.target'] );
+        for (const proj of exposed) {
+          // TODO: def-ambiguous-target (just v3, as the current is infamous and used in options),
+          message( 'redirected-implicitly-ambiguous',
+                   [ weakLocation( proj.location ), proj ],
+                   {
+                     '#': withAnno && 'justOne',
+                     target,
+                     art: elem,
+                     // art: definitionScope( target ), - TODO extra debug info in message
+                     anno: 'cds.redirection.target',
+                     sorted_arts: exposed,
+                   }, {
+                     // eslint-disable-next-line max-len
+                     std: 'Add $(ANNO) to one of $(SORTED_ARTS) to select the entity as redirection target for $(TARGET) in this service; can\'t auto-redirect $(ART) otherwise',
+                     // eslint-disable-next-line max-len
+                     two: 'Add $(ANNO) to either $(SORTED_ARTS) or $(SECOND) to select the entity as redirection target for $(TARGET) in this service; can\'t auto-redirect $(ART) otherwise',
+                     // eslint-disable-next-line max-len
+                     justOne: 'Remove $(ANNO) from all but one of $(SORTED_ARTS) to have a unique redirection target for $(TARGET) in this service; can\'t auto-redirect $(ART) otherwise',
+                   } );
+        }
         // continuation semantics: no implicit redirections
       }
     }
     if (elem.target) {          // redirection for Association to / Composition of
       if (elem.target._artifact === target) // no change (due to no implicit redirection)
         return true;
+      const type = resolvePath( elem.type, 'type', elem ); // cds.Association or cds.Composition
       const origin = {
-        kind: elem.kind,
+        kind: elem.kind, // necessary for rewrite, '$user-provided' would be best
         name: elem.name,
+        type: {
+          path: [ { id: type.name.absolute, location: elem.type.location } ],
+          scope: 'global',
+          location: elem.type.location,
+        },
         target: elem.target,
         $inferred: 'REDIRECTED',
         location: elem.target.location,
       };
       setLink( elem, origin, '_origin' );
+      setLink( elem.type, type, '_artifact' );
+      setLink( origin, elem, '_outer' );
       setLink( origin, elem._parent, '_parent' );
       if (elem._main)           // remark: the param `elem` can also be a type
         setLink( origin, elem._main, '_main' );
@@ -707,11 +791,11 @@ function resolve( model ) {
       setLink( origin, elem._block, '_block' );
       if (elem.foreignKeys) {
         origin.foreignKeys = elem.foreignKeys;
-        delete elem.foreignKeys;
+        delete elem.foreignKeys; // will be rewritten
       }
       if (elem.on) {
         origin.on = elem.on;
-        delete elem.on;
+        delete elem.on;         // will be rewritten
       }
     }
     elem.target = {
@@ -770,10 +854,7 @@ function resolve( model ) {
                                         target._descendants[service.name.absolute] ||
                                         [],
                                         elemScope, target );
-    const preferred = descendants.filter( ( d ) => {
-      const anno = d['@cds.redirection.target'];
-      return anno && (anno.val === undefined || anno.val );
-    } );
+    const preferred = descendants.filter( d => annotationVal( d['@cds.redirection.target'] ) );
     const exposed = preferred.length ? preferred : descendants;
     if (exposed.length < 2)
       return exposed || [];
@@ -812,7 +893,7 @@ function resolve( model ) {
       // Need to filter out auto-exposed, otherwise the behavior is
       // processing-order dependent (not storing the autoexposed in
       // _descendents would only be an alternative w/o recompilation)
-      return descendants.filter( d => !d['@cds.autoexposed'] );
+      return descendants.filter( d => !annotationVal( d['@cds.autoexposed'] ) );
     }
     // try scope as target first, even if it has @cds.redirection.target: false
     if (isDirectProjection( elemScope, target ))
@@ -943,6 +1024,7 @@ function resolve( model ) {
       $inferred: 'autoexposed',
       '@cds.autoexposed': {
         name: { path: [ { id: 'cds.autoexposed', location } ], location },
+        $inferred: 'autoexposed',
       },
     };
     // TODO: do we need to tag the generated entity with elemScope = 'auto'?
@@ -1440,8 +1522,9 @@ function resolve( model ) {
     }
     // Resolve projections/views
     // if (art.query)console.log( info( null, [art.query.location,art.query], 'VQ:' ).toString() );
-    // TODO: here, any order should be ok, i.e. just loop over $queries
-    traverseQueryPost( art.query, false, resolveQuery );
+
+    if (art.$queries)
+      art.$queries.forEach( resolveQuery );
 
     if (obj.type || obj._origin || obj.value && obj.value.path || obj.elements) // typed artifacts
       effectiveType(obj);  // set _effectiveType if appropriate, (future?): copy elems if extended
@@ -1586,6 +1669,11 @@ function resolve( model ) {
       }
     }
     if (art && art._annotate) {
+      if (art.kind === 'action' || art.kind === 'function') {
+        expandParameters( art );
+        if (art.returns)
+          effectiveType( art.returns );
+      }
       const aor = art.returns || art;
       const obj = aor.items || aor.targetAspect || aor;
       // Currently(?), effectiveType() does not calculate the effective type of
@@ -1620,6 +1708,44 @@ function resolve( model ) {
         annotateMembers( env && env[n], dict[n], prop, n, parent, kind );
     }
   }
+  function expandParameters( action ) {
+    // see also expandElements()
+    if (!enableExpandElements || !effectiveType( action ))
+      return;
+    const chain = [];
+    // Should we be able to consider params and returns separately?
+    // Probably not, let to-csn omit unchanged params/returns.
+    while (action._origin && !action.params) {
+      chain.push( action );
+      action = action._origin;
+    }
+    chain.reverse();
+    for (const art of chain) {
+      const origin = art._origin;
+      if (!art.params && origin.params) {
+        for (const name in origin.params) {
+          // TODO: we could check _annotate here to decide whether we really
+          // not to create proxies
+          const orig = origin.params[name];
+          linkToOrigin( orig, name, art, 'params', weakLocation( orig.location ), true )
+            .$inferred = 'expand-param';
+        }
+      }
+      if (!art.returns && origin.returns) {
+        // TODO: make linkToOrigin() work for returns, kind/name?
+        const location = weakLocation( origin.returns.location );
+        art.returns = {
+          name: Object.assign( {}, art.name, { id: '', param: '', location } ),
+          kind: 'param',
+          location,
+          $inferred: 'expand-param',
+        };
+        setProp( art.returns, '_parent', art );
+        setProp( art.returns, '_main', art._main || art );
+        setProp( art.returns, '_origin', origin.returns );
+      }
+    }
+  }
 
   function extensionFor( art ) {
     if (art.kind === 'annotate')
@@ -1826,7 +1952,7 @@ function resolve( model ) {
   function resolveQuery( query ) {
     if (!query._main)           // parse error
       return;
-    populateQuery( query );
+    traverseQueryPost( query, null, populateQuery );
     forEachGeneric( query, '$tableAliases', ( alias ) => {
       // console.log( info( null, [alias.location,alias], 'SQA:' ).toString() );
       if (alias.kind === 'mixin')
@@ -1967,6 +2093,7 @@ function resolve( model ) {
         dependsOnSilent(art, key);
       }
     });
+    obj.foreignKeys[$inferred] = 'keys';
   }
 
   function addForeignKeyNavigations( art ) {
@@ -2135,8 +2262,6 @@ function resolve( model ) {
   // Only top-level queries and sub queries in FROM
 
   function rewriteSimple( art ) {
-    // If we have a proper seperation of view elements and elements of the
-    // primary query, we can delete this function.
     // return;
     if (!art.includes && !art.query) {
       // console.log(message( null, art.location, art, {target:art._target},
@@ -2149,7 +2274,7 @@ function resolve( model ) {
   }
 
   function rewriteView( view ) {
-    traverseQueryPost( view.query, false, ( query ) => {
+    traverseQueryExtra( view, ( query ) => {
       forEachGeneric( query, 'elements', rewriteAssociation );
     } );
     if (view.includes)          // entities with structure includes:
@@ -2157,6 +2282,7 @@ function resolve( model ) {
   }
 
   // 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 );
@@ -2382,7 +2508,7 @@ function resolve( model ) {
       resolveExpr( cond, rewriteExpr, elem, nav.tableAlias );
     }
     else {
-      // TODO: support that
+      // TODO: support that, now that the ON condition is rewritten in the right order
       error( null, [ elem.value.location, elem ],
              'Selecting unmanaged associations from a sub query is not supported' );
     }
@@ -2551,6 +2677,8 @@ function resolve( model ) {
   }
 
   function resolveExpr( expr, expected, user, extDict, expandOrInline) {
+    // TODO: when we have rewritten the resolvePath functions,
+    // define a traverseExpr() in ./utils.js
     // TODO: extra "expected" 'expand'/'inline' instead o param `expandOrInline`
     if (!expr || typeof expr === 'string') // parse error or keywords in {xpr:...}
       return;
@@ -2587,7 +2715,7 @@ function resolve( model ) {
     else if (expr.query) {
       const { query } = expr;
       if (query.kind || query._leadingQuery) { // UNION has _leadingQuery
-        traverseQueryPost( query, false, resolveQuery );
+        // traverseQueryPost( query, false, resolveQuery );
       }
       else {
         error( 'expr-no-subquery', [ expr.location, user ], {},
@@ -2598,9 +2726,10 @@ function resolve( model ) {
       const args = Array.isArray(expr.args) ? expr.args : Object.values( expr.args );
       args.forEach( e => e && resolveExpr( e, e.$expected || expected, user, extDict ) );
     }
-    if (expr.suffix && !isBetaEnabled( options, 'windowFunctions' )) {
+    if (expr.suffix && isDeprecatedEnabled( options )) {
       const { location } = expr.suffix[0] || expr;
-      error( null, [ location, user ], 'Window functions are not supported' );
+      error( null, [ location, user ], { prop: 'deprecated' },
+             'Window functions are not supported if $(PROP) options are set' );
     }
     if (expr.suffix)
       expr.suffix.forEach( s => s && resolveExpr( s, expected, user, extDict ) );
@@ -2785,11 +2914,11 @@ function navProjection( navigation, preferred ) {
     : navigation._projections[0] || null;
 }
 
-// Query tree post-order traversal - called for everything which makes a query
+// Query tree post-order traversal - called for everything which contributes to the query
+// i.e. is necessary to calculate the elements of the query
 // except "real ones": operands of UNION etc, JOIN with ON, and sub queries in FROM
+// NOTE: does not run on non-referred sub queries!  Consider using ‹main›.$queries instead!
 function traverseQueryPost( query, simpleOnly, callback ) {
-  while (Array.isArray(query)) // query in parentheses, TODO: remove
-    query = query[0];
   if (!query)                   // parser error
     return;
   if (!query.op) {              // in FROM (not JOIN)
@@ -2809,13 +2938,51 @@ function traverseQueryPost( query, simpleOnly, callback ) {
     // console.log('FE:')
   }
   else if (query.args) {             // JOIN, UNION, INTERSECT
-    for (const q of query.args)
-      traverseQueryPost( q, simpleOnly, callback );
-    // The ON condition has to be traversed extra, because it must be evaluated
-    // after the complete FROM has been traversed.  It is also not necessary to
-    // evaluate it in populateQuery().
+    if (!query.join && simpleOnly == null) {
+      // enough for elements: traverse only first args for UNION/INTERSECT
+      // TODO: we might use this also when we do not rewrite associations
+      // in non-referred sub queries
+      traverseQueryPost( query.args[0], simpleOnly, callback );
+    }
+    else {
+      for (const q of query.args)
+        traverseQueryPost( q, simpleOnly, callback );
+      // The ON condition has to be traversed extra, because it must be evaluated
+      // after the complete FROM has been traversed.  It is also not necessary to
+      // evaluate it in populateQuery().
+    }
   }
   // else: with parse error (`select from <EOF>`, `select distinct from;`)
 }
 
+// Call callback on all queries in dependency order, i.e. starting with query Q
+// 1. sub queries in FROM sources of Q
+// 2. Q itself, except if non-referred query, but with right UNION parts
+// 3. sub queries in ON in FROM of Q
+// 4. sub queries in columns, WHERE, HAVING
+function traverseQueryExtra( main, callback ) {
+  if (!main.$queries)
+    return;
+  // with a top-level UNION, $queries[0] is just the left
+  traverseQueryPost( main.query, false, (q) => { // also with right of UNION (to be compatible)
+    setProp( q, '_status', 'extra' );
+    callback( q );
+  } );
+  for (const query of main.$queries.slice(1)) {
+    if (query._status === 'extra' || query._parent.kind === '$tableAlias')
+      continue; // if parent is alias, query is FROM source -> run by traverseQueryPost
+    // we are now in the top-level (parent is entity) or a non-referred query (parent is query)
+    setProp( query, '_status', 'extra' ); // do not call callback() in non-referred query
+    // console.log( 'A:', query.name,query._status)
+    traverseQueryPost( query, null, (q) => {
+      if (q._status !== 'extra') {
+        // console.log( 'T:', q.name)
+        setProp( q, '_status', 'extra' );
+        callback( q );
+      }
+      // else console.log( 'E:', q.name)
+    } );
+  }
+}
+
 module.exports = resolve;