@sap/cds-compiler 3.1.2 → 3.3.2

package/lib/compiler/extend.js

@@ -22,7 +22,8 @@ const {
   augmentPath,
   splitIntoPath,
 } = require('./utils');
-const { compareLayer, layer } = require('./moduleLayers');
+const layers = require('./moduleLayers');
+const { typeParameters } = require('./builtins');
 
 function extend( model ) {
   const { options } = model;
@@ -44,6 +45,9 @@ function extend( model ) {
 
   Object.assign( model.$functions, {
     lateExtensions,
+    layeredAssignments,
+    assignmentsOfHighestLayers,
+    applyTypeExtensions,
   } );
 
   applyExtensions();
@@ -74,6 +78,9 @@ function extend( model ) {
   }
 
   /**
+   * Propagate the given `prop` (e.g. annotation) early, i.e. copy it from all `.includes`
+   * if they have the property.
+   *
    * @param {XSN.Definition} art
    * @param {string} prop
    */
@@ -163,10 +170,10 @@ function extend( model ) {
         if (ext.expectedKind === 'context' || ext.expectedKind === 'service') {
           const loc = ext.name.location;
           // TODO: warning is enough
-          error( 'extend-with-artifacts', [ loc, ext ], { name, '#': ext.expectedKind }, {
-            std: 'Cannot extend non-context / non-service $(NAME) with artifacts',
-            service: 'Cannot extend non-service $(NAME) with artifacts',
-            context: 'Cannot extend non-context $(NAME) with artifacts',
+          error( 'extend-with-artifacts', [ loc, ext ], { name, '#': ext.expectedKind, keyword: `EXTEND ${ ext.expectedKind }` }, {
+            std: 'Can\'t extend non-context / non-service $(NAME) with $(KEYWORD)',
+            service: 'Can\'t extend non-service $(NAME) with $(KEYWORD)',
+            context: 'Can\'t extend non-context $(NAME) with $(KEYWORD)',
           });
         }
       }
@@ -182,7 +189,7 @@ function extend( model ) {
       checkDefinitions( ext, art, 'columns');
       if (ext.includes)
         applyIncludes( ext, art ); // emits error if `includes` is set
-      if (ext.kind === 'annotate')
+      if (ext.kind === 'annotate' || ext.kind === 'extend')
         checkAnnotate( ext, art );
       defineAnnotations( ext, art, ext._block, ext.kind );
     }
@@ -221,7 +228,8 @@ function extend( model ) {
   function extendMembers( extensions, art, noExtend ) {
     // TODO: do the whole extension stuff lazily if the elements are requested
     const elemExtensions = [];
-    extensions.sort( compareLayer );
+    extensions.sort( layers.compareLayer );
+    // TODO: use same sequence as in chooseAssignment() - better: use common code with that fn
     for (const ext of extensions) {
       // console.log(message( 'id', [ext.location, ext], { art: ext.name._artifact },
       //                      'Info', 'EXT').toString())
@@ -243,18 +251,19 @@ function extend( model ) {
             art.includes = [ ...ext.includes ];
           applyIncludes( ext, art );
         }
-        if (ext.kind === 'annotate')
+        if (ext.kind === 'annotate' || ext.kind === 'extend')
           checkAnnotate( ext, art );
         defineAnnotations( ext, art, ext._block, ext.kind );
         // TODO: do we allow to add elements with array of {...}?  If yes, adapt
         initMembers( ext, art, ext._block ); // might set _extend, _annotate
+        storeTypeExtension( ext, art );
         dependsOnSilent(art, ext); // art depends silently on ext (inverse to normal dep!)
       }
       for (const name in ext.elements) {
         const elem = ext.elements[name];
         if (elem.kind === 'element') { // i.e. not extend or annotate
           elemExtensions.push( elem );
-          break;
+          break;                // more than one elem in same EXTEND is fine
         }
       }
 
@@ -263,6 +272,8 @@ function extend( model ) {
     }
     if (elemExtensions.length > 1)
       reportUnstableExtensions( elemExtensions );
+    if (art._extendType && art._extendType.length > 0)
+      reportTypeExtensionsInSameLayer( art._extendType );
 
     [ 'elements', 'actions' ].forEach( (prop) => {
       const dict = art._extend && art._extend[prop];
@@ -315,14 +326,115 @@ function extend( model ) {
     }
   }
 
+  /**
+   * Similar to chooseAssignment for annotations, this function applies type extensions in order,
+   * such that hierarchies are respected.
+   * Order already set in `extendMembers()` using `compareLayers()`.
+   *
+   * @param art
+   */
+  function applyTypeExtensions(art) {
+    /**
+     * Contains the previous extension for each property that was applied
+     * successfully.
+     */
+    const previousSuccess = Object.create(null);
+    const allowedBuiltinCategories = [ 'string', 'decimal', 'integer', 'binary' ];
+    const artType = art.type?._artifact;
+
+    for (const ext of art._extendType) {
+      if (art.$inferred) {
+        // Only report first extension for $inferred artifact. Reduces noise.
+        error('ref-expected-scalar-type', [ ext.name.location, ext ], { '#': 'inferred' } );
+        break;
+      }
+
+      const baseType = art._effectiveType; // may be an ENUM
+      if (!artType || (art.kind !== 'type' && art.kind !== 'element') || !baseType?.builtin) {
+        // Only report first extension for non-scalar base type. Reduces noise.
+        error('ref-expected-scalar-type', [ ext.name.location, ext ], { } );
+        break;
+      }
+      else if (!allowedBuiltinCategories.includes(baseType.category)) {
+        // Only report first extension for non-scalar type. Reduces noise.
+        error('ref-expected-scalar-type', [ ext.name.location, ext ],
+              { '#': 'unsupported', prop: baseType.category });
+        continue;
+      }
+
+      for (const prop of typeParameters.list) {
+        if (!ext[prop])
+          continue;
+
+        if (!baseType.parameters?.includes(prop)) {
+          // For `extend T with type (length:10)` where T does not expect a length.
+          error( 'type-unexpected-argument', [ ext[prop].location, ext ], {
+            '#': 'type', prop, art, type: baseType,
+          });
+          break; // one error for first property is enough
+        }
+        else if (!art[prop]) {
+          // Can only extend properties that exist directly on the artifact.
+          error('ext-invalid-type-property', [ ext[prop].location, ext ],
+                { prop, '#': 'new-prop' });
+          break; // one error for first property is enough
+        }
+        else if (art[prop].val === ext[prop].val) {
+          // Ignore extensions with same value
+        }
+        else if (art[prop].literal === 'string' || ext[prop].literal === 'string' ) {
+          // Users can't change from/to string value for property,
+          // e.g. `variable`/`floating` for Decimal
+          error( 'ext-invalid-type-property', [ ext[prop].location, ext ],
+                 { '#': 'string', prop } );
+        }
+        else if (art[prop].val > ext[prop].val) {
+          // TODO: Future: Sub-message that points to previous extension?
+          error( 'ext-invalid-type-property', [ ext[prop].location, ext ], {
+            prop,
+            literal: ext[prop].val,
+            number: art[prop].val,
+            '#': previousSuccess[prop] ? 'ext-smaller' : 'smaller',
+          } );
+          break; // one error for first property is enough
+        }
+        else if (art[prop].val < ext[prop].val) {
+          art[prop] = ext[prop];
+          previousSuccess[prop] = ext;
+        }
+      }
+
+      // If `scale` is increased, but `precision` is not, data may be lost in a migration.
+      // e.g. `Decimal(4,2)` allows `12.34`. Increasing scale to 3 would make this value
+      // invalid and only allow `1.234`.
+      // TODO: Should we actually check that the increase is correct?
+      if (ext.scale && !ext.precision) {
+        error('ext-invalid-type-property', [ ext.scale.location, ext ], {
+          prop: 'scale',
+          otherprop: 'precision',
+          '#': 'scale',
+        });
+      }
+    }
+  }
+
+  /**
+   * Report 'Warning: Unstable element order due to repeated extensions'
+   * except if all extensions are in the same file.
+   *
+   * @param {XSN.Extension[]} extensions
+   */
   function reportUnstableExtensions( extensions ) {
-    // Report 'Warning: Unstable element order due to repeated extensions'.
+    // No message if all extensions are in the same file:
+    const file = layers.realname( extensions[0] );
+    if (extensions.every( ( ext, i ) => !i || file === layers.realname( ext ) ))
+      return;
     // Similar to chooseAssignment(), TODO there: also extra intralayer message
     // as this is a modeling error
     let lastExt = null;
     let open = [];              // the "highest" layers
     for (const ext of extensions) {
-      const extLayer = layer( ext ) || { realname: '', _layerExtends: Object.create(null) };
+      const extLayer = layers.layer( ext ) || { realname: '', _layerExtends: Object.create(null) };
       if (!open.length) {
         lastExt = ext;
         open = [ extLayer.realname ];
@@ -346,6 +458,28 @@ function extend( model ) {
       }
     }
   }
+
+  /**
+   * Report type extensions in same layer, similar mechanism to chooseAssignment()
+   * for annotations.
+   *
+   * @param {XSN.Extension[]} extensions
+   */
+  function reportTypeExtensionsInSameLayer( extensions ) {
+    // Group assignments by layer
+    const extLayers = layeredAssignments( extensions );
+    // We only care about the highest layer
+    const { assignments, issue } = assignmentsOfHighestLayers( extLayers );
+
+    if (issue) {
+      const id = (issue === 'unrelated')
+        ? 'ext-duplicate-extend-type-unrelated-layer'
+        : 'ext-duplicate-extend-type';
+      for (const ext of assignments)
+        message( id, [ ext.name.location, ext ], { type: ext.name._artifact } );
+    }
+  }
+
   /**
    * @param {XSN.Extension[]} extensions
    * @param {string} prop
@@ -354,12 +488,14 @@ function extend( model ) {
    * @param {object} validDict
    */
   function extendNothing( extensions, prop, name, art, validDict ) {
+    const artName = searchName( art, name, dictKinds[prop] );
     for (const ext of extensions) {
       // TODO: use shared functionality with notFound in resolver.js
       const { location } = ext.name;
+      const extName = { ...artName, kind: ext.kind };
       const msg
-        = error( 'extend-undefined', [ location, ext ],
-                 { art: searchName( art, name, dictKinds[prop] ) },
+        = error( 'extend-undefined', [ location, extName ],
+                 { art: artName },
                  {
                    std: 'Unknown $(ART) - nothing to extend',
                    // eslint-disable-next-line max-len
@@ -444,7 +580,11 @@ function extend( model ) {
   // includes ----------------------------------------------------------------
 
   /**
+   * Returns true, if `includes` can be applied.  They can't be applied if
+   * any of the artifacts referenced in `includes` are yet to be extended.
+   *
    * @param {XSN.Definition} art
+   * @returns {boolean}
    */
   function canApplyIncludes( art ) {
     if (art.includes) {
@@ -458,6 +598,15 @@ function extend( model ) {
   }
 
   /**
+   * Apply all includes of `ext` on `ext`.  Checks that `art` allows includes.
+   * If `ext === art`, then includes of the artifact itself are applied.
+   * If `ext !== art`, applies includes on the extensions, not artifact.
+   * Sets `_ancestor` links on `art`.
+   *
+   * Examples:
+   *   ext === art:  `entity E : F {}`  => add elements of F to E
+   *   ext !== art:  `extend E with F`  => add elements of F to extension on E
+   *
    * @param {XSN.Extension} ext
    * @param {XSN.Artifact} art
    */
@@ -471,37 +620,42 @@ function extend( model ) {
     if (!art._ancestors)
       setLink( art, '_ancestors', [] ); // recursive array of includes
     for (const ref of ext.includes) {
-      const template = ref._artifact; // already resolved
+      const template = ref._artifact;
+      // !template -> non-includable, e.g. scalar type, or cyclic
       if (template) {
         if (template._ancestors)
           art._ancestors.push( ...template._ancestors );
         art._ancestors.push( template );
       }
     }
-    includeMembers( ext, 'elements', forEachInOrder, ext === art && art );
-    includeMembers( ext, 'actions', forEachGeneric, ext === art && art );
+    includeMembers( ext, art, 'elements' );
+    includeMembers( ext, art, 'actions' );
   }
 
   /**
+   * Add all members (e.g. elements or actions) of `ext.includes` to `ext[prop]`
+   * if `parent` is `false` or to `parent` with appropriate _origin links otherwise.
+   * Included members are prepended to existing ones.
+   *
    * @param {XSN.Extension} ext
+   * @param {XSN.Artifact} art
    * @param {string} prop
-   * @param {function} forEach
-   * @param {XSN.Artifact} parent
    */
-  function includeMembers( ext, prop, forEach, parent ) {
+  function includeMembers( ext, art, prop ) {
     // TODO two kind of messages:
     // Error 'More than one include defines element "A"' (at include ref)
     // Warning 'Overwrites definition from include "I" (at elem def)
+    const parent = ext === art && art;
     const members = ext[prop];
     ext[prop] = Object.create(null); // TODO: do not set actions property if there are none
     for (const ref of ext.includes) {
       const template = ref._artifact; // already resolved
       if (template) {           // be robust
-        forEach( template, prop, ( origin, name ) => {
+        forEachInOrder( template, prop, ( origin, name ) => {
           if (members && name in members)
             return;               // TODO: warning for overwritten element
           const elem = linkToOrigin( origin, name, parent, prop, weakLocation( ref.location ) );
-          if (!parent)          // not yet set for EXTEND foo WITH bar
+          if (!parent) // not yet set for EXTEND foo WITH bar => linkToOrigin() did not add it
             dictAdd( ext[prop], name, elem );
           elem.$inferred = 'include';
           if (origin.masked)
@@ -514,7 +668,7 @@ function extend( model ) {
     }
     // TODO: expand elements having direct elements (if needed)
     if (members) {
-      forEach( { [prop]: members }, prop, ( elem, name ) => {
+      forEachInOrder( { [prop]: members }, prop, ( elem, name ) => {
         dictAdd( ext[prop], name, elem );
       });
     }
@@ -523,6 +677,9 @@ function extend( model ) {
   // localized texts entities
 
   /**
+   * Process localized data for `art`.  This includes creating `.texts` entities
+   * and `locale` associations.
+   *
    * @param {XSN.Artifact} art
    */
   function processLocalizedData( art ) {
@@ -542,9 +699,13 @@ function extend( model ) {
   }
 
   /**
+   * Returns `false`, if there is no localized data or an array of elements
+   * that are required for `.texts` entities such as keys and localized elements.
+   *
    * @param {XSN.Artifact} art
    * @param {XSN.Artifact|undefined} textsEntity
    * @param {boolean} fioriEnabled
+   * @returns {false|XSN.Element[]}
    */
   function localizedData( art, textsEntity, fioriEnabled ) {
     let keys = 0;
@@ -626,7 +787,7 @@ function extend( model ) {
   }
 
   /**
-   * TODO: set _parent also for main artifacts!
+   * Create the `.texts` entity for the given base artifact.
    *
    * @param {XSN.Artifact} base
    * @param {string} absolute
@@ -772,16 +933,20 @@ function extend( model ) {
   }
 
   /**
+   * Returns whether `art` directly or indirectly has the property 'prop',
+   * following the 'origin' and the 'type' (not involving elements).
+   *
+   * DON'T USE FOR ANNOTATIONS (see TODO below)
+   *
+   * TODO: we should issue a warning if we get localized via TYPE OF
+   * TODO: XSN: for anno short form, use { val: true, location, <no literal prop> }
+   *       ...then this function also works with annotations
+   *
    * @param {XSN.Artifact} art
    * @param {string} prop
+   * @returns {boolean}
    */
   function hasTruthyProp( art, prop ) {
-    // Returns whether art directly or indirectly has the property 'prop',
-    // following the 'origin' and the 'type' (not involving elements).
-    //
-    // TODO: we should issue a warning if we get localized via TYPE OF
-    // TODO XSN: for anno short form, use { val: true, location, <no literal prop> }
-    // ...then this function also works with annotations
     const processed = Object.create(null); // avoid infloops with circular refs
     let name = art.name.absolute;        // is ok, since no recursive type possible
     while (art && !processed[name]) {
@@ -1008,6 +1173,88 @@ function extend( model ) {
   }
 }
 
+/**
+ * Group assignments by their layers.  An assignment provided with a definition
+ * is considered to be provided in a layer named '', the lowest layer.
+ *
+ * TODO: make this usable for extend (elements), too =
+ *       do not use $priority, make assignments on define do not have own _block
+ *
+ * @param {object[]} assignments Array of assignments, e.g. extensions.
+ * @returns {Record<string, object>} key: layer name, value: {name, layer, assignments[]}`
+ */
+function layeredAssignments( assignments ) {
+  const layered = Object.create(null);
+  for (const a of assignments) {
+    const layer = a.$priority !== false && layers.layer( a );
+    // just consider layer if Extend/Annotate, not Define
+    const name = (layer) ? layer.realname : '';
+    const done = layered[name];
+    if (done)
+      done.assignments.push( a );
+    else
+      layered[name] = { name, layer, assignments: [ a ] };
+    // TODO: file - if set: unique in layer
+  }
+  return layered;
+}
+
+/**
+ * Return assignments of the highest layers.
+ * Also returns whether there could be an issue:
+ * - false: there is just one assignment
+ * - 'unrelated': there is just one assignment per layer
+ * - true: there is at least one layer with two or more assignments
+ * TODO: make this usable for extend (elements), too.
+ *
+ * @param {Record<string, object>} layeredAnnos Structure as returned by layeredAssignments()
+ * @returns {{assignments, issue: boolean|string}}
+ */
+function assignmentsOfHighestLayers( layeredAnnos ) {
+  const layerNames = Object.keys( layeredAnnos );
+  // console.log('HIB:',layerNames)
+  if (layerNames.length <= 1) {
+    const name = layerNames[0];
+    const { assignments } = layeredAnnos[name] || { assignments: [] };
+    delete layeredAnnos[name];
+    return { assignments, issue: assignments.length > 1 };
+  }
+
+  // collect all layers which are lower than another layer
+  const allExtends = Object.create(null);
+  allExtends[''] = {};        // the "Define" layer
+  for (const name of layerNames) {
+    if (name)                 // not the "Define" layer
+      Object.assign( allExtends, layeredAnnos[name].layer._layerExtends );
+  }
+  // console.log('HIE:',Object.keys(allExtends))
+  const assignments = [];
+  const highest = [];
+  for (const name of layerNames) {
+    if (!(name in allExtends)) {
+      const layer = layeredAnnos[name];
+      delete layeredAnnos[name];
+      highest.push( layer );
+      assignments.push( ...layer.assignments );
+    }
+  }
+  assignments.sort( compareAssignments );
+  const good = highest.every( layer => layer.assignments.length === 1 );
+  // TODO: use layer.file instead
+  const issue = !good || highest.length > 1 && 'unrelated';
+  // console.log('HI:',highest.map(l=>l.name),issue,issue&&assignments)
+  return { assignments, issue };
+}
+
+function compareAssignments( a, b ) {
+  const fileA = layers.realname( a._block );
+  const fileB = layers.realname( b._block );
+  if (fileA !== fileB)
+    return (fileA > fileB) ? 1 : -1;
+  return (a?.location?.line || 0) - (b?.location?.line || 0) ||
+    (a?.location?.col || 0) - (b?.location?.col || 0);
+}
+
 /**
  * Copy the annotations `@cds.persistence.skip`/`@cds.persistence.exists` from
  * source to target if present on source but not target.
@@ -1019,14 +1266,16 @@ function extend( model ) {
 function copyPersistenceAnnotations(target, source, options) {
   if (!source)
     return;
-  // Copy @cds.persistence.skip/exists annotation.
-  const noCopyExists = isDeprecatedEnabled( options, 'eagerPersistenceForGeneratedEntities' );
-  const existsAnno = '@cds.persistence.exists';
-  const skipAnno = '@cds.persistence.skip';
-  if (!noCopyExists && source[existsAnno] && !target[existsAnno])
-    target[existsAnno] = source[existsAnno];
-  if (source[skipAnno] && !target[skipAnno])
-    target[skipAnno] = source[skipAnno];
+
+  const copyExists = !isDeprecatedEnabled( options, 'eagerPersistenceForGeneratedEntities' );
+  if (copyExists)
+    copy( '@cds.persistence.exists' );
+  copy( '@cds.persistence.skip' );
+
+  function copy(anno) {
+    if ( source[anno] && !target[anno] )
+      target[anno] = { ...source[anno], $inferred: 'parent-origin' };
+  }
 }
 
 function augmentEqual( location, assocname, relations, prefix = '' ) {
@@ -1054,4 +1303,21 @@ function augmentEqual( location, assocname, relations, prefix = '' ) {
   }
 }
 
+/**
+ * If the given extension is a `EXTEND <def> WITH TYPE` extension, store
+ * it in the given artifact.  resolve.js will resolve types and call
+ * `typeExtensions()` later.
+ *
+ * @param {XSN.Extension} ext
+ * @param {object} art
+ */
+function storeTypeExtension( ext, art ) {
+  // If there are no parameters to apply, don't store the extension.
+  if (!typeParameters.list.some( prop => ext[prop] !== undefined ))
+    return;
+  else if (!art._extendType)
+    setLink( art, '_extendType', [] );
+  art._extendType.push( ext );
+}
+
 module.exports = extend;

package/lib/compiler/kick-start.js

@@ -10,7 +10,6 @@ function kickStart( model ) {
   const { message } = model.$messageFunctions;
 
   const { resolveUncheckedPath, resolvePath } = model.$functions;
-  Object.assign( model.$functions, { projectionAncestor } );
 
   // Set _service link (sorted to set it on parent first).  Could be set
   // directly, but beware a namespace becoming a service later.
@@ -68,7 +67,7 @@ function kickStart( model ) {
     // no redirection target for E if Service2.E = projection on Service1.E and
     // Service1.E = projection on E
     const chain = [];
-    const autoexposed = art.$generated || annotationVal( art['@cds.autoexposed'] );
+    const autoexposed = annotationVal( art['@cds.autoexposed'] );
     const preferredRedirectionTarget = annotationVal( art['@cds.redirection.target'] );
     // no need to set preferredRedirectionTarget in the while loop as we would
     // use the projection having @cds.redirection.target anyhow instead of
@@ -80,7 +79,7 @@ function kickStart( model ) {
       chain.push( art );
       setLink( art, '_ancestors', null ); // avoid infloop with cyclic from
       const name = resolveUncheckedPath( art._from[0], 'include', art ); // TODO: 'include'?
-      art = name && projectionAncestor( model.definitions[name], art.params );
+      art = name && model.definitions[name];
       if (autoexposed)
         break;                  // only direct projection for auto-exposed
     }
@@ -93,38 +92,6 @@ function kickStart( model ) {
     }
   }
 
-  // Return argument `source` if entity `source` has parameters like `params`
-  // - same parameters, although `params` can contain a new optional one (with DEFAULT)
-  // - a parameter in `params` can be optional which is not in `source.params`, but not vice versa
-  // - exactly the same types (type argument do not matter)
-  function projectionAncestor( source, params ) {
-    if (!source)
-      return source;
-    if (!params)                // proj has no params => ok if source has no params
-      return !source.params && source;
-    const sourceParams = source.params || Object.create(null);
-    for (const n in sourceParams) {
-      if (!(n in params))       // source param is not projection param
-        return null;            // -> can't be used as implicit redirection target
-    }
-    for (const n in params) {
-      const pp = params[n];
-      const sp = sourceParams[n];
-      if (sp) {
-        if (sp.default && !pp.default) // param DEFAULT clause not supported yet
-          return null;          // param is not optional anymore
-        const pt = pp.type && resolveUncheckedPath( pp.type, 'type', pp );
-        const st = sp.type && resolveUncheckedPath( sp.type, 'type', sp );
-        if ((pt || null) !== (st || null))
-          return null;          // params have different type
-      }
-      else if (!pp.default) {
-        return null;
-      }        // non-optional param in projection, but not source
-    }
-    return source;
-  }
-
   function postProcessArtifact( art ) {
     tagCompositionTargets( art );
     if (art.$queries) {