@sap/cds-compiler 3.1.2 → 3.4.0

package/lib/compiler/checks.js

@@ -18,6 +18,8 @@ const builtins = require('../compiler/builtins');
 const {
   forEachGeneric, forEachDefinition, forEachMember,
 } = require('../base/model');
+const { CompilerAssertion } = require('../base/error');
+const { pathName } = require('./utils');
 
 function check( model ) {       // = XSN
   const {
@@ -52,7 +54,7 @@ function check( model ) {       // = XSN
     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');
+        error(null, [ elem.location, elem ], {}, 'Element can\'t be virtual and key');
 
       checkForUnmanagedAssociations( elem, elem.key );
     }
@@ -66,26 +68,26 @@ function check( model ) {       // = XSN
     forEachGeneric( elem, 'elements', checkElement );
   }
 
-  function checkName( construct ) {
+  function checkName( construct ) { // TODO: move to define.js
     if (model.options.$skipNameCheck)
       return;
     // TODO: Move a corrected version of this check to definer (but do not rely
     // on it!): The code below misses to consider CSN input.
     if (construct.name.id && construct.name.id.indexOf('.') !== -1) {
       // TODO: No, we should not forbid this
-      error(null, [ construct.name.location, construct ],
+      error(null, [ construct.name.location, construct ], {},
             'The character \'.\' is not allowed in identifiers');
     }
   }
 
-  // TODO: move into definer.js
   function checkLocalizedElement(elem) {
     // if it is directly a localized element
     if (elem.localized && elem.localized.val) {
       const type = elem._effectiveType;
+      // See discussion issue #6520: should we allow all scalar types?
       if (!type || !type.builtin || type.category !== 'string') {
-        warning(null, [ elem.localized.location, elem ], {},
-                'Keyword “localized” may only be used in combination with string types');
+        warning(null, [ elem.type?.location, elem ], { keyword: 'localized' },
+                'Keyword $(KEYWORD) should only be used in combination with string types');
       }
     }
     // "key" keyword at localized element in SELECT list.
@@ -159,7 +161,7 @@ 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 ], {},
               'References to other values are not allowed as enum values');
       return;
     }
@@ -339,6 +341,7 @@ function check( model ) {       // = XSN
   }
 
   // Check that min and max cardinalities of 'elem' in 'art' have legal values
+  // TODO: move to define.js or parsers
   function checkCardinality(elem) {
     if (!elem.cardinality)
       return;
@@ -382,13 +385,16 @@ function check( model ) {       // = XSN
 
     // If provided, min cardinality must not exceed max cardinality (note that
     // '*' is considered to be >= any number)
-    const pair = [ [ 'sourceMin', 'sourceMax', 'Source' ], [ 'targetMin', 'targetMax', 'Target' ] ];
+    const pair = [ [ 'sourceMin', 'sourceMax', 'source' ], [ 'targetMin', 'targetMax', 'target' ] ];
     pair.forEach((p) => {
       if (elem.cardinality[p[0]] && elem.cardinality[p[1]] &&
           elem.cardinality[p[1]].literal === 'number' &&
           elem.cardinality[p[0]].val > elem.cardinality[p[1]].val) {
-        error(null, [ elem.cardinality.location, elem ],
-              `${ p[2] } minimum cardinality must not be greater than ${ p[2].toLowerCase() } maximum cardinality`);
+        error(null, [ elem.cardinality.location, elem ], { '#': p[2] }, {
+          std: 'Minimum cardinality must not be greater than maximum cardinality', // variant unused
+          source: 'Source minimum cardinality must not be greater than source maximum cardinality',
+          target: 'Target minimum cardinality must not be greater than target maximum cardinality',
+        });
       }
     });
   }
@@ -422,7 +428,7 @@ function check( model ) {       // = XSN
       if (groupByEntry._artifact && groupByEntry._artifact._effectiveType &&
           groupByEntry._artifact._effectiveType.on) {
         // Unmanaged association - complain
-        error(null, [ groupByEntry.location, art ],
+        error(null, [ groupByEntry.location, art ], {},
               'Unmanaged associations are not allowed in GROUP BY');
       }
     }
@@ -430,7 +436,7 @@ function check( model ) {       // = XSN
       if (orderByEntry._artifact && orderByEntry._artifact._effectiveType &&
           orderByEntry._artifact._effectiveType.on) {
         // Unmanaged association - complain
-        error(null, [ orderByEntry.location, art ],
+        error(null, [ orderByEntry.location, art ], {},
               'Unmanaged associations are not allowed in ORDER BY');
       }
     }
@@ -459,7 +465,7 @@ function check( model ) {       // = XSN
       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 ],
+          error(null, [ key.location, elem ], {},
                 'Virtual elements can\'t be used as a foreign key for a managed association');
         }
       }
@@ -494,7 +500,7 @@ function check( model ) {       // = XSN
   // associations can be followed (in the ON condition)
   //
   // TODO: this function must be completely reworked, probably even before
-  // integration into name resulution - did the first step.
+  // integration into name resolution - did the first step.
   // It is also incomplete, as associations in structures are not checked.
   // Additionally, `$self.assoc` references are also not found.
   function singleCheckUnmanagedAssocCondArgumentNoFollowUnmanagedAssoc(elem, arg, op) {
@@ -517,7 +523,7 @@ function check( model ) {       // = XSN
     if (argTarget.on) {
       const same = path0._artifact === elem;
       if (!same) {
-        error(null, [ path0.location, elem ],
+        error(null, [ path0.location, elem ], {},
               'Unmanaged association condition can\'t follow another unmanaged association');
       }
     }
@@ -527,7 +533,7 @@ function check( model ) {       // = XSN
     if (op && op.val === 'xpr') // no check for xpr
       return;
     if (op && op.val !== '=')
-      error(null, [ op.location, elem ], '$self comparison is only allowed with \'=\'');
+      error(null, [ op.location, elem ], {}, '$self comparison is only allowed with \'=\'');
   }
 
   // A function like this could be part of the compiler
@@ -601,7 +607,7 @@ function check( model ) {       // = XSN
     // 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');
+        error(null, arg.location, {}, 'Virtual elements can\'t be used in an expression');
 
 
       // Recursively traverse the argument expression
@@ -624,20 +630,25 @@ 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');
+        error(null, arg.location, {}, 'Virtual elements can\'t be used in an expression');
 
       // 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(null, arg.location, {},
+                'An association can\'t be used as a value in an expression');
+        }
       }
       else if (!allowAssocTail && isAssociationOperand(arg)) {
-        error(null, arg.location, 'An association can\'t be used as a value in an expression');
+        error(null, arg.location, {},
+              'An association can\'t be used as a value in an expression');
       }
 
-      if (isDollarSelfOrProjectionOperand(arg))
-        error(null, arg.location, `"${ arg.path[0].id }" can only be used as a value in a comparison to an association`);
+      if (isDollarSelfOrProjectionOperand(arg)) {
+        error(null, arg.location, { id: arg.path[0].id },
+              '$(ID) can only be used as a value in a comparison to an association');
+      }
 
       // Recursively traverse the argument expression
       checkTreeLikeExpression(arg, allowAssocTail);
@@ -736,7 +747,9 @@ function check( model ) {       // = XSN
 
     // Element must exist in annotation
     if (!elementDecl) {
-      warning(null, anno.location || anno.name.location, `Element "${ anno.name.path.map(step => step.id).join('.') }" not found for annotation "${ annoDecl.name.absolute }"`);
+      warning(null, anno.location || anno.name.location,
+              { name: pathName(anno.name.path), anno: annoDecl.name.absolute },
+              'Element $(NAME) not found for annotation $(ANNO)');
       return;
     }
 
@@ -747,10 +760,14 @@ function check( model ) {       // = XSN
 
     // Must have literal or path unless it is a boolean
     if (!anno.literal && !anno.path && getFinalTypeNameOf(elementDecl) !== 'cds.Boolean') {
-      if (elementDecl.type && elementDecl.type._artifact.name.absolute)
-        warning(null, anno.location || anno.name.location, `Expecting a value of type "${ elementDecl.type._artifact.name.absolute }" for the annotation`);
-      else
-        warning(null, anno.location || anno.name.location, 'Expecting a value for the annotation');
+      if (elementDecl.type && elementDecl.type._artifact.name.absolute) {
+        warning(null, anno.location || anno.name.location, { type: elementDecl.type._artifact },
+                'Expecting a value of type $(TYPE) for the annotation');
+      }
+      else {
+        warning(null, anno.location || anno.name.location, {},
+                'Expecting a value for the annotation');
+      }
 
       return;
     }
@@ -775,7 +792,7 @@ function check( model ) {       // = XSN
     if (elementDecl._effectiveType.items) {
       // Make sure we have an array value
       if (value.literal !== 'array') {
-        warning(null, loc, 'An array value is required here');
+        warning(null, loc, {}, 'An array value is required here');
         return;
       }
       // Check each element
@@ -788,7 +805,7 @@ function check( model ) {       // = XSN
     // Struct expected (can only happen within arrays)?
     if (elementDecl._effectiveType.elements) {
       if (value.literal !== 'struct') {
-        warning(null, loc, 'A struct value is required here');
+        warning(null, loc, {}, 'A struct value is required here');
         return;
       }
       // FIXME: Should check each element
@@ -800,31 +817,31 @@ function check( model ) {       // = XSN
     if (builtins.isStringTypeName(type)) {
       if (value.literal !== 'string' && value.literal !== 'enum' &&
           !elementDecl._effectiveType.enum)
-        warning(null, loc, `A string value is required for type "${ type }"`);
+        warning(null, loc, { type }, 'A string value is required for type $(TYPE)');
     }
     else if (builtins.isBinaryTypeName(type)) {
       if (value.literal !== 'string' && value.literal !== 'x')
-        warning(null, loc, `A hexadecimal string value is required for type "${ type }"`);
+        warning(null, loc, { type }, 'A hexadecimal string value is required for type $(TYPE)');
     }
     else if (builtins.isNumericTypeName(type)) {
       if (value.literal !== 'number' && value.literal !== 'enum' &&
           !elementDecl._effectiveType.enum)
-        warning(null, loc, `A numerical value is required for type "${ type }"`);
+        warning(null, loc, { type }, 'A numerical value is required for type $(TYPE)');
     }
     else if (builtins.isDateOrTimeTypeName(type)) {
       if (value.literal !== 'date' && value.literal !== 'time' &&
           value.literal !== 'timestamp' && value.literal !== 'string')
-        warning(null, loc, `A date/time value or a string is required for type "${ type }"`);
+        warning(null, loc, { type }, 'A date/time value or a string is required for type $(TYPE)');
     }
     else if (builtins.isBooleanTypeName(type)) {
       if (value.literal && value.literal !== 'boolean')
-        warning(null, loc, `A boolean value is required for type "${ type }"`);
+        warning(null, loc, { type }, 'A boolean value is required for type $(TYPE)');
     }
     else if (builtins.isRelationTypeName(type) || builtins.isGeoTypeName(type)) {
-      warning(null, loc, `Type "${ type }" can't be assigned a value`);
+      warning(null, loc, { type }, 'Type $(TYPE) can\'t be assigned a value');
     }
     else {
-      throw new Error(`Unknown primitive type name: ${ type }`);
+      throw new CompilerAssertion(`Unknown primitive type name: ${ type }`);
     }
 
     // Check enums
@@ -834,19 +851,19 @@ function check( model ) {       // = XSN
         // Enum symbol provided and expected
         if (!expectedEnum[value.sym.id]) {
           // .. but no such constant
-          warning(null, loc, `Enum symbol "#${ value.sym.id }" not found in enum`);
+          warning(null, loc, { id: `#${ value.sym.id }` }, 'Enum symbol $(ID) not found in enum');
         }
       }
       else {
         // Enum symbol provided but not expected
-        warning(null, loc, `Cannot use enum symbol "#${ value.sym.id }" for non-enum type "${ type }"`);
+        warning(null, loc, { id: `#${ value.sym.id }`, type }, 'Can\'t use enum symbol $(ID) for non-enum type $(TYPE)');
       }
     }
     else if (expectedEnum) {
       // Enum symbol not provided but expected
       if (!Object.keys(expectedEnum).some(symbol => expectedEnum[symbol].value.val === value.val)) {
         // ... and none of the valid enum symbols matches the value
-        warning(null, loc, 'An enum value is required here');
+        warning(null, loc, {}, 'An enum value is required here');
       }
     }
   }