@sap/cds-compiler 3.5.4 → 3.6.0

package/lib/compiler/checks.js

@@ -20,6 +20,7 @@ const {
 } = require('../base/model');
 const { CompilerAssertion } = require('../base/error');
 const { pathName } = require('./utils');
+const { forEachMemberRecursively } = require('../model/csnUtils');
 
 function check( model ) {       // = XSN
   const {
@@ -40,6 +41,10 @@ function check( model ) {       // = XSN
 
   function checkAnnotationDefinition( art ) {
     checkEnumType( art );
+    forEachMemberRecursively( art, (member) => {
+      if (member.localized?.val)
+        warning( 'def-unexpected-localized-anno', [ member.localized.location, member ] );
+    });
     // TODO: Should we check elements similar to definition-elements as well?
   }
 
@@ -54,24 +59,33 @@ function check( model ) {       // = XSN
     if (art.kind === 'enum')
       checkEnum( art );
     checkEnumType( art );
+
     forEachMember( art, checkGenericConstruct );
   }
 
   function checkElement( elem ) {
     checkLocalizedSubElement(elem);
-    if (elem.key && elem.key.val) {
-      if (elem.virtual && elem.virtual.val)
-        error(null, [ elem.location, elem ], {}, 'Element can\'t be virtual and key');
-
-      checkForUnmanagedAssociations( elem, elem.key );
+    if (elem.key?.val) {
+      if (elem.virtual?.val) {
+        error('def-unexpected-key', [ elem.key.location, elem ],
+              { '#': 'virtual', name: elem.name.element, prop: 'key' });
+      }
+      checkForUnmanagedAssociationsAsKey( elem, elem.key );
     }
     checkAssociation( elem );
     checkLocalizedElement( elem );
     if (elem.on && !elem.on.$inferred)
       checkExpression(elem.on, true);
-    if (elem.value)
-      checkExpression(elem.value);
+
+    if (elem.value) {
+      if (elem.$syntax === 'calc')
+        checkCalculatedElement( elem );
+      else
+        checkExpression( elem.value );
+    }
+
     checkCardinality(elem); // TODO: also for assoc types
+
     forEachGeneric( elem, 'elements', checkElement );
   }
 
@@ -111,6 +125,24 @@ function check( model ) {       // = XSN
     }
   }
 
+  function checkCalculatedElement( elem ) {
+    if (elem.value.path) {
+      checkExpressionsInPaths(elem.value);
+
+      const loc = [ elem.value.location, elem ];
+      if (isVirtualElement(elem.value._artifact))
+        error('ref-unexpected-virtual', loc, { '#': 'expr' });
+      else if (isStructuredElement(elem.value._artifact))
+        error('ref-unexpected-structured', loc, { '#': 'expr' } );
+      else if (elem.value._artifact?.target !== undefined)
+        error('ref-unexpected-assoc', loc, { '#': 'expr' });
+    }
+    else {
+      // TODO: The checks above should also be run for each path in expressions.
+      checkExpression( elem.value );
+    }
+  }
+
   function checkQuery( query ) {
     checkNoUnmanagedAssocsInGroupByOrderBy( query );
     // TODO: check too simple (just one source), as most of those in this file
@@ -169,9 +201,8 @@ function check( model ) {       // = XSN
     // Special handling to print a more detailed error message.
     // Other cases like `null` as enum value are handled in `checkEnumValueType()`
     if (type === 'enum') {
-      warning('enum-value-ref', [ loc, enumNode ], {},
+      warning('enum-value-ref', [ loc, enumNode ], {}, // TODO: make this an error in v4
               'References to other values are not allowed as enum values');
-      return;
     }
   }
 
@@ -329,7 +360,7 @@ function check( model ) {       // = XSN
    *
    * @param {any} element Element to check recursively
    */
-  function checkForUnmanagedAssociations( element, keyObj ) {
+  function checkForUnmanagedAssociationsAsKey( element, keyObj ) {
     if (element.targetAspect) {
       // TODO: bad location / message
       message('composition-as-key', [ keyObj.location, element ], {},
@@ -345,7 +376,7 @@ function check( model ) {       // = XSN
     // TODO: ease check for subelements: using unmanaged assocs is OK there, as
     // long as the whole key is "closed", i.e., no ref in ON refers to element
     // outside.
-    forEachGeneric( element, 'elements', e => checkForUnmanagedAssociations( e, keyObj ) );
+    forEachGeneric( element, 'elements', e => checkForUnmanagedAssociationsAsKey( e, keyObj ) );
   }
 
   // Check that min and max cardinalities of 'elem' in 'art' have legal values
@@ -468,14 +499,12 @@ function check( model ) {       // = XSN
 
   function checkAssociation( elem ) {
     // TODO: yes, a check similar to this could make it into the compiler)
-    // when virtual element is part of association
+    //       when virtual element is part of association
     if (elem.foreignKeys) {
       for (const k in elem.foreignKeys) {
         const key = elem.foreignKeys[k].targetElement;
-        if (key && key._artifact && key._artifact.virtual && key._artifact.virtual.val) {
-          error(null, [ key.location, elem ], {},
-                'Virtual elements can\'t be used as a foreign key for a managed association');
-        }
+        if (key && isVirtualElement(key._artifact))
+          error('ref-unexpected-virtual', [ key.location, elem ], { '#': 'fkey' });
       }
     }
     if (elem.on && !elem.on.$inferred)
@@ -601,13 +630,24 @@ function check( model ) {       // = XSN
    *
    * TO CLARIFY: do we want the "no virtual element" check for virtual elements/columns, too?
    *
-   * @param {any} arg Argument to check (part of an expression)
+   * @param {any} elem Element to check (part of an expression)
    * @returns {Boolean}
    */
-  function isVirtualElement( arg ) {
-    return arg.path &&
-      arg._artifact && arg._artifact.virtual && arg._artifact.virtual.val === true &&
-      arg._artifact.kind && arg._artifact.kind === 'element';
+  function isVirtualElement( elem ) {
+    let parent = elem?._origin || elem;
+    while (parent) {
+      if (parent.virtual?.val === true)
+        return true;
+      parent = parent._parent;
+    }
+    return false;
+  }
+
+  function isStructuredElement( elem ) {
+    // The effective type always points to something with elements _if_ the
+    // type is structured.  But `elem` should already have `elements` if its
+    // structured due to element expansion.
+    return !!(elem?._effectiveType || elem)?.elements;
   }
 
   /**
@@ -620,9 +660,8 @@ function check( model ) {       // = XSN
     const args = Array.isArray(xpr.args) ? xpr.args : Object.values(xpr.args || {});
     // Check for illegal argument usage within the expression
     for (const arg of args) {
-      if (isVirtualElement(arg))
-        error(null, arg.location, {}, 'Virtual elements can\'t be used in an expression');
-
+      if (isVirtualElement(arg._artifact || arg))
+        error('ref-unexpected-virtual', arg.location, { '#': 'expr' });
 
       // Recursively traverse the argument expression
       checkTokenStreamExpression(arg, allowAssocTail);
@@ -643,20 +682,17 @@ function check( model ) {       // = XSN
 
     // Check for illegal argument usage within the expression
     for (const arg of Array.isArray(xpr.args) && xpr.args || []) { // TODO named args?
-      if (isVirtualElement(arg))
-        error(null, arg.location, {}, 'Virtual elements can\'t be used in an expression');
+      if (isVirtualElement(arg._artifact || arg))
+        error('ref-unexpected-virtual', arg.location, { '#': 'expr' });
 
       // Arg must not be an association and not $self
       // Only if path is not approved exists path (that is non-query position)
       if (arg.path && arg.$expected !== undefined) { // not 'approved-exists'
-        if (arg.$expected === 'exists') {
-          error(null, arg.location, {},
-                'An association can\'t be used as a value in an expression');
-        }
+        if (arg.$expected === 'exists')
+          error('ref-unexpected-assoc', arg.location, { '#': 'expr' } );
       }
       else if (!allowAssocTail && isAssociationOperand(arg)) {
-        error(null, arg.location, {},
-              'An association can\'t be used as a value in an expression');
+        error('ref-unexpected-assoc', arg.location, { '#': 'expr' } );
       }
 
       if (isDollarSelfOrProjectionOperand(arg)) {
@@ -769,7 +805,7 @@ function check( model ) {       // = XSN
 
     // Sanity checks
     if (!elementDecl._effectiveType)
-      throw new Error(`Expecting annotation declaration to have _finalType: ${ JSON.stringify(annoDecl) }`);
+      throw new CompilerAssertion(`Expecting annotation declaration to have _finalType: ${ JSON.stringify(annoDecl) }`);
 
 
     // Must have literal or path unless it is a boolean
@@ -929,40 +965,13 @@ function check( model ) {       // = XSN
 }
 
 /**
- * Ensure that the sap.common.[Fiori]TextsAspect has proper types for
- * e.g. `locale` and `ID_texts`.
- *
- * @param {XSN.Model} model
- */
-function checkSapCommonTextsAspects( model ) {
-  checkSapCommonTextsAspectLocale( model, 'sap.common.TextsAspect' );
-  checkSapCommonTextsAspectLocale( model, 'sap.common.FioriTextsAspect' );
-
-  // Check ID_texts: Fiori requires it to be UUID.
-  const fioriTextsAspect = model.definitions['sap.common.FioriTextsAspect'];
-  const id = fioriTextsAspect?.elements?.ID_texts;
-  if (id) {
-    const idType = id._effectiveType;
-    if (!idType || idType.name?.absolute !== 'cds.UUID') {
-      const { error } = model.$messageFunctions;
-      error('def-invalid-element-type', [ id.type.location, id ], {
-        '#': 'std',
-        art: 'sap.common.FioriTextsAspect',
-        elemref: 'ID_texts',
-        type: 'cds.UUID',
-      });
-    }
-  }
-}
-
-/**
- * Ensure that the `locale` element of sap.common.[Fiori]TextsAspects
+ * Ensure that the `locale` element of sap.common.TextsAspects
  * is a string type.  This is required by CAP runtimes to work properly.
  *
  * @param {XSN.Model} model
- * @param {string} name Either sap.common.TextsAspects or sap.common.FioriTextsAspects
  */
-function checkSapCommonTextsAspectLocale( model, name ) {
+function checkSapCommonTextsAspects( model ) {
+  const name = 'sap.common.TextsAspect';
   const locale = model.definitions[name]?.elements?.locale;
   if (locale) {
     // `locale` could also be `sap.common.Locale`, which must also be a string.