@sap/cds-compiler 3.9.4 → 4.0.0

package/lib/compiler/populate.js

@@ -45,10 +45,24 @@ const {
   setExpandStatus,
   setExpandStatusAnnotate,
 } = require('./utils');
+const { typeParameters } = require('./builtins');
 
 const $inferred = Symbol.for('cds.$inferred');
 const $location = Symbol.for('cds.$location');
 
+/**
+ * These properties are copied from specified elements.
+ */
+const typePropertiesFromSpecifiedElements = {
+  // 'key' is special case, see setSpecifiedElementTypeProperties()
+  // TODO: Decide on behavior if an actual key does not have "key" property in specified elements,
+  //       and another non-key is marked key in them.
+  // key: 'if-undefined',
+  default: 1,
+  notNull: 1,
+  localized: 1,
+  ...typeParameters.expectedLiteralsFor,
+};
 
 // Export function of this file.
 function populate( model ) {
@@ -64,11 +78,11 @@ function populate( model ) {
     extendArtifactBefore,
     extendArtifactAfter,
   } = model.$functions;
-  model.$volatileFunctions.environment = environment;
   Object.assign( model.$functions, {
     effectiveType,
     getOrigin,
     resolveType,
+    navigationEnv,
   } );
   // let depth = 100;
 
@@ -113,17 +127,8 @@ function populate( model ) {
   //--------------------------------------------------------------------------
   // Phase 2: call effectiveType() on-demand, which also calculates view elems
 
-  // Return effective search environment provided by artifact `art`, i.e. the
-  // `artifacts` or `elements` dictionary.  For the latter, follow the `type`
-  // chain and resolve the association `target`.  View elements are calculated
-  // on demand.
-  function environment( art, location, user, assocSpec ) {
-    const env = navigationEnv( art, location, user, assocSpec );
-    if (env === 0)
-      return 0;
-    return env && env.elements || Object.create(null);
-  }
-
+  // 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
@@ -132,7 +137,7 @@ function populate( model ) {
     let type = effectiveType( art );
     while (type?.items)          // TODO: disallow navigation to many sometimes
       type = effectiveType( type.items );
-    if (!type?.target)
+    if (!type?.target || assocSpec === 'targetAspectOnly')
       return type;
 
     if (assocSpec === false) {
@@ -215,12 +220,14 @@ function populate( model ) {
       // Without type, value.path or _origin at beginning, link to itself:
       extendArtifactBefore( a );
       art = populateArtifact( a, art ) || a;
-      if (a.elements$ || a.enum$)
-        mergeSpecifiedElementsOrEnum( a );
       setLink( a, '_effectiveType', art );
       a.$effectiveSeqNo = ++effectiveSeqNo;
+      if (a.elements$ || a.enum$)
+        mergeSpecifiedElementsOrEnum( a );
       // console.log( 'ET-DO:', effectiveSeqNo, a?.kind, a?.name, a._extensions?.elements?.length )
       extendArtifactAfter( a ); // after setting _effectiveType (for messages)
+      if (a.typeProps$)
+        setSpecifiedElementTypeProperties(a);
     }
     // console.log( 'ET-END:', art?.kind, art?.name )
     return art;
@@ -241,6 +248,9 @@ function populate( model ) {
       if (!art.expand)
         return art;
     }
+    else if (art.targetAspect) { // target aspect in aspect
+      return art;
+    }
 
     // With properties to be calculated: ----------------------------------------
     if (art.query && art.kind !== '$tableAlias') { // query entity
@@ -313,19 +323,21 @@ function populate( model ) {
         return getOrigin( art.$queries?.[0] );
     }
     else {
+      // TODO: write checks for path in enum?
       if (art.value?.path)
-        return resolvePath( art.value, 'expr', art, null );
+        return resolvePath( art.value, (art.$syntax === 'calc' ? 'calc' : 'expr'), art );
       if (art.kind === 'select')
         return getOrigin( dictFirst( art.$tableAliases ) );
       // 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 would have a deeper callstack
+        // source → we would have a deeper callstack
         const source = resolvePath( art, 'from', art._parent );
         if (!source?._main)
           return source;        // direct entity (or undefined)
         // Before having done the resolvePath cleanup, do not rely on resolvePath
         // 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 );
       }
@@ -338,25 +350,6 @@ function populate( model ) {
       return ref._artifact;
     while (user._outer)         // in items
       user = user._outer;
-    if (ref.scope === 'typeOf') {
-      let struct = user;
-      while (struct.kind === 'element')
-        struct = struct._parent;
-      if (struct.kind === 'select' || struct.kind === 'annotation') {
-        // `type of` in annotation definitions can't work, because csn type refs
-        // always refer to definitions.
-        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( 'type-unexpected-typeof', [ ref.location, user ],
-                 { keyword: 'type of', '#': struct.kind } );
-        return setArtifactLink( ref, null );
-      }
-      return resolvePath( ref, 'typeOf', user );
-    }
     if (user.kind === 'event')
       return resolvePath( ref, 'eventType', user );
     if (user.kind === 'param' && user._parent &&
@@ -525,8 +518,7 @@ function populate( model ) {
    * Merge _specified_ elements with _inferred_ elements in the given view/element,
    * where specified elements can appear through CSN.
    *
-   * We only copy annotations, since they are not part of `columns`,
-   * but only appear in `elements` in CSN.
+   * We only copy annotations.
    *
    * This is important to ensure re-compilability.
    *
@@ -535,6 +527,8 @@ function populate( model ) {
    * @param art
    */
   function mergeSpecifiedElementsOrEnum( art ) {
+    let wasAnnotated = false;
+
     for (const id in (art.elements || art.enum)) {
       const ielem = art.elements ? art.elements[id] : art.enum[id];  // inferred element
       const selem = art.elements$ ? art.elements$[id] : art.enum$[id]; // specified element
@@ -543,44 +537,69 @@ function populate( model ) {
               'Element $(ID) is missing in specified elements' );
       }
       else {
-        let wasAnnotated = false;
         for (const prop in selem) {
           // just annotation assignments and doc comments for the moment
           if (prop.charAt(0) === '@' || prop === 'doc') {
             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;
           }
+          else if (typePropertiesFromSpecifiedElements[prop]) {
+            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.
+            ielem.typeProps$[prop] = selem[prop];
+          }
         }
 
-        if (wasAnnotated)
-          setExpandStatusAnnotate(art, 'annotate');
-
         selem.$replacement = true;
-        if (selem.elements) {
+        if (selem.elements)
           setLink(ielem, 'elements$', selem.elements);
-          delete selem.elements;
-        }
-        if (selem.enum) {
+        if (selem.enum)
           setLink(ielem, 'enum$', selem.enum);
-          delete selem.enum;
-        }
       }
     }
+
+    if (wasAnnotated)
+      setExpandStatusAnnotate(art, 'annotate');
+
     // TODO: We don't check enum$, yet! We first need to fix expansion for
     //       `cast(elem as EnumType)` (see #9421)
     for (const id in art.elements$) {
-      const selem = art.elements$[id]; // specified element
-      if (!selem.$replacement) {
-        // console.log( 'QED:', art.name, art.kind, art.elements )
-        error( 'query-unspecified-element', [ selem.name.location, selem ], { id },
+      const specifiedElement = art.elements$[id];
+      // TODO: Custom kind?
+      specifiedElement.$isSpecifiedElement = true;
+      if (!specifiedElement.$replacement) {
+        const loc = [ specifiedElement.name.location, specifiedElement ];
+        error( 'query-unspecified-element', loc, { id },
                'Element $(ID) does not result from the query' );
       }
     }
   }
 
+  function setSpecifiedElementTypeProperties( art ) {
+    for (const prop in art.typeProps$) {
+      let o = art;
+      if (o._effectiveType !== 0) { // cyclic
+        while (!o[prop] && getOrigin(o))
+          o = getOrigin(o);
+      }
+
+      if (typePropertiesFromSpecifiedElements[prop] === 'if-undefined') {
+        if (!o[prop])
+          art[prop] = art.typeProps$[prop];
+      }
+      else if (!o[prop] || art.typeProps$[prop].val !== o[prop]?.val) {
+        art[prop] = art.typeProps$[prop];
+      }
+    }
+  }
+
   function populateQuery( query ) {
     if (query._combined || !query.from || !query.$tableAliases)
       // already done or $join query or parse error
@@ -633,7 +652,7 @@ 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, null );
+    const assoc = resolvePath( elem.value, 'expr', elem ); // TODO: extra 'column'?
     if (!effectiveType( assoc )?.target)
       return initFromColumns( elem, elem.expand );
     const { targetMax } = path[path.length - 1].cardinality || getCardinality( assoc );
@@ -727,8 +746,10 @@ function populate( model ) {
       return;
     }
     if (!elem.type && elem.value?.type) {  // top-level CAST( expr AS type )
-      if (!elem.target)   // TODO: we might issue an error if there is a target
+      if (!elem.target) {  // TODO: we might issue an error if there is a target
         elem.type = { ...elem.value.type, $inferred: 'cast' };
+        // TODO: What about other direct properties in cast such as items/enum/...?
+      }
     }
     if (elem.foreignKeys)       // REDIRECTED with explicit foreign keys
       forEachGeneric( elem, 'foreignKeys', (key, name) => initKey( key, name, elem ) );
@@ -832,9 +853,12 @@ function populate( model ) {
 
   function columnEnv( envParent, query ) { // etc.  wildcard._pathHead;
     // if (envParent) console.log( 'CE:', envParent._origin, query );
-    return (envParent)
-      ? environment( getOrigin( envParent ) ) // not the col with expand, but the referred
-      : userQuery( query )._combined;
+    if (!envParent)
+      return userQuery( query )._combined;
+    const env = navigationEnv( getOrigin( envParent ) );
+    if (env === 0)
+      return 0;
+    return env?.elements || Object.create(null);
   }
 
   function reportReplacement( sibling, navElem, query ) {
@@ -903,13 +927,17 @@ function populate( model ) {
     // PRE: elem has no target, assoc has target prop
     if (elem.kind === '$tableAlias')
       return false;
+    // Specified elements could lead to warnings that seem unfixable by the user.
+    // TODO: Custom kind?
+    if (elem.$isSpecifiedElement)
+      return false;
     const assocTarget = resolvePath( assoc.target, 'target', assoc );
     let target = assocTarget;
     // console.log( info( null, [ elem.location, elem ], {target,art:assoc,name:''+assoc.target},
     //              'RED').toString())
     if (!target)
       return false;             // error in target ref
-    const { location } = elem.value || elem.type || elem.name;
+    const { location } = elem.value || elem.type || elem.name || elem;
     const service = (elem._main || elem)._service;
     if (service && service !== target._service && assocIsToBeRedirected( elem )) {
       if (service !== (assoc._main || assoc)._service ||
@@ -920,36 +948,9 @@ function populate( model ) {
     if (elem === assoc) {    // redirection of user-provided target
       if (assocTarget === 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, // necessary for rewrite, '$user-provided' would be best
-        name: elem.name,
-        type: {                 // TODO: necessary?
-          path: [ { id: type.name.absolute, location: elem.type.location } ],
-          scope: 'global',
-          location: elem.type.location,
-          $inferred: 'REDIRECTED',
-        },
-        target: elem.target,
-        $inferred: 'REDIRECTED',
-        location: elem.target.location,
-      };
-      setLink( elem, '_origin', origin );
-      setArtifactLink( elem.type, type );
-      setLink( origin, '_outer', elem );
-      setLink( origin, '_parent', elem._parent );
-      if (elem._main)           // remark: the param `elem` can also be a type
-        setLink( origin, '_main', elem._main );
-      setLink( origin, '_effectiveType', origin );
-      setLink( origin, '_block', elem._block );
-      if (elem.foreignKeys) {
-        origin.foreignKeys = elem.foreignKeys;
-        delete elem.foreignKeys; // will be rewritten
-      }
-      if (elem.on) {
-        origin.on = elem.on;
-        delete elem.on;         // will be rewritten
-      }
+      elem.target.$inferred = '';
+      setArtifactLink( elem.target, target );
+      return true;
     }
     if (target !== assocTarget)
       setExpandStatus( elem, 'target' ); // (might) also set in rewriteCondition
@@ -1235,22 +1236,22 @@ function populate( model ) {
         }
         return autoexposed;
       }
-      error( 'duplicate-autoexposed', [ service.name.location, service ],
-             { target, art: absolute },
-             'Name $(ART) of auto-exposed entity for $(TARGET) collides with other definition' );
+      message( 'def-duplicate-autoexposed', [ service.name.location, service ],
+               { target, art: absolute },
+               'Name $(ART) of auto-exposed entity for $(TARGET) collides with other definition' );
       info( null, [ target.name.location, target ],
             { art: service },
             'Expose this (or the competing) entity explicitly in service $(ART)' );
       if (autoexposed.$inferred !== 'autoexposed')
         return target;
       const firstTarget = autoexposed.query.from._artifact;
-      error( 'duplicate-autoexposed', [ service.name.location, service ],
-             { target: firstTarget, art: absolute },
-             'Name $(ART) of auto-exposed entity for $(TARGET) collides with other definition' );
+      message( 'def-duplicate-autoexposed', [ service.name.location, service ],
+               { target: firstTarget, art: absolute },
+               'Name $(ART) of auto-exposed entity for $(TARGET) collides with other definition' );
       info( null, [ firstTarget.name.location, firstTarget ],
             { art: service },
             'Expose this (or the competing) entity explicitly in service $(ART)' );
-      autoexposed.$inferred = 'duplicate-autoexposed';
+      autoexposed.$inferred = 'def-duplicate-autoexposed';
       return target;
     }
     // console.log(absolute)

package/lib/compiler/propagator.js

@@ -13,7 +13,6 @@ const {
   forEachMember,
   forEachGeneric,
   isDeprecatedEnabled,
-  isBetaEnabled,
 } = require( '../base/model');
 const {
   setLink,
@@ -43,8 +42,8 @@ function propagate( model ) {
     '@cds.external': never,
     '@cds.redirection.target': never,
     '@fiori.draft.enabled': onlyViaArtifact,
-    '@': annotation,            // always except in 'items'
-    doc: annotation,            // always except in 'items'
+    '@': annotation,            // always except in 'items' (and parameters for entity return types)
+    doc: annotation,            // always except in 'items' (and parameters for entity return types)
     default: withKind,          // always except in 'items'
     virtual,
     notNull,
@@ -74,7 +73,6 @@ function propagate( model ) {
   // eslint-disable-next-line max-len
   const oldVirtualNotNullPropagation = isDeprecatedEnabled( options, '_oldVirtualNotNullPropagation' );
   const { warning, throwWithError } = model.$messageFunctions;
-  const propagateToReturns = isBetaEnabled( options, 'v4preview' );
 
   forEachDefinition( model, run );
 
@@ -157,7 +155,7 @@ function propagate( model ) {
 
   function step({ target, source }) {
     // console.log('PROPS:',source&&source.name,'->',target.name)
-    const viaType = target.type && // TODO: falsy $inferred value instead 'cast'?
+    const viaType = target.type && // TODO: falsy $inferred value instead of 'cast'?
           (!target.type.$inferred || target.type.$inferred === 'cast');
     const keys = Object.keys( source );
     for (const prop of keys) {
@@ -279,13 +277,14 @@ function propagate( model ) {
     const from = viewFromPrimary( target )?.path;
     // do not propagate from member / if follow assoc in from or into `returns` of actions (v4)
     if (!(from ? from[from.length - 1]._artifact : source)._main &&
-       !(propagateToReturns && target._parent && target._parent.returns === target))
+       !(target._parent && target._parent.returns === target))
       annotation( prop, target, source );
   }
 
   function withKind( prop, target, source ) {
-    if (target.kind &&
-      (propagateToReturns || !target._parent || target._parent.returns !== target))
+    if (target.kind === 'param' && source.kind === 'entity')
+      return; // Don't propagate from entity types to parameters (+ return type).
+    if (target.kind)
       always(prop, target, source); // not in 'items'
   }