@sap/cds-compiler 2.7.0 → 2.10.2

package/lib/compiler/definer.js

@@ -216,7 +216,8 @@ function getDefinerFunctions( model ) {
     applyExtensions();
 
     Object.keys( model.definitions ).forEach( preProcessArtifact );
-    const commonLanguagesEntity = isBetaEnabled( options, 'addTextsLanguageAssoc' ) &&
+    const commonLanguagesEntity // TODO: remove beta after a grace period
+        = (options.addTextsLanguageAssoc || isBetaEnabled( options, 'addTextsLanguageAssoc' )) &&
           model.definitions['sap.common.Languages'];
     addTextsLanguageAssoc = !!(commonLanguagesEntity && commonLanguagesEntity.elements &&
                                commonLanguagesEntity.elements.code);
@@ -492,7 +493,7 @@ function getDefinerFunctions( model ) {
     initDollarSelf( art );      // $self
     if (art.params)
       initParams( art );        // $parameters
-    if (art.includes && !(art.name.absolute in extensionsDict))
+    if (art.includes && !(art.name.absolute in extensionsDict)) // TODO: in next phase?
       extensionsDict[art.name.absolute] = []; // structure with includes must be "extended"
 
     if (!art.query)
@@ -607,14 +608,7 @@ function getDefinerFunctions( model ) {
     if (query.on)
       initExprForQuery( query.on, query );
     // TODO: MIXIN with name = ...subquery (not yet supported anyway)
-    for (const elem of query.columns || []) {
-      if (elem && (elem.value || elem.expand)) {
-        setProp( elem, '_block', query._block );
-        defineAnnotations( elem, elem, query._block );
-        initExprForQuery( elem.value, query );
-        initExpandInline( elem );
-      }
-    }
+    initSelectItems( query, query.columns );
     if (query.where)
       initExprForQuery( query.where, query );
     if (query.having)
@@ -622,22 +616,41 @@ function getDefinerFunctions( model ) {
     initMembers( query, query, query._block );
   }
 
-  function initExpandInline( elem ) {
-    // TODO: forbid with :param, global:true, in ref-where, outside queries (CSN), ...
-    for (const sub of elem.expand || elem.inline || []) {
-      if (!sub)                 // parse error
+  function initSelectItems( parent, columns ) {
+    // TODO: forbid expand/inline with :param, global:true, in ref-where, outside queries (CSN), ...
+    let wildcard = null;
+    for (const col of columns || parent.expand || parent.inline || []) {
+      if (!col)                 // parse error
         continue;
-      if (elem.value)
-        setProp( sub, '_pathHead', elem ); // also set for '*' in expand/inline
-      else if (elem._pathHead)
-        setProp( sub, '_pathHead', elem._pathHead );
-      if (sub.value || sub.expand) {
-        setProp( sub, '_block', elem._block );
-        defineAnnotations( sub, sub, elem._block ); // TODO: complain with inline
-        initExpandInline( sub );
+      if (!columns) {
+        if (parent.value)
+          setProp( col, '_pathHead', parent ); // also set for '*' in expand/inline
+        else if (parent._pathHead)
+          setProp( col, '_pathHead', parent._pathHead );
+      }
+      if (col.val === '*') {
+        if (!wildcard) {
+          wildcard = col;
+        }
+        else {
+          // a late syntax error (this code also runs with parse-cdl), i.e.
+          // no semantic loc (wouldn't be available for expand/inline anyway)
+          error( 'syntax-duplicate-clause', [ col.location, null ],
+                 { prop: '*', line: wildcard.location.line, col: wildcard.location.col },
+                 'You have provided a $(PROP) already at line $(LINE), column $(COL)' );
+          // TODO: extra text variants for expand/inline? - probably not
+          col.val = null;       // do not consider it for expandWildcard()
+        }
+      }
+      else if (col.value || col.expand) {
+        setProp( col, '_block', parent._block );
+        defineAnnotations( col, col, parent._block ); // TODO: complain with inline
+        // TODO: allow sub queries? at least in top-level expand without parallel ref
+        if (columns)
+          initExprForQuery( col.value, parent );
+        initSelectItems( col );
       }
     }
-    // TODO: allow sub queries in top-level expand without parallel ref
   }
 
   function initExprForQuery( expr, query ) {
@@ -656,9 +669,38 @@ function getDefinerFunctions( model ) {
     }
     else if (expr.path && expr.$expected === 'exists') {
       expr.$expected = 'approved-exists';
+      approveExistsInChildren(expr);
     }
   }
 
+  /**
+   * If we have a valid top-level exists, exists in filters of sub-expressions can be translated,
+   * since we will have a top-level subquery after exists-processing in the forHanaNew.
+   *
+   * Recursively drill down into:
+   * - the .path
+   * - the .args
+   * - the .where.args
+   *
+   * Any $expected === 'exists' encountered along the way are turned into 'approved-exists'
+   *
+   * working:     exists toE[exists toE] -> select from E where exists toE
+   * not working: toE[exists toE] -> we don't support subqueries in filters
+   *
+   * @param {object} exprOrPathElement starts w/ an expr but then subelem from .path or .where.args
+   */
+  function approveExistsInChildren(exprOrPathElement) {
+    if (exprOrPathElement.$expected === 'exists')
+      exprOrPathElement.$expected = 'approved-exists';
+    // Drill down
+    if (exprOrPathElement.args)
+      exprOrPathElement.args.forEach(elem => approveExistsInChildren(elem));
+    else if (exprOrPathElement.where && exprOrPathElement.where.args)
+      exprOrPathElement.where.args.forEach(elem => approveExistsInChildren(elem));
+    else if (exprOrPathElement.path)
+      exprOrPathElement.path.forEach(elem => approveExistsInChildren(elem));
+  }
+
   // table is table expression in FROM, becomes an alias
   function initTableExpression( table, query, joinParents ) {
     if (!table)                 // parse error
@@ -706,6 +748,8 @@ function getDefinerFunctions( model ) {
           //        ? ta._joinParent.args[ta.$joinArgsIndex] // in JOIN
           //        : ta._parent.from )                      // directly in FROM
           // Note for --raw-output: _joinParent pointing to CROSS JOIN node has not name
+          if (!tab)             // parse error; time for #6241
+            return;             // (parser method to only add non-null to array)
           setProp( tab, '_joinParent', table );
           tab.$joinArgsIndex = index;
           initTableExpression( tab, query, joinParents );
@@ -859,6 +903,7 @@ function getDefinerFunctions( model ) {
    * (which is basically the component name of the `parent` element plus a dot).
    */
   function initMembers( construct, parent, block, initExtensions = false ) {
+    // TODO: split extend from init
     const isQueryExtension = kindProperties[construct.kind].isExtension &&
           (parent._main || parent).query;
     let obj = construct;
@@ -914,7 +959,7 @@ function getDefinerFunctions( model ) {
       forEachInOrder( construct, 'params', init );
     const { returns } = construct;
     if (returns) {
-      returns.kind = 'param';
+      returns.kind = (kindProperties[construct.kind].isExtension) ? construct.kind : 'param';
       init( returns, '' );      // '' is special name for returns parameter
     }
     return;
@@ -983,6 +1028,7 @@ function getDefinerFunctions( model ) {
   }
 
   function checkDefinitions( construct, parent, prop, dict = construct[prop] ) {
+    // TODO: do differently, see also annotateMembers() in resolver
     // To have been checked by parsers:
     // - artifacts (CDL-only anyway) only inside [extend] context|service
     if (!dict)
@@ -1421,6 +1467,12 @@ function getDefinerFunctions( model ) {
 
         model.extensions.push(annotationArtifact);
         extendArtifact( exts, annotationArtifact ); // also sets _artifact link in extensions
+        // if one of the annotate statement mentions 'returns', assume it
+        // TODO: with warning/info?
+        for (const ext of exts) {
+          if (ext.$syntax === 'returns')
+            annotationArtifact.$syntax = 'returns';
+        }
       }
     }
   }
@@ -1704,6 +1756,7 @@ function getDefinerFunctions( model ) {
   }
 
   function extendMembers( extensions, art, noExtend ) {
+    // TODO: do the whole extension stuff lazily if the elements are requested
     const elemExtensions = [];
     extensions.sort( compareLayer );
     for (const ext of extensions) {
@@ -1749,7 +1802,12 @@ function getDefinerFunctions( model ) {
     [ 'elements', 'actions' ].forEach( (prop) => {
       const dict = art._extend && art._extend[prop];
       for (const name in dict) {
-        const validDict = art[prop] || prop === 'elements' && art.enum;
+        let obj = art;
+        if (obj.targetAspect)
+          obj = obj.targetAspect;
+        while (obj.items)
+          obj = obj.items;
+        const validDict = obj[prop] || prop === 'elements' && obj.enum;
         const member = validDict[name];
         if (!member)
           extendNothing( dict[name], prop, name, art, validDict );
@@ -1988,8 +2046,8 @@ function getDefinerFunctions( model ) {
 
       if (isKey && isLocalized) { // key with localized is wrong - ignore localized
         const errpos = elem.localized || elem.type || elem.name;
-        warning( 'localized-key', [ errpos.location, elem ], {},
-                 'Keyword "localized" is ignored for primary keys' );
+        warning( 'localized-key', [ errpos.location, elem ], { keyword: 'localized' },
+                 'Keyword $(KEYWORD) is ignored for primary keys' );
       }
     }
     if (textElems.length <= keys)
@@ -2131,9 +2189,9 @@ function getDefinerFunctions( model ) {
           });
         }
       }
-      else {                    // use location of LOCALIZED keyword
+      if (hasTruthyProp( orig, 'localized' )) { // use location of LOCALIZED keyword
         const localized = orig.localized || orig.type || orig.name;
-        elem.localized = { val: false, $inferred: 'localized', location: localized.location };
+        elem.localized = { val: null, $inferred: 'localized', location: localized.location };
       }
     }
     if (fioriEnabled)

package/lib/compiler/resolver.js

@@ -560,8 +560,12 @@ 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-elements';
     return true;
   }
 
@@ -587,14 +591,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 enferred 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 +641,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 +754,7 @@ function resolve( model ) {
     const nullScope = {
       kind: 'namespace', name: { absolute: autoScopeName, location }, location,
     };
+    model.definitions[autoScopeName] = nullScope;
     initArtifact( nullScope );
     return nullScope;
   }
@@ -1550,14 +1586,23 @@ 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;
+      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;
 
@@ -1613,6 +1658,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;
   }
 
@@ -1816,7 +1863,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 +1900,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 +2344,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
@@ -2545,12 +2598,18 @@ 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' )) {
+      const { location } = expr.suffix[0] || expr;
+      error( null, [ location, user ], 'Window functions are not supported' );
+    }
+    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 +2620,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 },

package/lib/compiler/shared.js

@@ -60,7 +60,7 @@ const kindProperties = {
 
 function propExists( prop, parent ) {
   const obj = parent.returns || parent;
-  return (obj.items || obj)[prop];
+  return (obj.items || obj.targetAspect || obj)[prop];
 }
 
 function artifactsEnv( art ) {
@@ -657,13 +657,28 @@ function fns( model, environment = artifactsEnv ) {
           return false;
         continue;
       }
-      if (art && art.$uncheckedElements) {
-        // do not check any elements of the path, e.g. $session
-        return art;
-      }
+
       const fn = (spec.envFn && artItemsCount >= 0) ? spec.envFn : 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 = setLink( item, env && env[item.id] );
+
       if (!sub)
         return (sub === 0) ? 0 : errorNotFound( item, env );
       else if (Array.isArray(sub)) // redefinitions
@@ -941,10 +956,11 @@ function linkToOrigin( origin, name, parent, prop, location, silentDep ) {
 
 function setMemberParent( elem, name, parent, prop ) {
   if (prop) {              // extension or structure include
-    // TODO: consider ARRAY OF and RETURNS, COMPOSITION OF type
-    if (!(prop in parent))
-      parent[prop] = Object.create(null);
-    dictAdd( parent[prop], name, elem );
+    // TODO: consider nested ARRAY OF and RETURNS, COMPOSITION OF type
+    const p = parent.items || parent.targetAspect || parent;
+    if (!(prop in p))
+      p[prop] = Object.create(null);
+    dictAdd( p[prop], name, elem );
   }
   if (parent._outer)
     parent = parent._outer;
@@ -1000,6 +1016,10 @@ function storeExtension( elem, name, prop, parent, block ) {
   const kind = `_${ elem.kind }`; // _extend or _annotate
   if (!parent[kind])
     setProp( parent, kind, {} );
+  // if (name === '' && prop === 'params') {
+  //   pushToDict( parent[kind], 'returns', elem ); // not really a dict
+  //   return;
+  // }
   if (!parent[kind][prop])
     parent[kind][prop] = Object.create(null);
   pushToDict( parent[kind][prop], name, elem );