@sap/cds-compiler 4.3.2 → 4.4.2

package/lib/compiler/checks.js

@@ -214,6 +214,7 @@ function check( model ) {
 
     // TODO: This check should be moved to localized.js
     // "key" keyword at localized element in SELECT list.
+    // TODO: not in inferred elements, but also inside aspects
     if (elem.key?.val && elem._main?.query) {
       // original element is localized but not key, as that would have
       // already resulted in a warning by localized.js
@@ -459,7 +460,7 @@ function check( model ) {
           error( 'ref-unexpected-calculated', [ key.location, elem ], { '#': 'fkey' } );
       }
     }
-    if (elem.default) {
+    if (elem.default?.val !== undefined) {
       if (elem.targetAspect || elem.on || fkCount !== 1) {
         const variant = (elem.targetAspect && 'targetAspect') || (elem.on && 'onCond') || 'multi';
         error( 'type-unexpected-default', [ elem.default.location, elem ], {
@@ -852,7 +853,7 @@ function check( model ) {
 
     // Element must exist in annotation
     if (!elementDecl) {
-      warning( null, [ anno.location || anno.name.location, art ],
+      warning( null, [ anno.location || anno.name.location, art, anno ],
                { name: anno.name.id, anno: annoDecl.name.id },
                'Element $(NAME) not found for annotation $(ANNO)' );
       return;
@@ -866,11 +867,11 @@ function check( model ) {
     // Must have literal or path unless it is a boolean
     if (!anno.literal && !anno.path && elementDecl._effectiveType?.category !== 'boolean') {
       if (elementDecl.type?._artifact) {
-        warning( 'anno-expecting-value', [ anno.location || anno.name.location, art ],
+        warning( 'anno-expecting-value', [ anno.location || anno.name.location, art, anno ],
                  { '#': 'type', type: elementDecl.type._artifact } );
       }
       else {
-        warning( 'anno-expecting-value', [ anno.location || anno.name.location, art ],
+        warning( 'anno-expecting-value', [ anno.location || anno.name.location, art, anno ],
                  { '#': 'std', anno: anno.name.id } );
       }
 
@@ -891,7 +892,7 @@ function check( model ) {
       return;
 
     const anno = annoDef.name.id;
-    const loc = [ value.location || value.name.location, art ];
+    const loc = [ value.location || value.name.location, art, annoDef ];
 
     // Array expected?
     if (elementDecl._effectiveType.items) {

package/lib/compiler/define.js

@@ -136,7 +136,7 @@ const {
   storeExtension,
   dependsOnSilent,
   pathName,
-  isDirectComposition,
+  targetCantBeAspect,
 } = require('./utils');
 const { compareLayer } = require('./moduleLayers');
 const { initBuiltins, isInReservedNamespace } = require('./builtins');
@@ -313,7 +313,6 @@ function define( model ) {
       artifacts[using] = {
         kind: 'using',          // !, not namespace - we do not know artifact yet
         name: { id: using, location, $inferred: 'as' },
-        // TODO: use global ref (in general - all uses of splitIntoPath)
         extern: { location, id: absolute },
         location,
         $inferred: 'path-prefix',
@@ -564,7 +563,7 @@ function define( model ) {
     initMembers( art, art, block );
     initDollarSelf( art );      // $self
     if (art.params)
-      initDollarParameters( art );
+      initDollarParameters( art ); // $parameters
 
     if (!art.query)
       return;
@@ -1199,7 +1198,7 @@ function define( model ) {
 
   // To be reworked -------------------------------------------------------------
 
-  // TODO: make special for extend/annotate
+  // TODO: is only necessary for extensions - make special for extend/annotate
   function checkDefinitions( construct, parent, prop, dict = construct[prop] ) {
     // TODO: do differently, see also annotateMembers() in resolver
     // To have been checked by parsers:
@@ -1227,7 +1226,7 @@ function define( model ) {
     //
     else if (parent.kind === 'action' || parent.kind === 'function') {
       error( 'ext-unexpected-action', [ construct.location, construct ], { '#': parent.kind }, {
-        std: 'Actions and functions can\'t be extended, only annotated',
+        std: 'Actions and functions can\'t be extended, only annotated', // TODO: → ext-unsupported
         action: 'Actions can\'t be extended, only annotated',
         function: 'Functions can\'t be extended, only annotated',
       } );
@@ -1277,17 +1276,20 @@ function define( model ) {
 
   /**
    * Return whether the `target` is actually a `targetAspect`
-   * TODO: really do that here and not in kick-start.js?
    */
   function targetIsTargetAspect( elem ) {
     const { target } = elem;
-    if (target.elements) {
-      // TODO: error if CSN has both target.elements and targetAspect.elements
-      // -> delete target
+    if (target.elements)        // CSN parser ensures: has no targetAspect then
       return true;
+
+    if (elem.targetAspect) {
+      // Ensure that a compiled CSN is parseable - not inside query, only on element
+      return false;
     }
-    if (elem.targetAspect || options.parseCdl || !isDirectComposition( elem ))
+    if (targetCantBeAspect( elem ) || options.parseCdl)
       return false;
+    // Compare this check with check in acceptEntity() called by resolvePath()
+    // Remark:  do not check `on` and `foreignKeys` here, we want error for those, not the aspect
     const name = resolveUncheckedPath( target, 'target', elem );
     const aspect = name && model.definitions[name];
     return (aspect?.kind === 'aspect' || aspect?.kind === 'type') && // type is sloppy

package/lib/compiler/extend.js

@@ -2,7 +2,7 @@
 
 'use strict';
 
-const { weakLocation } = require('../base/location');
+const { weakRefLocation } = require('../base/location');
 const { searchName } = require('../base/messages');
 const {
   forEachInOrder,
@@ -31,7 +31,22 @@ const $location = Symbol.for( 'cds.$location' );
 // attach stupid location - TODO: remove in v5
 const genLocation = new CsnLocation( '' );
 
-// Array.prototype.spread = 42;   // prototype-polluted JS classes
+const draftElements = [
+  'IsActiveEntity',
+  'HasActiveEntity',
+  'HasDraftEntity',
+  'DraftAdministrativeData',
+  'SiblingEntity',
+];
+const draftBoundActions = [
+  'draftPrepare',
+  'draftActivate',
+  'draftEdit',
+];
+
+function canBeDraftMember( name, parent, draftMembers ) {
+  return parent?.kind === 'entity' && parent._service && draftMembers.includes( name );
+}
 
 function extend( model ) {
   // Get simplified "resolve" functionality and the message function:
@@ -686,21 +701,15 @@ function extend( model ) {
     }
   }
 
-  // const unexpected_props = {
-  //   elements: 'anno-unexpected-elements',
-  //   enum: 'anno-unexpected-elements', // TODO
-  //   params: 'anno-unexpected-params',
-  //   actions: 'anno-unexpected-actions',
-  // };
-  // const undefined_props = {
-  //   elements: 'anno-undefined-element',
-  //   enum: 'anno-undefined-element', // TODO
-  //   params: 'anno-undefined-param',
-  //   actions: 'anno-undefined-action',
-  // };
-
   function checkRemainingMemberExtensions( parent, ext, prop, name ) {
     // console.log('CRME:',prop,name,parent,ext)
+
+    // TODO: just use `ext-undefined-element` etc also when no elements are there
+    // at all (but use an extra text variant and the `{…}` location).  Reason: we
+    // might allow to add new actions, and an `annotate` on an undefined action
+    // should not lead to another message id.  We would use and extra message id
+    // if we consider this an error or such sub annotates are then ignored
+    // (i.e. not put into the "super annotate").
     const dict = parent[prop];
     if (!dict) {
       // TODO: check - for each name? - better locations
@@ -714,6 +723,9 @@ function extend( model ) {
                    { '#': (parent._effectiveType?.kind === 'entity') ? 'entity' : 'std' }, {
                      std: 'Elements only exist in entities, types or typed constructs',
                      entity: 'Elements of entity types can\'t be annotated',
+                     // TODO: extra msg for 'entity'? → this is some other
+                     // situation, somehow similar when trying to annotate elements
+                     // of target entity
                    } );
           break;
         case 'params':
@@ -721,8 +733,10 @@ function extend( model ) {
                    'Parameters only exist for actions or functions' );
           break;
         case 'actions':
-          // TODO: check if artifact can have actions, similar to `anno-unexpected-actions`
-          notFound( 'anno-undefined-action', ext.name.location, ext,
+          if (canBeDraftMember( name, parent, draftBoundActions ))
+            return true;
+          // TODO: use extra text variant and location of dictionary - no
+          notFound( 'ext-undefined-action', ext.name.location, ext,
                     { '#': 'action', art: parent, name } );
           break;
         default:
@@ -737,22 +751,26 @@ function extend( model ) {
       const art = inReturns || parent;
       switch (prop) {
         case 'elements':
-          notFound( 'anno-undefined-element', ext.name.location, ext,
+          if (canBeDraftMember( name, parent, draftElements ))
+            break;
+          notFound( 'ext-undefined-element', ext.name.location, ext,
                     { '#': (inReturns ? 'returns' : 'element'), art, name },
                     parent.elements );
           break;
         case 'enum':            // TODO: extra msg id?
-          notFound( 'anno-undefined-element', ext.name.location, ext,
+          notFound( 'ext-undefined-element', ext.name.location, ext,
                     { '#': (inReturns ? 'enum-returns' : 'enum'), art, name },
                     parent.enum );
           break;
         case 'params':
-          notFound( 'anno-undefined-param', ext.name.location, ext,
+          notFound( 'ext-undefined-param', ext.name.location, ext,
                     { '#': 'param', art: parent, name },
                     parent.params );
           break;
         case 'actions':
-          notFound( 'anno-undefined-action', ext.name.location, ext,
+          if (canBeDraftMember( name, parent, draftBoundActions ))
+            break;
+          notFound( 'ext-undefined-action', ext.name.location, ext,
                     { '#': 'action', art: parent, name },
                     parent.actions );
           break;
@@ -1153,8 +1171,10 @@ function extend( model ) {
     // Warning 'Overwrites definition from include "I" (at elem def)
     const parent = ext === art && art;
     const members = ext[prop];
-    if (members)
+    if (members) {
       ext[prop] = Object.create( null );
+      ext[prop][$location] = members[$location];
+    }
     let hasNewElement = false;
 
     for (const ref of ext.includes) {
@@ -1162,6 +1182,7 @@ function extend( model ) {
       if (template) {           // be robust
         if (template[prop] && !ext[prop])
           ext[prop] = Object.create( null );
+        const location = weakRefLocation( ref );
         // eslint-disable-next-line no-loop-func
         forEachInOrder( template, prop, ( origin, name ) => {
           if (members && members[name]) {
@@ -1170,7 +1191,7 @@ function extend( model ) {
             return;
           }
           hasNewElement = true;
-          const elem = linkToOrigin( origin, name, parent, prop, weakLocation( ref.location ) );
+          const elem = linkToOrigin( origin, name, parent, prop, location );
           setLink( elem, '_block', origin._block );
           if (!parent) // not yet set for EXTEND foo WITH bar => linkToOrigin() did not add it
             dictAdd( ext[prop], name, elem );

package/lib/compiler/finalize-parse-cdl.js

@@ -86,7 +86,7 @@ function finalizeParseCdl( model ) {
       resolveUncheckedPath( include, 'include', main );
 
     // define.js takes care that `target` is a ref and
-    // `targetAspect` is a structure.
+    // `targetAspect` is a structure (anonymous aspect) or ref to aspect.
     if (artifact.target)
       resolveUncheckedPath( artifact.target, 'target', main );
     if (artifact.targetAspect)

package/lib/compiler/generate.js

@@ -17,7 +17,9 @@ const {
   isDirectComposition,
   copyExpr,
 } = require('./utils');
-const { weakLocation } = require('../base/location');
+const { weakLocation, weakRefLocation, weakEndLocation } = require('../base/location');
+
+const $location = Symbol.for( 'cds.$location' );
 
 function generate( model ) {
   const { options } = model;
@@ -220,6 +222,7 @@ function generate( model ) {
         warning( 'def-ignoring-localized', [ errpos.location, elem ],
                  { keyword: 'localized' },
                  'Keyword $(KEYWORD) is ignored for primary keys' );
+        // continuation semantics as stated: counts as key field in texts entity
       }
     }
     if (textElems.length <= keys)
@@ -277,11 +280,11 @@ function generate( model ) {
    * @param {boolean} fioriEnabled
    */
   function createTextsEntity( base, absolute, textElems, fioriEnabled ) {
-    const { location } = base.name;
+    const location = weakLocation( base.elements[$location] || base.location );
     const art = {
       kind: 'entity',
       name: { id: absolute, location },
-      location: base.location,
+      location,
       elements: Object.create( null ),
       $inferred: 'localized-entity',
     };
@@ -332,30 +335,8 @@ function generate( model ) {
     // assertUnique array value, first entry is 'locale'
     const assertUniqueValue = [];
 
-    for (const orig of textElems) {
-      const elem = linkToOrigin( orig, orig.name.id, art, 'elements' );
-      if (orig.key && orig.key.val) {
-        // elem.key = { val: fioriEnabled ? null : true, $inferred: 'localized', location };
-        // TODO: the previous would be better, but currently not supported in toCDL
-        if (!fioriEnabled) {
-          elem.key = { val: true, $inferred: 'localized', location };
-          // If the propagated elements remain key (that is not fiori.draft.enabled)
-          // they should be omitted from OData containment EDM
-          setAnnotation( elem, '@odata.containment.ignore', location );
-        }
-        else {
-          // add the former key paths to the unique constraint
-          assertUniqueValue.push({
-            path: [ { id: orig.name.id, location: orig.location } ],
-            location: orig.location,
-          });
-        }
-      }
-      if (hasTruthyProp( orig, 'localized' )) { // use location of LOCALIZED keyword
-        const localized = orig.localized || orig.type || orig.name;
-        elem.localized = { val: null, $inferred: 'localized', location: localized.location };
-      }
-    }
+    for (const orig of textElems)
+      addElementToTextsEntity( orig, art, fioriEnabled, assertUniqueValue );
 
     initArtifact( art );
     if (art.includes) {
@@ -366,7 +347,7 @@ function generate( model ) {
     if (fioriEnabled) {
       // The includes mechanism puts TextsAspect's elements before .texts' elements.
       // Because ID_texts is not copied from TextsAspect, the order is messed
-      // up.  Fix it.
+      // up.  Fix it.  TODO: introduce $includeAfter from Extensions.md
       const { elements } = art;
       art.elements = Object.create( null );
       const names = [ 'ID_texts', 'locale', ...Object.keys( elements ) ];
@@ -385,6 +366,31 @@ function generate( model ) {
     return art;
   }
 
+  function addElementToTextsEntity( orig, art, fioriEnabled, assertUniqueValue ) {
+    const elem = linkToOrigin( orig, orig.name.id, art, 'elements' );
+    // To keep the locations of non-inferred original elements, do not set $inferred:
+    if (orig.$inferred)
+      elem.$inferred = 'localized-origin';
+    const { location } = elem;
+    if (orig.key && orig.key.val) {
+      // elem.key = { val: fioriEnabled ? null : true, $inferred: 'localized', location };
+      // TODO: the previous would be better, but currently not supported in toCDL
+      if (!fioriEnabled) {
+        elem.key = { val: true, $inferred: 'localized', location };
+        // If the propagated elements remain key (that is not fiori.draft.enabled)
+        // they should be omitted from OData containment EDM
+        setAnnotation( elem, '@odata.containment.ignore', location );
+      }
+      else {
+        // add the former key paths to the unique constraint
+        assertUniqueValue.push( { path: [ { id: orig.name.id, location } ], location } );
+      }
+    }
+    if (hasTruthyProp( orig, 'localized' )) { // use location of LOCALIZED keyword
+      elem.localized = { val: null, $inferred: 'localized', location };
+    }
+  }
+
   /**
    * Enrich the `.texts` entity for the given base artifact.
    * In contrast to createTextsEntityWithDefaultElements(), this one creates
@@ -400,14 +406,15 @@ function generate( model ) {
   function enrichTextsEntityWithInclude( art, base, absolute, fioriEnabled ) {
     const textsAspectName = 'sap.common.TextsAspect';
     const textsAspect = model.definitions['sap.common.TextsAspect'];
-    const { location } = art.name;
+    const { location } = art;
 
-    art.includes = [ createInclude( textsAspectName, base.location ) ];
+    art.includes = [ createInclude( textsAspectName, location ) ];
 
     if (fioriEnabled) {
       // "Early" include; only for element `locale`, which has its `key` property
       // removed (or rather: it is not copied).
       linkToOrigin( textsAspect.elements.locale, 'locale', art, 'elements', location );
+      art.elements.locale.$inferred = 'localized';
     }
 
     if (addTextsLanguageAssoc && art.elements.language)
@@ -425,12 +432,13 @@ function generate( model ) {
     // If there is a type `sap.common.Locale`, then use it as the type for the element `locale`.
     // If not, use the default `cds.String` with a length of 14.
     const hasLocaleType = model.definitions['sap.common.Locale']?.kind === 'type';
-    const { location } = art.name;
+    const { location } = art;   // is already a weak location
     const locale = {
       name: { location, id: 'locale' },
       kind: 'element',
       type: linkMainArtifact( location, hasLocaleType ? 'sap.common.Locale' : 'cds.String' ),
       location,
+      $inferred: 'localized',   // $generated in Universal CSN, no $location
     };
     if (!hasLocaleType)
       locale.length = { literal: 'number', val: 14, location };
@@ -449,7 +457,7 @@ function generate( model ) {
     // texts : Composition of many Books.texts on texts.ID=ID;
     /** @type {array} */
     const keys = textElems.filter( e => e.key && e.key.val );
-    const { location } = art.name;
+    const location = weakEndLocation( art.elements[$location] ) || weakLocation( art.location );
     const texts = {
       name: { location, id: 'texts' },
       kind: 'element',
@@ -568,7 +576,7 @@ function generate( model ) {
       while (origin && !origin.targetAspect && origin._origin)
         origin = origin._origin;
       let target = origin.targetAspect;
-      if (target && target.path)
+      if (target?.path)
         target = resolvePath( origin.targetAspect, 'targetAspect', origin );
       if (!target || !target.elements)
         return;
@@ -601,7 +609,7 @@ function generate( model ) {
   function allowAspectComposition( target, elem, keys, entityName ) {
     if (!target.elements || Object.values( target.elements ).some( e => e.$duplicates ))
       return false;             // no elements or with redefinitions
-    const location = elem.target && elem.target.location || elem.location;
+    const location = elem.targetAspect?.location || elem.location;
     if ((elem._main._upperAspects || []).includes( target ))
       return 0;               // circular containment of the same aspect
 
@@ -648,16 +656,22 @@ function generate( model ) {
     if (elem.type && !isDirectComposition( elem )) {
       // Only issue warning for direct usages, not for projections, includes, etc.
       // TODO: Make it configurable error; v5: error
-      warning( 'def-expected-comp-aspect', [ elem.type.location, elem ],
-               { prop: 'Composition of', otherprop: 'Association to' },
-               'Expected $(PROP), but found $(OTHERPROP) for composition of aspect' );
+      // TODO: move to resolve.js where we test the targetAspect,
+      warning( 'type-expecting-composition', [ elem.type.location, elem ],
+               { newcode: 'Composition of', code: 'Association to' },
+               'Expecting $(NEWCODE), not $(CODE) for the anonymous target aspect' );
+      // auto-correct to avoid additional error 'type-unexpected-target-aspect' if
+      // cds.Association:
+      const { path, $inferred } = elem.type;
+      if (!$inferred && path?.length === 1 && path[0].id === 'cds.Association')
+        path[0].id = 'cds.Composition';
     }
 
     return true;
   }
 
   function createTargetEntity( target, elem, keys, entityName, base ) {
-    const { location } = elem.targetAspect || elem.target || elem;
+    const location = weakRefLocation( elem.targetAspect || elem.target || elem );
     elem.on = {
       location,
       op: { val: '=', location },
@@ -673,7 +687,7 @@ function generate( model ) {
       name: {
         id: entityName,
         // for code navigation (e.g. via `extend`s): point to the element's name
-        location: elem.name.location,
+        location: weakLocation( elem.name.location ),
       },
       location,
       elements: Object.create( null ),
@@ -690,18 +704,17 @@ function generate( model ) {
     }
 
     // Since there is no user-written up_ element, use a weak location to the beginning of {…}.
-    const upLocation = weakLocation( location );
     const up = { // elements.up_ = ...
-      name: { location: upLocation, id: 'up_' },
+      name: { location, id: 'up_' },
       kind: 'element',
-      location: upLocation,
+      location,
       $inferred: 'aspect-composition',
-      type: linkMainArtifact( upLocation, 'cds.Association' ),
-      target: linkMainArtifact( upLocation, base.name.id ),
+      type: linkMainArtifact( location, 'cds.Association' ),
+      target: linkMainArtifact( location, base.name.id ),
       cardinality: {
-        targetMin: { val: 1, literal: 'number', location: upLocation },
-        targetMax: { val: 1, literal: 'number', location: upLocation },
-        location: upLocation,
+        targetMin: { val: 1, literal: 'number', location },
+        targetMax: { val: 1, literal: 'number', location },
+        location,
       },
     };
     // By default, 'up_' is a managed primary key association.
@@ -710,18 +723,21 @@ function generate( model ) {
     if (isDeprecatedEnabled( options, '_unmanagedUpInComponent' )) {
       addProxyElements( art, keys, 'aspect-composition', target.name && location,
                         'up__', '@odata.containment.ignore' );
-      up.on = augmentEqual( upLocation, 'up_', Object.values( keys ), 'up__' );
+      up.on = augmentEqual( location, 'up_', Object.values( keys ), 'up__' );
     }
     else {
-      up.key = { location: upLocation, val: true };
+      up.key = { location, val: true };
       // managed associations must be explicitly set to not null
       // even if target cardinality is 1..1
-      up.notNull = { location: upLocation, val: true };
+      up.notNull = { location, val: true };
     }
 
     dictAdd( art.elements, 'up_', up );
     // Only for named aspects, use a new location; otherwise use the origin's one.
-    addProxyElements( art, target.elements, 'aspect-composition', target.name && location );
+
+    // To keep the locations of non-inferred original elements, do not set $inferred:
+    const enforceLocation = target.name || elem.$inferred;
+    addProxyElements( art, target.elements, 'aspect-composition', enforceLocation && location );
 
     setLink( art, '_block', model.$internal );
     model.definitions[entityName] = art;
@@ -742,7 +758,8 @@ function generate( model ) {
       const origin = elements[name];
       const proxy = linkToOrigin( origin, pname, null, null, location, true );
       setLink( proxy, '_block', origin._block );
-      proxy.$inferred = inferred;
+      if (location)
+        proxy.$inferred = inferred;
       if (origin.masked)
         proxy.masked = Object.assign( { $inferred: 'include' }, origin.masked );
       if (origin.key)
@@ -784,7 +801,7 @@ function generate( model ) {
   }
 
   function linkMainArtifact( location, absolute ) {
-    const r = { location };
+    const r = { location, path: [ { id: absolute, location } ] };
     setArtifactLink( r, model.definitions[absolute] );
     return r;
   }

package/lib/compiler/kick-start.js

@@ -3,7 +3,12 @@
 'use strict';
 
 const { isBetaEnabled, forEachGeneric } = require('../base/model');
-const { setLink, annotationVal, annotationIsFalse } = require('./utils');
+const {
+  setLink,
+  annotationVal,
+  annotationIsFalse,
+  isDirectComposition,
+} = require('./utils');
 
 function kickStart( model ) {
   const { options } = model;
@@ -122,10 +127,7 @@ function kickStart( model ) {
   }
 
   function tagCompositionTargets( elem ) {
-    const { type } = elem;
-    if (elem.target && type &&
-        (type._artifact === model.definitions['cds.Composition'] ||
-         type.path?.[0].id === 'cds.Composition')) {
+    if (elem.target && isDirectComposition( elem )) {
       // A target aspect would have already moved to property `targetAspect` in
       // define.js (hm... more something for kick-start.js...)
       // TODO: for safety, just use resolveUncheckedPath()