@sap/cds-compiler 6.9.3 → 7.0.1

package/lib/compiler/assert-consistency.js

@@ -110,6 +110,7 @@ function assertConsistency( model, stage ) {
         '$functions',
         '$assert',
         '_sortedSources',
+        '_associations',        // backlink associations
       ],
     },
     ':parser': {                // top-level from parser
@@ -268,6 +269,7 @@ function assertConsistency( model, stage ) {
       also: [ false ],
     },
     $keysNavigation: { kind: true, test: TODO },
+    $backlink: { kind: true, test: TODO },
     $filtered: { kind: true, inherits: 'value' }, // for assoc+filter
     $enclosed: { kind: true, inherits: 'value' }, // for comp+filter
     params: { kind: true, inherits: 'definitions' },
@@ -375,7 +377,7 @@ function assertConsistency( model, stage ) {
       requires: [ 'location' ],
       optional: [
         'path', 'elements', '_outer', '_parent', '_main', '_block', 'kind',
-        'scope', '_artifact', '$inferred', '$expand', '$inCycle',
+        'scope', '_artifact', '$inferred', '$expand', '$inCycle', '$backlink',
         '$tableAliases', '_$next',
         '_origin', '_effectiveType', '$effectiveSeqNo', '_extensions', '$contains',
       ],
@@ -429,7 +431,7 @@ function assertConsistency( model, stage ) {
       kind: [ 'entity', 'view', 'type', 'aspect' ],
       test: isString,            // CSN parser should check for 'entity', 'view', 'projection'
     },
-    $tokenTexts: {
+    $tokenTexts: {              // TODO: rename to $isExpression
       parser: true,
       test: isStringOrBool,
     },
@@ -498,7 +500,7 @@ function assertConsistency( model, stage ) {
         'literal', 'val', 'sym', 'struct', 'variant', 'path', 'name', '$duplicates', 'upTo',
         // expressions as annotation values
         '$tokenTexts', 'op', 'args', 'func', '_artifact', 'type', '$typeArgs',
-        'scale', 'srid', 'length', 'precision', 'scope', '$parens',
+        'scale', 'srid', 'length', 'precision', 'scope', '$parens', '$errorReported',
         '_block', '_outer',     // for annotation assignments
       ],
       // TODO: restrict path to #simplePath
@@ -567,9 +569,20 @@ function assertConsistency( model, stage ) {
     expectedKind: { kind: [ 'extend' ], test: locationVal( isString ) },
     virtual: { kind: true, test: locationVal() },
     key: { kind: true, test: locationVal(), also: [ null, undefined ] },
-    masked: { kind: true, test: locationVal() },
     notNull: { kind: true, test: locationVal() },
-    includes: { kind: true, inherits: 'type', test: isArray() },
+    includes: {
+      kind: true,
+      test: isArray(),
+      inherits: 'type',
+      optional: [
+        'path', 'scope', '_artifact', '$inferred', '$postponeInclude',
+      ],
+    },
+    $postponeInclude: {
+      kind: true,
+      parser: true,
+      test: isNumber,
+    },
     returns: {
       kind: [ 'action', 'function' ],
       requires: [ 'kind', 'location' ],
@@ -677,6 +690,7 @@ function assertConsistency( model, stage ) {
     _projections: { kind: true, test: TODO },
     _complexProjections: { kind: true, test: TODO }, // for projected paths with filters
     _entities: { test: TODO },
+    _associations: { test: TODO },
     $compositionTargets: { test: isDictionary( isBoolean ) },
     $collectedExtensions: { test: TODO },
     _upperAspects: { kind: [ 'type', 'entity' ], test: isArray( TODO ) },

package/lib/compiler/checks.js

@@ -565,7 +565,8 @@ function check( model ) {
   }
 
   function checkDefaultValue( art ) {
-    if (!art._effectiveType)
+    const effective = art._effectiveType;
+    if (!effective)
       return;
     if (art.kind !== 'element' && art.kind !== 'type' && art.kind !== 'param')
       return;
@@ -590,21 +591,37 @@ function check( model ) {
       }
     }
 
-    const isMap = art._effectiveType?.name.id === 'cds.Map';
-    if (isMap) {
-      error( 'type-unexpected-default', [ defaultValue.location, art ], {
-        '#': 'map', keyword: 'default', type: 'cds.Map',
-      } );
+    if (effective.elements) {
+      const kind = art.type?._artifact?.kind;
+      const isEntity = (kind === 'entity' || kind === '$self');
+      if (isEntity || Object.keys( effective.elements ).length !== 1) {
+        message( 'type-unexpected-default-struct', [ defaultValue.location, art ], {
+          '#': (isEntity ? kind : art.kind), keyword: 'default',
+        }, {
+          std: 'Unexpected $(KEYWORD) for a structure',
+          // eslint-disable-next-line @stylistic/max-len
+          param: 'Unexpected $(KEYWORD) for a structured parameter with not exactly one sub element',
+          // eslint-disable-next-line @stylistic/max-len
+          type: 'Unexpected $(KEYWORD) for a structured type definition with not exactly one element',
+          // eslint-disable-next-line @stylistic/max-len
+          element: 'Unexpected $(KEYWORD) for a structured element with not exactly one sub element',
+          $self: 'Unexpected $(KEYWORD) for a binding parameter',
+          entity: 'Unexpected $(KEYWORD) for an entity-typed parameter',
+        } );
+      }
     }
-    else if (art._effectiveType?.elements) {
-      // TODO: error for v7
-      warning( 'type-unexpected-default-struct', [ defaultValue.location, art ], {
-        '#': art.kind, keyword: 'default',
+    else if (effective.items) {
+      const kind = art.items?.type?._artifact?.kind;
+      message( 'type-unexpected-default-array', [ defaultValue.location, art ], {
+        '#': (kind === '$self' ? kind : 'std'), keyword: 'default',
       }, {
-        std: 'Unexpected $(KEYWORD) for a structure',
-        param: 'Unexpected $(KEYWORD) for a structured parameter',
-        type: 'Unexpected $(KEYWORD) for a structured type definition',
-        element: 'Unexpected $(KEYWORD) for a structured element',
+        std: 'Unexpected $(KEYWORD) for an array',
+        $self: 'Unexpected $(KEYWORD) for a binding parameter',
+      } );
+    }
+    else if (effective.name.id === 'cds.Map') {
+      error( 'type-unexpected-default', [ defaultValue.location, art ], {
+        '#': 'map', keyword: 'default', type: 'cds.Map',
       } );
     }
   }
@@ -1008,30 +1025,11 @@ function check( model ) {
     return false;
   }
 
-  /**
-   * Returns true if the given annotation accepts expressions as values.
-   *
-   * @param {object} anno
-   * @param {XSN.Artifact} art
-   * @returns {boolean}
-   */
-  function checkAnnotationAcceptsExpressions( anno, art ) {
-    const name = anno.name?.id;
-    if (!name)
-      return true;
-    if (!propagationRules[`@${ name }`] || acceptsExprValues[`@${ name }`])
-      return true;
-    error( 'anno-unexpected-expr', [ anno.location, art ], { anno: name },
-           'Unexpected expression as value for $(ANNO)' );
-    return false;
-  }
-
   function checkAnnotationAssignment1( art, anno ) {
     const name = anno.name?.id;
-    if (art.$contains?.$annotation && anno.kind === '$annotation' && anno._outer) {
-      if (checkAnnotationAcceptsExpressions( anno, art ))
-        checkAnnotationExpressions( anno, art );
-    }
+    const forbid = name && propagationRules[`@${ name }`] &&
+      !acceptsExprValues[`@${ name }`];
+    checkAnnotationExpressions( anno, art, forbid && name );
 
     // Has been slightly adapted for model.vocabularies but comments need to be
     // adapted, etc.
@@ -1142,16 +1140,22 @@ function check( model ) {
   /**
    * Check the expressions inside annotations.
    */
-  function checkAnnotationExpressions( anno, art ) {
-    if (anno.$tokenTexts) {
-      checkGenericExpression( anno, art, null, 'anno' );
+  function checkAnnotationExpressions( anno, art, forbid ) {
+    if (!anno.sym && anno.$tokenTexts) {
+      if (forbid) {
+        error( 'anno-unexpected-expr', [ anno.location, art ], { anno: forbid },
+               'Unexpected expression as value for $(ANNO)' );
+      }
+      else {
+        checkGenericExpression( anno, art, null, 'anno' );
+      }
     }
     else if (anno.literal === 'array') {
-      anno.val.forEach( val => checkAnnotationExpressions( val, art ) );
+      anno.val.forEach( val => checkAnnotationExpressions( val, art, forbid ) );
     }
     else if (anno.literal === 'struct') {
       const struct = Object.values(anno.struct);
-      struct.forEach(val => checkAnnotationExpressions( val, art ));
+      struct.forEach(val => checkAnnotationExpressions( val, art, forbid ));
     }
   }
 
@@ -1246,8 +1250,8 @@ function check( model ) {
     if (value.literal === 'enum') {
       if (expectedEnum) {
         // Enum symbol provided and expected
-        if (!expectedEnum[value.sym.id]) {
-          // ... but no such constant
+        if (!expectedEnum[value.sym.id] && value.sym._artifact === undefined) {
+          // ... but no such constant and not yet reported
           warning( null, loc, { id: `#${ value.sym.id }`, anno }, 'Enum symbol $(ID) not found in enum for annotation $(ANNO)' );
         }
       }

package/lib/compiler/define.js

@@ -213,9 +213,9 @@ function define( model ) {
     addI18nBlocks();            // TODO: part of extend.js?
 
     const { $self } = model.definitions;
-    if ($self && $self.kind !== 'namespace') { // TODO v7: non-config error
-      message( 'name-deprecated-$self', [ $self.name.location, $self ], { name: '$self' },
-               'Do not use $(NAME) as name for an artifact definition' );
+    if ($self && $self.kind !== 'namespace') {
+      error( 'name-deprecated-$self', [ $self.name.location, $self ], { name: '$self' },
+             'Do not use $(NAME) as name for an artifact definition' );
     }
   }
 
@@ -279,7 +279,7 @@ function define( model ) {
 
   function addMainArtifact( art, block, prefix ) {
     setLink( art, '_block', block );
-    initExprAnnoBlock( art, block );
+    initExprAnnoBlock( art, block, error ); // TODO: why also here?
     art.name.id ??= prefix + pathName( art.name.path );
     const absolute = art.name.id;
     // TODO: check reserved, see checkName()/checkLocalizedObjects() of checks.js
@@ -394,7 +394,7 @@ function define( model ) {
 
   function addExtension( ext, block ) {
     setLink( ext, '_block', block );
-    initExprAnnoBlock( ext, block );
+    initExprAnnoBlock( ext, block, error );
     const absolute = ext.name && resolveUncheckedPath( ext.name, '_uncheckedExtension', ext );
     if (!absolute)                    // broken path
       return;
@@ -1048,7 +1048,7 @@ function define( model ) {
   function initMembers( parent ) {
     // TODO: combine with initMembers() - better structuring
     const block = parent._block;
-    initExprAnnoBlock( parent, block );
+    initExprAnnoBlock( parent, block, error );
     const obj = initItemsLinks( parent, block );     // down many / array of
 
     if (obj.scale && !obj.precision &&