@sap/cds-compiler 3.9.2 → 4.0.0

package/lib/compiler/checks.js

@@ -16,7 +16,9 @@
 // const { hasArtifactTypeInformation } = require('../model/csnUtils')
 const builtins = require('../compiler/builtins');
 const {
-  forEachGeneric, forEachDefinition, forEachMember, isBetaEnabled,
+  forEachGeneric,
+  forEachDefinition,
+  forEachMember,
 } = require('../base/model');
 const { CompilerAssertion } = require('../base/error');
 const { pathName } = require('./utils');
@@ -457,7 +459,7 @@ function check( model ) {       // = XSN
         const key = elem.foreignKeys[k].targetElement;
         if (key && isVirtualElement(key._artifact))
           error('ref-unexpected-virtual', [ key.location, elem ], { '#': 'fkey' });
-        else if (key._artifact?.$syntax === 'calc')
+        else if (key._artifact?.$syntax === 'calc' && !key._artifact.value.stored?.val)
           error( 'ref-unexpected-calculated', [ key.location, elem ], { '#': 'fkey' } );
       }
     }
@@ -508,9 +510,6 @@ function check( model ) {       // = XSN
    * 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
@@ -590,7 +589,7 @@ function check( model ) {       // = XSN
       visitExpression(elem.on, elem, (xpr, user) => {
         checkExpressionNotVirtual(xpr, user);
         checkExpressionAssociationUsage(xpr, user, true);
-        if (xpr._artifact?.$syntax === 'calc')
+        if (xpr._artifact?.$syntax === 'calc' && !xpr._artifact.value.stored?.val)
           error( 'ref-unexpected-calculated', [ xpr.location, user ], { '#': 'on' } );
       });
       if (isDollarSelfOrProjectionOperand(elem.on)) {
@@ -612,15 +611,20 @@ function check( model ) {       // = XSN
   function checkCalculatedElementValue( elem ) {
     visitExpression(elem.value, elem, (xpr, user) => {
       if (xpr._artifact) { // we only need to check artifact references
+        const sourceLoc = xpr.path?.[xpr.path.length - 1].location || xpr.location;
         checkExpressionNotVirtual(xpr, user);
-        if (isStructuredElement(xpr._artifact))
-          error('ref-unexpected-structured', [ xpr.location, elem ], { '#': 'expr' } );
+        // For inferred (e.g. included) calc elements, this error is already emitted at the origin.
+        // And users can't change structured to non-structured elements.
+        if (!elem.$inferred && isStructuredElement(xpr._artifact))
+          error('ref-unexpected-structured', [ sourceLoc, elem ], { '#': 'expr' } );
         else if (xpr._artifact.target !== undefined)
-          error('ref-unexpected-assoc', [ xpr.location, elem ], { '#': 'expr' });
+          error('ref-unexpected-assoc', [ sourceLoc, elem ], { '#': 'expr' });
+        else if (xpr._artifact.localized?.val)
+          error('ref-unexpected-localized', [ sourceLoc, elem ], { '#': 'calc' });
       }
     });
-    // Calc elements must not refer to keys, because that may lead to another key
-    // in an SQL view, which is missing in OData.
+    // Calculated elements must not refer to keys, because that may lead to another
+    // key in an SQL view, which is missing in OData (for on-read).
     // Following associations does not lead to this issue.
     if (elem.value.path && isKeyElement(elem.value._artifact) &&
       !followsAnAssociation(elem.value.path)) {
@@ -830,7 +834,7 @@ function check( model ) {       // = XSN
 
     // Element must exist in annotation
     if (!elementDecl) {
-      warning(null, anno.location || anno.name.location,
+      warning(null, [ anno.location || anno.name.location, art ],
               { name: pathName(anno.name.path), anno: annoDecl.name.absolute },
               'Element $(NAME) not found for annotation $(ANNO)');
       return;
@@ -844,11 +848,11 @@ 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('anno-expecting-value', anno.location || anno.name.location,
+        warning('anno-expecting-value', [ anno.location || anno.name.location, art ],
                 { '#': 'type', type: elementDecl.type._artifact });
       }
       else {
-        warning('anno-expecting-value', anno.location || anno.name.location,
+        warning('anno-expecting-value', [ anno.location || anno.name.location, art ],
                 { '#': 'std', anno: anno.name.absolute });
       }
 
@@ -856,31 +860,31 @@ function check( model ) {       // = XSN
     }
 
     // Value must be assignable to type
-    checkValueAssignableTo(anno, elementDecl, art);
+    checkValueAssignableTo(anno, anno, elementDecl, art);
   }
 
   // Check that annotation assignment 'value' (having 'path or 'literal' and
   // 'val') is potentially assignable to element 'element'. Complain on 'loc'
   // if not
-  function checkValueAssignableTo( value, elementDecl, art ) {
+  function checkValueAssignableTo( annoDef, value, elementDecl, art ) {
     // FIXME: We currently do not have any element declaration that could match
     // a 'path' value, so we simply leave those alone
     if (value.path)
       return;
 
-
+    const anno = annoDef.name.absolute;
     const loc = [ value.location || value.name.location, art ];
 
     // Array expected?
     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, { anno }, 'An array value is required for annotation $(ANNO)');
         return;
       }
       // Check each element
       for (const valueItem of value.val)
-        checkValueAssignableTo(valueItem, elementDecl._effectiveType.items, art);
+        checkValueAssignableTo(value, valueItem, elementDecl._effectiveType.items, art);
 
       return;
     }
@@ -888,7 +892,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, { anno }, 'A struct value is required here for annotation $(ANNO)');
         return;
       }
       // FIXME: Should check each element
@@ -899,29 +903,41 @@ function check( model ) {       // = XSN
     const type = getFinalTypeNameOf(elementDecl);
     if (builtins.isStringTypeName(type)) {
       if (value.literal !== 'string' && value.literal !== 'enum' &&
-          !elementDecl._effectiveType.enum)
-        warning(null, loc, { type }, 'A string value is required for type $(TYPE)');
+          !elementDecl._effectiveType.enum) {
+        warning(null, loc, { type, anno },
+                'A string value is required for type $(TYPE) for annotation $(ANNO)');
+      }
     }
     else if (builtins.isBinaryTypeName(type)) {
-      if (value.literal !== 'string' && value.literal !== 'x')
-        warning(null, loc, { type }, 'A hexadecimal string value is required for type $(TYPE)');
+      if (value.literal !== 'string' && value.literal !== 'x') {
+        warning(null, loc, { type, anno },
+                'A hexadecimal string value is required for type $(TYPE) for annotation $(ANNO)');
+      }
     }
     else if (builtins.isNumericTypeName(type)) {
       if (value.literal !== 'number' && value.literal !== 'enum' &&
-          !elementDecl._effectiveType.enum)
-        warning(null, loc, { type }, 'A numerical value is required for type $(TYPE)');
+          !elementDecl._effectiveType.enum) {
+        warning(null, loc, { type, anno },
+                'A numerical value is required for type $(TYPE) for annotation $(ANNO)');
+      }
     }
     else if (builtins.isDateOrTimeTypeName(type)) {
       if (value.literal !== 'date' && value.literal !== 'time' &&
-          value.literal !== 'timestamp' && value.literal !== 'string')
-        warning(null, loc, { type }, 'A date/time value or a string is required for type $(TYPE)');
+          value.literal !== 'timestamp' && value.literal !== 'string') {
+        warning(null, loc, { type, anno },
+                // eslint-disable-next-line max-len
+                'A date/time value or a string is required for type $(TYPE) for annotation $(ANNO)');
+      }
     }
     else if (builtins.isBooleanTypeName(type)) {
-      if (value.literal && value.literal !== 'boolean')
-        warning(null, loc, { type }, 'A boolean value is required for type $(TYPE)');
+      if (value.literal && value.literal !== 'boolean') {
+        warning(null, loc, { type, anno },
+                'A boolean value is required for type $(TYPE) for annotation $(ANNO)');
+      }
     }
     else if (builtins.isRelationTypeName(type) || builtins.isGeoTypeName(type)) {
-      warning(null, loc, { type }, 'Type $(TYPE) can\'t be assigned a value');
+      warning(null, loc, { type, anno },
+              'Type $(TYPE) can\'t be assigned a value for annotation $(ANNO)');
     }
     else if (!elementDecl._effectiveType.enum) {
       throw new CompilerAssertion(`Unknown primitive type name: ${ type }`);
@@ -933,13 +949,14 @@ function check( model ) {       // = XSN
       if (expectedEnum) {
         // Enum symbol provided and expected
         if (!expectedEnum[value.sym.id]) {
-          // .. but no such constant
-          warning(null, loc, { id: `#${ value.sym.id }` }, 'Enum symbol $(ID) not found in enum');
+          // ... but no such constant
+          warning(null, loc, { id: `#${ value.sym.id }`, anno }, 'Enum symbol $(ID) not found in enum for annotation $(ANNO)');
         }
       }
       else {
         // Enum symbol provided but not expected
-        warning(null, loc, { id: `#${ value.sym.id }`, type }, 'Can\'t use enum symbol $(ID) for non-enum type $(TYPE)');
+        warning(null, loc, { id: `#${ value.sym.id }`, type, anno },
+                'Can\'t use enum symbol $(ID) for non-enum type $(TYPE) for annotation $(ANNO)');
       }
     }
     else if (expectedEnum) {
@@ -948,7 +965,7 @@ function check( model ) {       // = XSN
         .some(symbol => getEnumValue(expectedEnum[symbol]) === value.val);
       if (!hasValidValue) {
         // ... and none of the valid enum symbols matches the value
-        warning(null, loc, {}, 'An enum value is required here');
+        warning(null, loc, { anno }, 'An enum value is required for annotation $(ANNO)');
       }
     }
   }

package/lib/compiler/define.js

@@ -123,7 +123,6 @@ const {
   forEachGeneric,
   forEachInOrder,
   forEachMember,
-  isBetaEnabled,
 } = require('../base/model');
 const shuffleGen = require('../base/shuffle');
 const {
@@ -174,11 +173,6 @@ function define( model ) {
     initMembers,
     checkDefinitions,           // TODO: remove
   } );
-  // During the definer, we can only resolve artifact references, i.e,
-  // after a `.`, we only search in the `_subArtifacts` dictionary:
-  model.$volatileFunctions.environment = function artifactsEnv( art ) {
-    return art._subArtifacts || Object.create(null);
-  };
 
   let boundSelfParamType = true; // special `$self` for binding param must still be initialised
 
@@ -333,6 +327,7 @@ function define( model ) {
    * @param {XSN.SourceAst} src
    */
   function addUsing( decl, src ) {
+    setLink( decl, '_block', src );
     if (decl.usings) {
       // e.g. `using {a,b} from 'file.cds'` -> recursive
       decl.usings.forEach( u => addUsing( u, src ) );
@@ -393,7 +388,7 @@ function define( model ) {
 
   function addExtension( ext, block ) {
     setLink( ext, '_block', block );
-    const absolute = ext.name && resolveUncheckedPath( ext.name, 'extend', ext );
+    const absolute = ext.name && resolveUncheckedPath( ext.name, '_extensions', ext );
     if (!absolute)                    // broken path
       return;
     delete ext.name.path[0]._artifact; // might point to wrong JS object in phase 1
@@ -423,9 +418,11 @@ function define( model ) {
   }
 
   function initExtension( parent ) {
-    forEachMember( parent, function init( sub ) {
+    forEachMember( parent, function initExtensionMember( sub, name, prop ) {
       if (sub.kind !== 'extend' && sub.kind !== 'annotate')
         return;                 // for defs inside, set somewhere else - TODO: rethink
+      if (prop === 'params' && name === '') // RETURNS
+        sub.name = { id: '', location: sub.location };
       setLink( sub, '_block', parent._block );
       setLink( sub, '_parent', parent );
       setLink( sub, '_main', parent._main || parent );
@@ -512,7 +509,9 @@ function define( model ) {
         '#': kindProperties[art.kind].normalized || art.kind,
       } );
     }
-    else {
+    else if (!art.builtin) {
+      // TODO: better messages with definitions with the same name as builtin,
+      // especially if there is just one
       error( 'duplicate-definition', [ art.name.location, art ], {
         name: art.name.absolute,
         '#': (art.kind === 'annotation' ? 'annotation' : 'absolute' ),
@@ -555,7 +554,7 @@ function define( model ) {
         continue;
       for (const decl of entry) {
         if (!decl.$duplicates) { // do not have two duplicate messages
-          error( 'duplicate-using', [ decl.name.location, null ], { name }, // TODO: semantic
+          error( 'duplicate-using', [ decl.name.location, decl ], { name },
                  'Duplicate definition of top-level name $(NAME)' );
         }
       }
@@ -634,7 +633,6 @@ function define( model ) {
     setLink( self, '_origin', art );
     art.$tableAliases = Object.create(null);
     art.$tableAliases[selfname] = self;
-    setLink( art, '_$next', model.$magicVariables );
   }
 
   function initDollarParameters( art ) {
@@ -713,9 +711,7 @@ function define( model ) {
     function initQuery() {
       const main = art._main || art;
       setLink( query, '_$next',
-               // if art is $tableAlias, set to embedding query
-               (!art._main || art.kind === 'select' || art.kind === '$join')
-                 ? art : art._parent ); // TODO: check with name resolution change
+               (art.kind === '$tableAlias' ? art._parent._$next : art) );
       setLink( query, '_block', art._block );
       query.kind = 'select';
       query.name = { location: query.location };
@@ -819,7 +815,7 @@ function define( model ) {
         dictAddArray( p.$tableAliases, table.name.id, table );
       }
       if (table.name?.id[0] === '$' && table.name.$inferred !== '$internal') {
-        warning( 'name-invalid-dollar-alias', [ table.name.location, table ], {
+        message( 'name-invalid-dollar-alias', [ table.name.location, table ], {
           '#': (table.name.$inferred ? '$tableImplicit' : '$tableAlias'),
           name: '$',
           keyword: 'as',
@@ -841,6 +837,7 @@ function define( model ) {
   }
 
   function initExprForQuery( expr, query ) {
+    // TODO: use traverseExpr()
     if (Array.isArray(expr)) { // TODO: old-style $parens ?
       expr.forEach( e => initExprForQuery( e, query ) );
     }
@@ -876,7 +873,7 @@ function define( model ) {
           error( 'duplicate-definition', [ loc, query ], { name: dupName, '#': 'alias' } );
         } );
         if (mixin.name.id[0] === '$') {
-          warning( 'name-invalid-dollar-alias', [ mixin.name.location, mixin ],
+          message( 'name-invalid-dollar-alias', [ mixin.name.location, mixin ],
                    { '#': 'mixin', name: '$' } );
         }
       }
@@ -891,7 +888,7 @@ function define( model ) {
       if (!col)                 // parse error
         continue;
       hasItems = true;
-      if (!columns) {
+      if (!columns) {           // expand or inline
         if (parent.value)
           setLink( col, '_pathHead', parent ); // also set for '*' in expand/inline
         else if (parent._pathHead)
@@ -1059,12 +1056,14 @@ function define( model ) {
 
     function initElementsAsEnum() {
       // in extensions, extended enums are represented as elements
+      let firstEnum = null;
       for (const n in obj.elements) {
         const e = obj.elements[n];
         if (e.kind === 'element') {
           // An "element" has `$syntax: 'enum'` if it could also be an enum
           if (e.$syntax === 'enum') { // TODO: what about "just name"? (current forbidden)
             e.kind = 'enum';
+            firstEnum = firstEnum || e;
           }
           else {
             // We do not want to complain separately about all element properties:
@@ -1076,6 +1075,13 @@ function define( model ) {
           }
         }
       }
+      if (firstEnum && block.$frontend !== 'json') {
+        // Don't emit this message if `ext-unexpected-element` was already emitted.
+        // This message is similar to the one above.  In v5/6, we could probably remove the warning
+        // and always emit the error.
+        warning( 'ext-expecting-enum', [ firstEnum.location, construct ],
+                 { code: 'extend … with enum' }, 'Use $(CODE) when extending enums' );
+      }
       forEachGeneric( { enum: obj.elements }, 'enum', init );
     }
 
@@ -1166,10 +1172,6 @@ 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';
     }
   }
@@ -1190,8 +1192,11 @@ function define( model ) {
     }
     const first = params[Object.keys( params )[0] || ''];
     const type = first?.type || first?.items?.type; // this sequence = no derived type
-    if (type?.path?.length === 1 && type?.path[0]?.id === '$self') // TODO: no where: ?
+    const path = type?.path;
+    if (path?.length === 1 && path[0]?.id === '$self') { // TODO: no where: ?
       setLink( type, '_artifact', boundSelfParamType );
+      setLink( path[0], '_artifact', boundSelfParamType );
+    }
   }
 
   // To be reworked -------------------------------------------------------------
@@ -1212,11 +1217,11 @@ function define( model ) {
       return true;
     const location = dict[$location];
     if (prop === 'actions') {
-      error( 'unexpected-actions', [ location, construct ], {},
+      error( 'def-unexpected-actions', [ location, construct ], {},
              'Actions and functions only exist top-level and for entities' );
     }
     else if (parent.kind === 'action' || parent.kind === 'function') {
-      error( 'extend-action', [ construct.location, construct ], { '#': parent.kind }, {
+      error( 'ext-unexpected-action', [ construct.location, construct ], { '#': parent.kind }, {
         std: 'Actions and functions can\'t be extended, only annotated',
         action: 'Actions can\'t be extended, only annotated',
         function: 'Functions can\'t be extended, only annotated',
@@ -1254,7 +1259,7 @@ function define( model ) {
       error( 'extend-columns', [ location, construct ], { art: construct } );
     }
     else { // if (prop === 'enum') {
-      error( 'unexpected-enum', [ location, construct ], {},
+      error( 'def-unexpected-enum', [ location, construct ], {},
              'Enum symbols can only be defined for types or typed constructs' );
     }
     return construct === parent;
@@ -1270,7 +1275,7 @@ function define( model ) {
     }
     if (elem.targetAspect || options.parseCdl || !isDirectComposition( elem ))
       return false;
-    const name = resolveUncheckedPath( target, 'compositionTarget', elem );
+    const name = resolveUncheckedPath( target, 'target', elem );
     const aspect = name && model.definitions[name];
     return aspect && (aspect.kind === 'aspect' || aspect.kind === 'type'); // type is sloppy
   }