@sap/cds-compiler 3.8.2 → 3.9.4

package/lib/compiler/base.js

@@ -66,9 +66,13 @@ function propExists( prop, parent ) {
   return (obj.items || obj.targetAspect || obj)[prop];
 }
 
-// Return the "old style" name structure with `absolute`, `action`, `param`,
-// `element`.  The following code makes use of the fact that only member extensions
-// have a "sparse" name structure.
+/**
+ * Return the "old style" name structure with `absolute`, `action`, `param`,
+ * `element`.  The following code makes use of the fact that only member extensions
+ * have a "sparse" name structure.
+ *
+ * @param {XSN.Artifact} art
+ */
 function getArtifactName( art ) {
   if (!art.name || art.name.absolute) // no name or “old style”
     return art.name;
@@ -105,7 +109,7 @@ function getMemberNameProp( elem, kind ) {
     obj = obj.items;
   if (obj.elements || obj.enum)
     return 'element';
-  throw CompilerAssertion( `Member not found in parent properties ${ Object.keys( obj ).join('+') }` );
+  throw new CompilerAssertion( `Member not found in parent properties ${ Object.keys( obj ).join('+') }` );
 }
 
 module.exports = {

package/lib/compiler/builtins.js

@@ -191,6 +191,13 @@ const magicVariables = {
     // Require that elements are accessed, i.e. no $at, only $at.<element>.
     $requireElementAccess: true,
   },
+  $valid: { // dito
+    elements: {
+      from: {}, to: {},
+    },
+    // Require that elements are accessed, i.e. no $valid, only $valid.<element>.
+    $requireElementAccess: true,
+  },
   $now: {}, // Dito
   $session: {
     // In ABAP CDS session variables are accessed in a generic way via

package/lib/compiler/checks.js

@@ -16,11 +16,12 @@
 // const { hasArtifactTypeInformation } = require('../model/csnUtils')
 const builtins = require('../compiler/builtins');
 const {
-  forEachGeneric, forEachDefinition, forEachMember,
+  forEachGeneric, forEachDefinition, forEachMember, isBetaEnabled,
 } = require('../base/model');
 const { CompilerAssertion } = require('../base/error');
 const { pathName } = require('./utils');
 const { forEachMemberRecursively } = require('../model/csnUtils');
+const $location = Symbol.for('cds.$location');
 
 function check( model ) {       // = XSN
   const {
@@ -34,11 +35,13 @@ function check( model ) {       // = XSN
   forEachGeneric( model, 'vocabularies', checkAnnotationDefinition );
   return;
 
-  function checkDefinition( art ) {
-    checkGenericConstruct( art );
-    forEachMember( art, member => checkMember(member) );
-    if (art.$queries)
-      art.$queries.forEach( checkQuery );
+  function checkDefinition( def ) {
+    checkGenericConstruct( def );
+    if (def.includes && def.elements)
+      checkElementIncludeOverride( def );
+    forEachMember( def, member => checkMember(member) );
+    if (def.$queries)
+      def.$queries.forEach( checkQuery );
   }
 
   function checkAnnotationDefinition( art ) {
@@ -498,6 +501,70 @@ function check( model ) {       // = XSN
       checkTypeStructure(artifact.items);
   }
 
+  /**
+   * Report issues when an entity overrides structured elements of an included entity
+   * with a scalar one or vice versa.
+   *
+   * NOTE: Relies on element expansion.
+   */
+  function checkElementIncludeOverride( def ) {
+    if (!isBetaEnabled(model.options, 'v4preview'))
+      return; // this is a v4 check only
+
+    for (const name in def.elements) {
+      const element = def.elements[name];
+      // Element is new in `art`, not expanded; we can't check for !element._origin, due
+      // to calculated elements such as `a = b`.
+      if (element.$inferred !== 'include') {
+        for (const include of def.includes) {
+          if (include._artifact?.elements?.[name] !== undefined)
+            checkElementOverride( element, include._artifact.elements[name]);
+        }
+      }
+    }
+
+    return;
+
+    function checkElementOverride( elem, original ) {
+      const xorElements = !elem.elements !== !original.elements;
+      if (xorElements) {
+        // one of the two elements is not structured
+        const prop = !elem.elements ? 'new-not-structured' : 'old-not-structured';
+        const name = elem.name.id;
+        // Position at type/struct, not name
+        const loc = elem.type?.location || elem.elements?.[$location] || elem.location;
+        error('ref-invalid-override', [ loc, elem ],
+              { '#': prop, art: original._main, name });
+        return false;
+      }
+      else if (original.elements &&
+               !checkSubStructureOverride(elem, elem.elements, original.elements)) {
+        return false;
+      }
+      return true;
+    }
+
+    /**
+     * Ensure the new one has at least as many elements as the original.
+     */
+    function checkSubStructureOverride( user, elements, originals ) {
+      for (const element in originals) {
+        const elem = elements[element];
+        const orig = originals[element];
+        if (elem === undefined) {
+          const loc = [ elements[$location], user ];
+          error('ref-invalid-override', loc, { '#': 'missing', id: user.name.id, name: element });
+          return false; // only report one
+        }
+        else if (!checkElementOverride(elem, orig)) {
+          return false;
+        }
+      }
+      return true;
+    }
+  }
+
+
   // Former checkExpressions.js ----------------------------------------------
 
   /**

package/lib/compiler/define.js

@@ -123,6 +123,7 @@ const {
   forEachGeneric,
   forEachInOrder,
   forEachMember,
+  isBetaEnabled,
 } = require('../base/model');
 const shuffleGen = require('../base/shuffle');
 const {
@@ -159,7 +160,7 @@ function define( model ) {
   const { options } = model;
   // Get simplified "resolve" functionality and the message function:
   const {
-    error, warning, info, messages,
+    error, warning, info, messages, message,
   } = model.$messageFunctions;
   const {
     resolveUncheckedPath,
@@ -201,7 +202,7 @@ function define( model ) {
     setLink( model, '_entities', [] ); // for entities with includes
     model.$entity = 0;
     model.$compositionTargets = Object.create(null);
-    model.$lateExtensions = Object.create(null); // TODO: rename to $collectedExtensions
+    model.$collectedExtensions = Object.create(null);
 
     initBuiltins( model );
     const sourceNames = shuffleArray( Object.keys( model.sources ) );
@@ -211,7 +212,7 @@ function define( model ) {
       initNamespaceAndUsing( model.sources[name] );
     dictForEach( model.definitions, initArtifact );
     dictForEach( model.vocabularies, initVocabulary );
-    dictForEach( model.$lateExtensions, e => e._extensions.forEach( initExtension ) );
+    dictForEach( model.$collectedExtensions, e => e._extensions.forEach( initExtension ) );
 
     addI18nBlocks();
   }
@@ -398,8 +399,8 @@ function define( model ) {
     delete ext.name.path[0]._artifact; // might point to wrong JS object in phase 1
     ext.name.absolute = absolute; // definition might not be there yet, no _artifact link
     const location = { file: '' }; // stupid required location
-    const late = model.$lateExtensions[absolute] ||
-          (model.$lateExtensions[absolute] = {
+    const late = model.$collectedExtensions[absolute] ||
+          (model.$collectedExtensions[absolute] = {
             kind: 'annotate',
             name: { absolute, location },
             $inferred: '',
@@ -1165,6 +1166,10 @@ function define( model ) {
         if (!elem.target)
           elem.type = { ...elem.value.type, $inferred: 'cast' };
       }
+      if (elem.value.stored?.val === true && !isBetaEnabled(options, 'calculatedElementsOnWrite')) {
+        const loc = [ elem.value.stored.location, elem ];
+        message( 'def-unsupported-calc-elem', loc, { '#': 'on-write' } );
+      }
       elem.$syntax = 'calc';
     }
   }