@sap/cds-compiler 4.0.2 → 4.1.2

package/lib/compiler/populate.js

@@ -41,9 +41,10 @@ const {
   linkToOrigin,
   setMemberParent,
   proxyCopyMembers,
-  dependsOn,
   setExpandStatus,
   setExpandStatusAnnotate,
+  dependsOnSilent,
+  columnRefStartsWithSelf,
 } = require('./utils');
 const { typeParameters } = require('./builtins');
 
@@ -73,6 +74,7 @@ function populate( model ) {
   } = model.$messageFunctions;
   const {
     resolvePath,
+    nestedElements,
     attachAndEmitValidNames,
     initArtifact,
     extendArtifactBefore,
@@ -81,8 +83,7 @@ function populate( model ) {
   Object.assign( model.$functions, {
     effectiveType,
     getOrigin,
-    resolveType,
-    navigationEnv,
+    getInheritedProp,
   } );
   // let depth = 100;
 
@@ -111,12 +112,17 @@ function populate( model ) {
   newAutoExposed = true;      // internal error if auto-expose after here
   return;
 
+  /** Make sure that effectiveType() is called on all members and items */
   function traverseElementEnvironments( art ) {
-    navigationEnv( art );
+    let type = effectiveType( art );
+    while (type?.items)
+      type = effectiveType( type.items );
     if (art.$queries)
       art.$queries.forEach( traverseElementEnvironments );
     if (art.mixin)
-      dictForEach( art.mixin, navigationEnv );
+      dictForEach( art.mixin, effectiveType );
+    if (art.targetAspect?.elements)
+      effectiveType( art.targetAspect );
     if (art !== art._main?._leadingQuery) // already done
       forEachMember( art, traverseElementEnvironments );
   }
@@ -125,37 +131,6 @@ function populate( model ) {
   //--------------------------------------------------------------------------
   // The central functions for path resolution - must work on-demand
   //--------------------------------------------------------------------------
-  // Phase 2: call effectiveType() on-demand, which also calculates view elems
-
-  // TODO: move setting dependencies and complaining about assocs in keys
-  // to resolvePath - then remove params: location, user
-  function navigationEnv( art, location, user, assocSpec ) {
-    // = effectiveType() on from-path, TODO: should actually already part of
-    // resolvePath() on FROM
-    if (!art)
-      return undefined;
-    let type = effectiveType( art );
-    while (type?.items)          // TODO: disallow navigation to many sometimes
-      type = effectiveType( type.items );
-    if (!type?.target || assocSpec === 'targetAspectOnly')
-      return type;
-
-    if (assocSpec === false) {
-      // TODO: combine this with setTargetReferenceKey&Co in getPathItem?
-      error( null, [ location, user ], {},
-             'Following an association is not allowed in an association key definition' );
-    }                   // TODO: else warning for assoc usage with falsy assocSpec
-    const target = resolvePath( type.target, 'target', type );
-    if (!target)
-      return target;
-    if (target && assocSpec && user)
-      dependsOn( user, target, location || user.location );
-    const effectiveTarget = effectiveType( target );
-    if (effectiveTarget === 0 && location)
-      dependsOn( user, user, (user.target || user.type || user.value || user).location );
-    // console.log('NT:',assocSpec,!!user,target)
-    return effectiveTarget;
-  }
 
   /**
    * Return the artifact having properties which are relevant for further name
@@ -189,10 +164,11 @@ function populate( model ) {
    * artifact is an association or composition; it also does not give you the
    * information about the technical base type of an enum.
    *
-   * Calculating an effective association/composition does not imply calculating
-   * its effective target.  Calculating an effective structure (entities, …)
-   * does not imply calculating the effective types of its elements.  Calculating
-   * an effective array does not imply calculating its effective line type.
+   * Calculating an effective association/composition implies calculating its
+   * target entity (including redirections), but not induce calculating the
+   * target's elements.  Calculating an effective structure (entities, …)  does
+   * not imply calculating the effective types of its elements.  Calculating an
+   * effective array does not imply calculating its effective line type.
    */
   function effectiveType( art ) {
     if (!art)
@@ -212,16 +188,28 @@ function populate( model ) {
     }
     if (art)
       art = art._effectiveType;
-    if (art === 0)
+    if (art === 0) {
+      model.$assert = 'cycle';
+      // throw Error(`CYCLE: ${ chain.length }`);
       return art;
-
+    }
     chain.reverse();
     for (const a of chain) {
+      // Ensure that the _effectiveType of the parent has been calculated.  This
+      // is usually the case, but might not be for elements of anonymous target
+      // aspects.  Without it, extensions/annotations might get lost.
+      // For a query and its parent (usually the query entity!), it is the other way
+      // around: to calculate the _effectiveType of the query entity, we might need
+      // to calculate the _effectiveType of a query in FROM first.
+      if (a.kind !== 'select')
+        effectiveType( a._outer || a._main && a._parent );
+      // TODO: forbid $self+$self.elem inline, see expandWildcard()
       // Without type, value.path or _origin at beginning, link to itself:
       extendArtifactBefore( a );
       art = populateArtifact( a, art ) || a;
       setLink( a, '_effectiveType', art );
       a.$effectiveSeqNo = ++effectiveSeqNo;
+      // console.log('PE:',require('../model/revealInternalProperties').ref(a))
       if (a.elements$ || a.enum$)
         mergeSpecifiedElementsOrEnum( a );
       // console.log( 'ET-DO:', effectiveSeqNo, a?.kind, a?.name, a._extensions?.elements?.length )
@@ -237,13 +225,16 @@ function populate( model ) {
     // Name-resolution relevant properties directly at artifact:
     // ‹view›.elements of input must have been moved (to elements$) before!
     // console.log('Q:',art.elements,art.enum,art.items,!!art.query)
+    // console.log('PA:',require('../model/revealInternalProperties').ref(art))
     if (art.includes)           // first version of includes via effectiveTpe()
       art.includes.forEach( i => effectiveType( i._artifact ) );
     if (art.elements != null || art.enum != null || art.items != null)
       return art;
     if (art.target) {
+      // make sure that target._artifact is set:
+      const target = resolvePath( art.target, 'target', art );
       // try to implicitly redirect explicitly provided target:
-      if (!origEffective?.target && art.kind !== 'mixin')
+      if (target && !origEffective?.target && art.kind !== 'mixin')
         redirectImplicitly( art, art );
       if (!art.expand)
         return art;
@@ -257,8 +248,14 @@ function populate( model ) {
       const leading = art.$queries[0];
       if (!leading)             // parse error
         return null;
-      // assert that there is no _effectiveType on leading (should be the case, as
-      // you cannot refer to a query of another artifact)
+      if (leading._effectiveType !== undefined) {
+        // You cannot refer to a query of another artifact:
+        throw new CompilerAssertion(
+          `Unexpected _effectiveType on leading query of ${ art.name.absolute }`
+        );
+      }
+      // TODO: try just return (effectiveType( leading )) === 0 ? 0 : art;
+      setLink( leading, '_effectiveType', 0 ); // relevant to detect invalid $self.*
       populateQuery( leading );
       setLink( leading, '_effectiveType', leading );
       leading.$effectiveSeqNo = ++effectiveSeqNo;
@@ -313,7 +310,7 @@ function populate( model ) {
     if (art._origin !== undefined)
       return art._origin;
     if (art.type)               // not stored in _origin
-      return resolveType( art.type, art );
+      return resolvePath( art.type, 'type', art );
     return setLink( art, '_origin', getOriginRaw( art ) );
   }
 
@@ -321,17 +318,23 @@ function populate( model ) {
     if (!art._main) {
       if (art.query)
         return getOrigin( art.$queries?.[0] );
+      // TODO: if we add the `includes` mechanism, use resolveUncheckedPath() for
+      // includes here, because the accept function for includes requires the
+      // elements to have been calculated!
     }
     else {
       // TODO: write checks for path in enum?
       if (art.value?.path)
-        return resolvePath( art.value, (art.$syntax === 'calc' ? 'calc' : 'expr'), art );
-      if (art.kind === 'select')
-        return getOrigin( dictFirst( art.$tableAliases ) );
+        return resolvePath( art.value, (art.$syntax === 'calc' ? 'calc' : 'column'), art );
+      if (art.kind === 'select') {
+        const alias = dictFirst( art.$tableAliases );
+        // With parse errors, the first “alias” might be $self.  Using its origin
+        // would lead to a cyclic processing dependency.
+        return (alias.kind === '$tableAlias') ? getOrigin( alias ) : null;
+      }
       // init sets _origin for alias to sub query, only need to handle ref here:
       if (art.kind === '$tableAlias') {
-        // do not use navigationEnv(): it would always call effectiveType() on the
-        // source → we would have a deeper callstack
+        // do not call effectiveType() on the source to avoid a deeper callstack
         const source = resolvePath( art, 'from', art._parent );
         if (!source?._main)
           return source;        // direct entity (or undefined)
@@ -339,33 +342,19 @@ function populate( model ) {
         // to call effectiveType() on the last assoc of a from ref:
         // TODO: check this with test3/Queries/DollarSelf/CorruptedSource.err.cds
         const assoc = effectiveType( source );
-        return resolvePath( assoc?.target, 'target', assoc );
+        return assoc?.target._artifact;
       }
     }
     return '';
   }
 
-  function resolveType( ref, user ) {
-    if (ref._artifact !== undefined)
-      return ref._artifact;
-    while (user._outer)         // in items
-      user = user._outer;
-    if (user.kind === 'event')
-      return resolvePath( ref, 'eventType', user );
-    if (user.kind === 'param' && user._parent &&
-      (user._parent.kind === 'action' || user._parent.kind === 'function'))
-      return resolvePath( ref, 'actionParamType', user );
-    return resolvePath( ref, 'type', user );
-  }
-
-  function getCardinality( assoc ) {
-    while (assoc?._effectiveType) {
-      // if (--depth) throw Error(`GCARD: ${ Object.keys(art) }`)
-      if (assoc.cardinality)
-        return assoc.cardinality;
-      assoc = getOrigin( assoc );
+  function getInheritedProp( art, prop ) {
+    while (art?._effectiveType) {
+      if (art[prop] !== undefined)
+        return art[prop];
+      art = getOrigin( art );
     }
-    return {};
+    return undefined;
   }
 
   function userQuery( user ) {
@@ -511,7 +500,7 @@ function populate( model ) {
   //--------------------------------------------------------------------------
 
   // TODO: delete XSN._entities
-  // TODO: delete ENTITY._from
+  // TODO: delete ENTITY._from - use _origin? instead _from[0]
   // TODO (after on-demand ext): delete XSN.$entity
 
   /**
@@ -533,8 +522,12 @@ function populate( model ) {
       const ielem = art.elements ? art.elements[id] : art.enum[id];  // inferred element
       const selem = art.elements$ ? art.elements$[id] : art.enum$[id]; // specified element
       if (!selem) {
-        info( 'query-missing-element', [ ielem.name.location, art ], { id },
-              'Element $(ID) is missing in specified elements' );
+        info( 'query-missing-element', [ ielem.name.location, art ], {
+          '#': ielem.kind === 'enum' ? 'enum' : 'std', id,
+        }, {
+          std: 'Element $(ID) is missing in specified elements',
+          enum: 'Enum $(ID) is missing in specified enum values',
+        } );
       }
       else {
         for (const prop in selem) {
@@ -543,8 +536,6 @@ function populate( model ) {
             ielem[prop] = selem[prop];
             // required for gensrc mode of to-csn.js, otherwise the annotation
             // may be lost during recompilation.
-            // TODO: Clarify: Should gensrc add this annotation to the column or as an
-            //       annotate statement? Currently it's at the column.
             ielem[prop].$priority = 'annotate';
             wasAnnotated = true;
           }
@@ -552,7 +543,7 @@ function populate( model ) {
             if (!ielem.typeProps$)
               setLink(ielem, 'typeProps$', Object.create(null));
             // Note: At this point in time, effectiveType() was likely not called on the
-            // element, yet. Setting it here, we can't compare it to it's value from _origin.
+            // element, yet. Setting it here, we can't compare it to its value from _origin.
             ielem.typeProps$[prop] = selem[prop];
           }
         }
@@ -602,17 +593,19 @@ function populate( model ) {
 
   function populateQuery( query ) {
     if (query._combined || !query.from || !query.$tableAliases)
-      // already done or $join query or parse error
+      // already done (TODO: re-check!) or $join query or parse error
       return query;
     setLink( query, '_combined', Object.create(null) );
     query.$inlines = [];
     forEachGeneric( query, '$tableAliases', resolveTabRef );
-
     initFromColumns( query, query.columns );
     if (query.excludingDict) {
       for (const name in query.excludingDict)
         resolveExcluding( name, query._combined, query.excludingDict, query );
     }
+    // TODO: should we to set some falsy values? E.g. with $self.*, cyclic from?
+    // Yes, when element names cannot fully be determined (wrong source ref,
+    // cyclic, ...)  BTW, similar with `includes`
     return query;
 
     function resolveTabRef( alias ) {
@@ -652,10 +645,11 @@ function populate( model ) {
       return null;
     // If we allow CDL-style casts of `expand`s to associations in the future, we
     // need to ignore an explicit type, i.e. not getOrigin():
-    const assoc = resolvePath( elem.value, 'expr', elem ); // TODO: extra 'column'?
+    const assoc = resolvePath( elem.value, 'column', elem );
     if (!effectiveType( assoc )?.target)
       return initFromColumns( elem, elem.expand );
-    const { targetMax } = path[path.length - 1].cardinality || getCardinality( assoc );
+    const { targetMax } = path[path.length - 1].cardinality ||
+                          getInheritedProp( assoc, 'cardinality' ) || {};
     if (targetMax && (targetMax.val === '*' || targetMax.val > 1)) {
       elem.items = { location: elem.expand[$location] };
       setLink( elem.items, '_outer', elem );
@@ -666,9 +660,9 @@ function populate( model ) {
   // TODO: make this function shorter - make part of this (e.g. setting
   // parent/name) also be part of definer.js
   // TODO: query is actually the elemParent, where the new elements are added to
-  // top-level: just query, columns
-  // inline: + elements (TODO: remove), colParent
-  // expand: just query (which is a column/element), columns=array of expand
+  // top-level: ( query, query.columns )
+  // inline: ( queryOrColParent, col.inline, col )
+  // expand: ( col, col.expand )
   function initFromColumns( query, columns, inlineHead = undefined ) {
     const elemsParent = query.items || query;
     if (!inlineHead) {
@@ -677,7 +671,11 @@ function populate( model ) {
         query._main.elements = elemsParent.elements;
     }
 
-    for (const col of columns || [ { val: '*' } ]) {
+    if (!columns)
+      columns = [ { val: '*' } ];
+
+    for (let i = 0; i < columns.length; ++i) {
+      const col = columns[i];
       if (col.val === '*') {
         const siblings = wildcardSiblings( columns, query );
         expandWildcard( col, siblings, inlineHead, query );
@@ -689,15 +687,16 @@ function populate( model ) {
         col.kind = '$inline';
         col.name = {};
         // a name for this internal symtab entry (e.g. '.2' to avoid clashes
-        // with real elements) is only relevant for for `cdsc -R`/debugging
+        // with real elements) is only relevant for `cdsc -R`/debugging
         const q = userQuery( query );
         q.$inlines.push( col );
+        dependsOnSilent( q, col );
         // or use userQuery( query ) in the following, too?
         setMemberParent( col, `.${ q.$inlines.length }`, query );
         initFromColumns( query, col.inline, col );
       }
       else if (!col.$replacement) {
-        const id = ensureColumnName( col, query );
+        const id = ensureColumnName( col, i, query );
         col.kind = 'element';
         dictAdd( elemsParent.elements, id, col, ( name, location ) => {
           error( 'duplicate-definition', [ location, query ], { name, '#': 'element' } );
@@ -710,25 +709,36 @@ function populate( model ) {
   }
 
   // TODO: probably do this already in definer.js
-  function ensureColumnName( col, query ) {
+  function ensureColumnName( col, colIndex, query ) {
     if (col.name)
       return col.name.id;
     if (col.inline || col.val === '*')
       return '';
     const path = col.value &&
-        (col.value.path || !col.value.args && col.value.func && col.value.func.path);
-    if (path && path.length) {
-      const last = !path.broken && path.length && path[path.length - 1];
+        (col.value.path || !col.value.args && col.value.func?.path);
+    if (path) {
+      const last = path.length && !path.broken && path[path.length - 1];
       if (last) {
         col.name = { id: last.id || '', location: last.location, $inferred: 'as' };
         return col.name.id;
       }
     }
-    else if (col.value || col.expand) {
-      error( 'query-req-name', [ col.value && col.value.location || col.location, query ], {},
+    else if (col.expand || col.value && (col._pathHead || query._parent.kind !== 'select')) {
+      // _pathHead => inline/expand; _parent -> only allowed in sub-selects
+      error( 'query-req-name', [ col.value?.location || col.location, query ], {},
              'Alias name is required for this select item' );
     }
-    // invent a name for code completion in expression
+    else if (col.value) {
+      col.name = {
+        // NOTE: If the alias is changed, corresponding name-clash tests must be updated as well!
+        id: `$_column_${ colIndex + 1 }`,
+        location: col.value.location || col.location,
+        $inferred: '$internal',
+      };
+      col.$inferred = '$internal';
+      return col.name.id;
+    }
+    // invent a name for code completion in expression, see also #10596
     col.name = {
       id: '',
       location: col.value && col.value.location || col.location,
@@ -768,8 +778,9 @@ function populate( model ) {
       return siblings;
 
     let seenWildcard = null;
+    let colIndex = 0;
     for (const col of columns) {
-      const id = ensureColumnName( col, query );
+      const id = ensureColumnName( col, colIndex, query );
       if (id) {
         col.$replacement = !seenWildcard;
         siblings[id] = !(id in siblings) && col;
@@ -777,6 +788,7 @@ function populate( model ) {
       else if (col.val === '*') {
         seenWildcard = true;
       }
+      ++colIndex;
     }
     return siblings;
   }
@@ -788,10 +800,13 @@ function populate( model ) {
     const inferred = query._main.$inferred;
     const excludingDict = (colParent || query).excludingDict || Object.create(null);
 
-    const envParent = wildcard._pathHead; // TODO: rename _pathHead to _pathEnv
+    const envParent = wildcard._pathHead; // TODO: rename _pathHead to _columnParent
     // console.log('S1:',location.line,location.col,
     //             envParent&&!!envParent._origin&&envParent._origin.name)
-    const env = columnEnv( envParent, query );
+    const env = wildcardColumnEnv( wildcard, query );
+    if (!env)
+      return;
+
     // if (envParent) console.log('S2:',location.line,location.col,
     //             envParent?.name,envParent?._origin?.name,
     //             Object.keys(env),Object.keys(elements))
@@ -851,14 +866,25 @@ function populate( model ) {
     }
   }
 
-  function columnEnv( envParent, query ) { // etc.  wildcard._pathHead;
+  function wildcardColumnEnv( wildcard, query ) { // etc.  wildcard._pathHead;
     // if (envParent) console.log( 'CE:', envParent._origin, query );
-    if (!envParent)
-      return userQuery( query )._combined;
-    const env = navigationEnv( getOrigin( envParent ) );
-    if (env === 0)
-      return 0;
-    return env?.elements || Object.create(null);
+    const colParent = wildcard._pathHead;
+    if (!colParent)
+      return userQuery( query )._combined; // see combinedSourcesOrParentElements
+
+    const head = resolvePath( colParent.value, 'column', colParent );
+    // eslint-disable-next-line no-nested-ternary
+    if (!head
+        ? !columnRefStartsWithSelf( colParent )
+        : head._main
+          ? userQuery( head ) !== userQuery( query )
+          : head._main !== query._main)
+      return nestedElements( wildcard );
+
+    error( 'def-unexpected-wildcard', [ wildcard.location, colParent ], { code: '*' },
+           'Unexpected $(CODE) (wildcard) after $self/association to self reference' );
+    model.$assert = null;       // explains cyclic dependencies
+    return null;
   }
 
   function reportReplacement( sibling, navElem, query ) {
@@ -902,7 +928,7 @@ function populate( model ) {
   function setElementOrigin( queryElem, navElem, name, location ) {
     const sourceElem = navElem._origin;
     const alias = navElem._parent;
-    // always expand * to path with table alias (reason: columns current_date etc)
+    // always expand * to path with table alias (reason: columns $user etc)
     const path = [ { id: alias.name.id, location }, { id: name, location } ];
     queryElem.value = { path, location };
     setLink( path[0], '_navigation', alias );
@@ -931,7 +957,7 @@ function populate( model ) {
     // TODO: Custom kind?
     if (elem.$isSpecifiedElement)
       return false;
-    const assocTarget = resolvePath( assoc.target, 'target', assoc );
+    const assocTarget = assoc.target._artifact;
     let target = assocTarget;
     // console.log( info( null, [ elem.location, elem ], {target,art:assoc,name:''+assoc.target},
     //              'RED').toString())
@@ -1139,9 +1165,10 @@ function populate( model ) {
   function isDirectProjection( proj, base ) {
     return proj.kind === 'entity' && // not event
       // direct proj (TODO: or should we add them to another list?)
+      // TODO: delete ENTITY._from
       proj.query && proj.query.op && proj.query.op.val === 'SELECT' &&
       proj._from && proj._from.length === 1 &&
-      base === resolvePath( proj._from[0], 'from', proj );
+      base === resolvePath( proj._from[0], 'from', proj.query );
   }
 
   // Auto-exposure -----------------------------------------------------------
@@ -1152,7 +1179,8 @@ function populate( model ) {
       return target.$autoexpose;
     const origTarget = target;
     const chain = [];
-    let source = target._from && resolvePath( target._from[0], 'from', target );
+    const alias1 = target._from?.[0]; // TODO: delete ENTITY._from ?
+    let source = alias1 && resolvePath( alias1, 'from', alias1._parent );
     // query source ref might not have been resolved yet, cycle avoided as
     // setAutoExposed() sets $autoexpose and a second call on same art would
     // return false
@@ -1160,7 +1188,8 @@ function populate( model ) {
       // stop at first ancestor with annotation or at non-query entity
       chain.push( target );
       target = source;
-      source = target._from && resolvePath( target._from[0], 'from', target );
+      const alias = target._from?.[0]; // TODO: delete ENTITY._from ?
+      source = alias && resolvePath( alias, 'from', alias._parent );
     }
     const autoexpose = target.$autoexpose;
     if (typeof autoexpose === 'boolean') {

package/lib/compiler/propagator.js

@@ -159,7 +159,8 @@ function propagate( model ) {
           (!target.type.$inferred || target.type.$inferred === 'cast');
     const keys = Object.keys( source );
     for (const prop of keys) {
-      if (prop in target)       // TODO: warning with competing props from multi-includes
+      // TODO: warning with competing props from multi-includes
+      if (target[prop] !== undefined || source[prop] === undefined)
         continue;
       const transformer = props[prop] || props[prop.charAt(0)];
       if (transformer)
@@ -174,9 +175,9 @@ function propagate( model ) {
       while (elem._parent.kind === 'element')
         elem = elem._parent;
       if (elem !== source) {
-        if (!('notNull' in target) && ('notNull' in elem))
+        if (target.notNull === undefined && elem.notNull !== undefined)
           props.notNull( 'notNull', target, elem );
-        if (!('virtual' in target) && ('virtual' in elem))
+        if (target.virtual === undefined && elem.virtual !== undefined)
           props.virtual( 'virtual', target, elem );
       }
     }