@sap/cds-compiler 2.7.0 → 2.11.2

package/lib/compiler/resolver.js

@@ -47,25 +47,28 @@ 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,
   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 +76,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 +245,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 +277,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 );
       }
     }
@@ -405,7 +413,7 @@ 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 );
+        traverseQueryPost( view.query, null, populateQuery );
         if (view.elements$)     // specified elements
           mergeSpecifiedElements( view );
         if (!view.$entity) {
@@ -494,7 +502,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 +544,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
@@ -560,8 +587,33 @@ function resolve( model ) {
         // or should we use orig.location? - TODO: try to find test to see message
         .$inferred = 'expand-element';
     }
-    art.$expand = 'origin';   // if value stays, elements won't appear in CSN
-    // TODO: should we also set 'virtual' here?
+    // 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
+    // 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;
   }
 
@@ -587,14 +639,45 @@ function resolve( model ) {
     return false;
   }
 
-  function setExpandStatus( elem ) {
+  // 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
+  //             that value is only on elements, types, and params -> no other members
+  //             when set, only on elem/art with expanded elements
+  // - 'target': all expanded (sub) elements might only have new target/on, but
+  //             no indivual annotations on any (sub) member
+  //             when set, traverse all parents where the value has been 'origin' before
+  // - 'annotate': at least one inferred (sub) member has an individual annotation,
+  //               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 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'
+  //           (might sometimes render the elements unnecessarily, which is not wrong)
+  // - universal: do not render expanded sub elements if $expand = 'origin'
+  function setExpandStatus( elem, status ) {
+    // set on element
     while (elem._main) {
       elem = elem._parent;
-      if (!elem.$expand)
+      if (elem.$expand !== 'origin')
         return;
-      elem.$expand = 'target';  // meaning: expanded, containing assocs
+      elem.$expand = status;    // meaning: expanded, containing assocs
       for (let line = elem.items; line; line = line.items)
-        line.$expand = 'target'; // to-csn just uses the innermost $expand
+        line.$expand = status; // to-csn just uses the innermost $expand
+    }
+  }
+  function setExpandStatusAnnotate( elem, status ) {
+    for (;;) {
+      if (elem.$expand === status)
+        return;                 // already set
+      elem.$expand = status;    // meaning: expanded, containing annos
+      for (let line = elem.items; line; line = line.items)
+        line.$expand = status; // to-csn just uses the innermost $expand
+      if (!elem._main)
+        return;
+      elem = elem._parent;
     }
   }
 
@@ -606,7 +689,7 @@ function resolve( model ) {
     // PRE: elem has no target, assoc has target prop
     if (elem.kind === '$tableAlias')
       return false;
-    setExpandStatus( elem );
+    setExpandStatus( elem, 'target' );
     let target = resolvePath( assoc.target, 'target', assoc );
     // console.log( info( null, [ elem.location, elem ], {target,art:assoc,name:''+assoc.target},
     //              'RED').toString())
@@ -719,6 +802,7 @@ function resolve( model ) {
     const nullScope = {
       kind: 'namespace', name: { absolute: autoScopeName, location }, location,
     };
+    model.definitions[autoScopeName] = nullScope;
     initArtifact( nullScope );
     return nullScope;
   }
@@ -1404,8 +1488,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
@@ -1550,14 +1635,28 @@ function resolve( model ) {
       }
     }
     if (art && art._annotate) {
-      if (art.$expand && art._annotate.elements)
-        art.$expand = 'annotate'; // do not omit expanded elements when they are annotated
-      // TODO: returns
-      let obj = art.returns || art; // why the extra `returns` for actions?
-      obj = obj.items || obj;
+      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
+      // its line item:
+      effectiveType( obj );
+      if (art._annotate.elements)
+        setExpandStatusAnnotate( aor, 'annotate' );
       annotate( obj, 'element', 'elements', 'enum', art );
       annotate( art, 'action', 'actions' );
       annotate( art, 'param', 'params' );
+      // const { returns } = art._annotate;
+      // if (returns) {
+      //   const dict = returns.elements;
+      //   const env = obj.returns && obj.returns.elements || null;
+      //   for (const n in dict)
+      //     annotateMembers( env && env[n], dict[n], 'elements', n, parent, 'element' );
+      // }
     }
     return;
 
@@ -1575,6 +1674,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')
@@ -1613,6 +1750,8 @@ function resolve( model ) {
     ext.kind = 'annotate';    // after setMemberParent()!
     setProp( art, '_extension', ext );
     setProp( ext.name, '_artifact', art );
+    if (art.returns)
+      ext.$syntax = 'returns';
     return ext;
   }
 
@@ -1779,7 +1918,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')
@@ -1816,7 +1955,7 @@ function resolve( model ) {
     return;
 
     function resolveJoinOn( join ) {
-      if (join.args) {             // JOIN
+      if (join && join.args) {  // JOIN
         for (const j of join.args)
           resolveJoinOn( j );
         if (join.on)
@@ -1853,7 +1992,10 @@ function resolve( model ) {
     }
     const target = resolvePath( obj.target, 'target', art );
     if (obj.on) {
-      if (!art._main || !art._parent.elements && !art._parent.items) {
+      if (!art._main || !art._parent.elements && !art._parent.items && !art._parent.targetAspect) {
+        // TODO: test of .items a bit unclear - we should somehow restrict the
+        // use of unmanaged assocs in MANY, at least with $self
+        // TODO: $self usage in anonymous aspects to be corrected in Core Compiler
         const isComposition = obj.type && obj.type.path && obj.type.path[0] &&
                               obj.type.path[0].id === 'cds.Composition';
         message( 'assoc-as-type', [ obj.on.location, art ],
@@ -2294,6 +2436,9 @@ function resolve( model ) {
 
   // TODO: there is no need to rewrite the on condition of non-leading queries,
   // i.e. we could just have on = {…}
+  // TODO: re-check $self rewrite (with managed composition of aspects),
+  // and actually also $self inside anonymous aspect definitions
+  // (not entirely urgent as we do not analyse it further, at least sole "$self")
   function rewriteCondition( elem, assoc ) {
     if (enableExpandElements && elem._parent && elem._parent.kind === 'element') {
       // managed association as sub element not supported yet
@@ -2498,6 +2643,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;
@@ -2534,7 +2681,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 ], {},
@@ -2545,12 +2692,19 @@ 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 && isDeprecatedEnabled( options )) {
+      const { location } = expr.suffix[0] || expr;
+      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 ) );
   }
 
   function resolveParamsAndWhere( step, expected, user, extDict, isLast ) {
     const alias = step._navigation && step._navigation.kind === '$tableAlias' && step._navigation;
     const type = alias || effectiveType( step._artifact );
-    const art = type && type.target && type.target._artifact || type;
+    const art = (type && type.target) ? type.target._artifact : type;
     if (!art)
       return;
     const entity = (art.kind === 'entity') &&
@@ -2561,7 +2715,7 @@ function resolve( model ) {
       if (step.where)
         resolveExpr( step.where, 'filter', user, environment( type ) );
     }
-    else if (step.where || step.cardinality ) {
+    else if (step.where && step.where.location || step.cardinality ) {
       const location = combinedLocation( step.where, step.cardinality );
       // XSN TODO: filter$location including […]
       message( 'expr-no-filter', [ location, user ], { '#': expected },
@@ -2729,8 +2883,6 @@ function navProjection( navigation, preferred ) {
 // Query tree post-order traversal - called for everything which makes a query
 // except "real ones": operands of UNION etc, JOIN with ON, and sub queries in FROM
 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)
@@ -2750,11 +2902,19 @@ 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;`)
 }