@sap/cds-compiler 5.9.4 → 6.0.12

package/lib/compiler/resolve.js

@@ -143,10 +143,6 @@ function resolve( model ) {
         const msg = semanticLoc && 'target';
         error( 'ref-cyclic', [ location, semanticLoc || user ], {
           art, '#': msg,
-        }, {
-          std: 'Illegal circular reference to $(ART)',
-          element: 'Illegal circular reference to element $(MEMBER) of $(ART)',
-          target: 'Illegal circular reference to target $(ART)',
         } );
       }
     } );
@@ -1172,12 +1168,24 @@ function resolve( model ) {
     return [ null, '$navElement', '$tableAlias' ][path.length] === (kind || true) && elem._origin;
   }
 
-  function addImplicitForeignKeys( art, obj, target ) {
+  function isQuasiVirtualAssociation( art ) {
+    if (art.on)
+      return false;
+    if (art.foreignKeys != null)
+      return !art.foreignKeys;
     const max = art.cardinality?.targetMax;
-    if (max && (typeof max.val !== 'number' || max.val > 1) &&
-        !art.$inferred && !art.virtual?.val) {
-      warning( 'assoc-incomplete-to-many', [ max.location, art ], null,
-               'Provide an ON-condition or foreign keys to this to-many association' );
+    return max && (typeof max.val !== 'number' || max.val > 1);
+  }
+
+  function addImplicitForeignKeys( art, obj, target ) {
+    if (!art.$inferred && !art.virtual?.val && isQuasiVirtualAssociation( obj )) {
+      if (!isDeprecatedEnabled( options, 'noQuasiVirtualAssocs' )) {
+        // TODO: set `foreignKeys`, `ON` or `virtual` to false or similar to
+        // indicate that it is already handled (and that we might not be able to
+        // follow the assoc)?  Let us set foreignKeys to false
+        obj.foreignKeys = false;
+        return;               // no foreign keys for `Association to many Target`;
+      }
     }
     obj.foreignKeys = Object.create( null );
     forEachInOrder( target, 'elements', ( elem, name ) => {
@@ -1306,6 +1314,8 @@ function resolve( model ) {
             'The redirected target is the original $(ART)' );
     }
 
+    // No check with user-provided ON/fKeys (remark: compiler deduceds ON/fKeys
+    // _after_ redirecting the target = no $inferred test necessary):
     if (elem.foreignKeys || elem.on)
       return;          // TODO: or should we still bring an msg if nothing in common?
 
@@ -1456,19 +1466,35 @@ function resolve( model ) {
     }
   }
 
-  function resolveAnnoExpr( expr, art, anno = expr ) {
+  function resolveAnnoExpr( expr, art, anno = expr, topItem = false ) {
     if (expr.$tokenTexts) {
-      if (!anno.kind)
+      if (anno === expr) {
         initAnnotationForExpression( anno, art );
+      }
+      else if (topItem) {     // item of top-level array annotation
+        setLink( expr, '_outer', anno );
+        anno = expr;
+      }
+
       const type = anno === expr && anno.name;
       // TODO: it might be best to set an _artifact link also for property values
       // like in `@Anno: [ { foo: #EnumSymbol }]
       resolveExpr( expr, 'annotation', anno, type );
     }
     else if (expr.literal === 'array') {
-      expr.val.forEach( val => resolveAnnoExpr( val, art, anno ) );
+      const withExpr = anno === expr &&
+        // the following is needed for checkAnnotationAcceptsExpressions(),
+        // otherwise @cds.persistence.skip: [hdi, hdbcds, sql.postgres] fails
+        expr.val.some( item => item.$tokenTexts || item.literal === 'struct');
+      if (withExpr)
+        initAnnotationForExpression( anno, art );
+      expr.val.forEach( val => resolveAnnoExpr( val, art, anno, withExpr ) );
     }
     else if (expr.literal === 'struct') {
+      if (topItem) {     // item of top-level array annotation
+        setLink( expr, '_outer', anno );
+        anno = expr;
+      }
       Object.values( expr.struct ).forEach( val => resolveAnnoExpr( val, art, anno ) );
     }
   }
@@ -1480,10 +1506,9 @@ function resolve( model ) {
    * @param {XSN.Artifact} art
    */
   function initAnnotationForExpression( anno, art ) {
-    anno.kind = '$annotation';
     setLink( anno, '_outer', art );
     art.$contains ??= {};
-    art.$contains.$annotation = { // set in resolveExprNode
+    art.$contains.$annotation ??= { // set in resolveExprPath
       $path: false,
       $self: false,
     };
@@ -1491,6 +1516,9 @@ function resolve( model ) {
     // Might be useful for future recursive types.
   }
 
+  // Note: for annotation assignments, `art` should be the annotation, not the
+  // assignee (element, ...); otherwise, artifact links could be resolved in the
+  // wrong block
   function resolveExpr( expr, exprCtx, art, type = null ) {
     traverseTypedExpr( expr, exprCtx, art, type, resolveExprNode );
   }
@@ -1543,8 +1571,12 @@ function resolve( model ) {
     const ref = resolvePath( expr, expected, user );
 
     if (expected === 'annotation') {
-      user._outer.$contains.$annotation.$path = true;
-      user._outer.$contains.$annotation.$self ||= expr.path[0]?._navigation?.kind === '$self';
+      const ruser = (user._outer.kind === '$annotation')
+        ? user._outer._outer
+        : user._outer;
+      // if (!ruser.$contains) console.log('UO:',!!ruser,!!user._block,user._outer)
+      ruser.$contains.$annotation.$path = true;
+      ruser.$contains.$annotation.$self ||= expr.path[0]?._navigation?.kind === '$self';
     }
 
     // check whether arguments and filters are allowed on last path item;
@@ -1562,9 +1594,10 @@ function resolve( model ) {
     const art = type && (type.kind === 'entity' ? type : type.target?._artifact);
     if (!art)
       return ref;               // error already reported via resolvePathItem()
-    const unexpectedFilter = expected !== 'column' && expected !== 'calc';
+    const unexpectedFilter = expected !== 'column' && expected !== 'calc' && 'std' ||
+          isQuasiVirtualAssociation( type ) && 'model-only';
     if (last.args || last.where || last.cardinality)
-      reportUnexpectedArgsAndFilter( last, expected, user, art, unexpectedFilter && 'std' );
+      reportUnexpectedArgsAndFilter( last, expected, user, art, unexpectedFilter );
     // TODO: we should have different message-ids for the "last" stuff: adding
     // `.item` likely corrects the ref, probably with location at end of ref
     return ref;
@@ -1622,12 +1655,12 @@ function resolve( model ) {
   function resolveEnumSymbol( expr, expected, user, type ) {
     const { sym } = expr;
     // CSN input with both '#'+val (recompilation) → do not resolve
-    if (!sym || expr.val !== undefined || !type)
+    if (!sym || expr.val !== undefined)
       return;
     // The parameter def for an argument, and the annotation def for an assignment
     // is in `type._artifact`, it is not `type` itself:
-    type = effectiveType( type.id ? type._artifact : type );
-    // Remark: do not use `?.`, type could be 0 for cyclic parameter type
+    type = type && effectiveType( type.id ? type._artifact : type );
+    // Remark: type could be 0 for cyclic parameter type
     if (type && type.foreignKeys) {
       const keys = Object.values( type.foreignKeys );
       if (keys.length === 1) {
@@ -1636,11 +1669,14 @@ function resolve( model ) {
       }
     }
     const symbols = type && type.enum;
-    if (!symbols)
-      return;
-
-    // TODO: or warning if enum symbol but non-enum type?
-    if (symbols[sym.id]) {
+    if (!symbols) {
+      if (user.kind !== '$annotation') { // TODO: better type deduction for annotations
+        const msg = (user.kind === 'enum') ? 'symbolDef' : type && 'invalidType';
+        warning( 'ref-unexpected-enum', [ expr.location, user ],
+                 { '#': msg || 'untyped', enum: sym.id, type: type || '' } );
+      }
+    }
+    else if (symbols[sym.id]) {
       setLink( sym, '_artifact', symbols[sym.id] );
     }
     else {
@@ -1649,8 +1685,7 @@ function resolve( model ) {
         type = getOrigin( type );
       const err = message( 'ref-undefined-enum', [ sym.location, user ],
                            { id: sym.id, type } );
-      if (options.newParser || options.newparser)
-        attachAndEmitValidNames( err, symbols );
+      attachAndEmitValidNames( err, symbols );
     }
   }
 
@@ -1662,7 +1697,7 @@ function resolve( model ) {
     if ((step.where || step.cardinality) && variant) {
       const location = combinedLocation( step.where, step.cardinality );
       // XSN TODO: filter$location including […]
-      message( 'expr-unexpected-filter', [ location, user ], { '#': variant } );
+      error( 'expr-unexpected-filter', [ location, user ], { '#': variant } );
     }
     return variant && traverseExpr.SKIP;
   }

package/lib/compiler/shared.js

@@ -775,8 +775,13 @@ function fns( model ) {
     if (head._artifact !== undefined)
       return head._artifact;
     let ruser = user._user || user; // TODO: nicer name if we keep this
-    if (ruser.kind === '$annotation')
-      ruser = ruser._outer;
+    // TODO: re-think _user link
+    if (ruser._outer && !semantics.isMainRef) {
+      if (ruser.kind === '$annotation')
+        ruser = ruser._outer;     // for elem refs, use elem as real "user"
+      else if (ruser._outer.kind === '$annotation')
+        ruser = ruser._outer._outer;
+    }
 
     // Handle expand/inline, `type of`, :param, global (internally for CDL):
     if (user._columnParent && !semantics.isMainRef) { // in expand/inline
@@ -1002,7 +1007,8 @@ function fns( model ) {
         // TODO: remove again, should be easy enough in to-csn without.
         if (path.length === 1 && art.kind === '$tableAlias')
           (user._user || user).$noOrigin = true;
-        if (head.id === '$projection' && user.kind === '$annotation') {
+        if (head.id === '$projection' &&
+            (user.kind === '$annotation' || user._outer?.kind === '$annotation')) {
           error( 'ref-unsupported-projection', [ head.location, user ],
                  { code: '$projection', newcode: '$self' },
                  '$(CODE) is not supported in annotations; replace by $(NEWCODE)' );
@@ -1286,6 +1292,8 @@ function fns( model ) {
     if (!user.elements && !user.actions && !user.enum && !user.params &&
         couldBeDraftsEntity( item.id, valid, prev, path ))
       return;
+    if (couldBeDraftAdminDataEntity( item ) )
+      return;
     signalNotFound( (valid.length > 1 ? 'ext-undefined-art' : 'ext-undefined-def'),
                     // TODO: ext-undefined-xyz
                     [ item.location, user ], valid, { art } );
@@ -1293,11 +1301,15 @@ function fns( model ) {
 
   function couldBeDraftsEntity( id, valid, prev, path ) {
     const entity = prev
-      ? prev === path[path.length - 2]._artifact && prev
+      ? prev === path[path.length - 2]._artifact && prev // TODO: Should check for '.drafts'?
       : path.length === 1 && id.endsWith( '.drafts' ) && model.definitions[id.slice( 0, -7 )];
     return entity?.kind === 'entity' && !!entity._service;
   }
 
+  function couldBeDraftAdminDataEntity( item ) {
+    return item.id === 'DraftAdministrativeData' && !item._artifact;
+  }
+
   function undefinedParam( user, head, valid, _dict, _art, _path, semantics ) {
     // TODO: text variant if there are no parameters, or in artifactParameters()
     // TODO: use prepared message variants

package/lib/compiler/tweak-assocs.js

@@ -274,7 +274,7 @@ function tweakAssocs( model ) {
     // target -> avoid infloop ourselves with _status.
     // TODO: this should be good now
     const chain = [];
-    while (!elem.on && !elem.foreignKeys) {
+    while (!elem.on && elem.foreignKeys == null) {
       chain.push( elem );
       if (elem._status === 'rewrite') { // circular dependency (already reported)
         for (const e of chain)

package/lib/compiler/utils.js

@@ -126,7 +126,7 @@ function proxyCopyMembers( art, dictProp, originDict, location, kind, tmpDepreca
       if (kind)
         member.kind = kind;
       else if (origin.key && !tmpDeprecated)
-        // TODO(v6): remove tmpDeprecated once `noKeyPropagationWithExpansions` is removed
+        // TODO(v6): remove tmpDeprecated once `_noKeyPropagationWithExpansions` is removed
         member.key = Object.assign( { $inferred: 'expanded' }, origin.key );
       if (kind && origin.masked)  // TODO: remove!
         member.masked = Object.assign( { $inferred: 'nav' }, origin.masked );

package/lib/edm/annotations/edmJson.js

@@ -83,7 +83,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     });
     delete parent[op];
   };
-  const noOp = () => (true);
+  const noOp = () => {};
   //----------------------------------
   // Create the transformer dictionary
   const transform = {
@@ -96,7 +96,6 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     isNull: (p, o) => notADynExpr(p, o, null, null, null, null, 'is null'),
     isNotNull: (p, o) => notADynExpr(p, o, null, null, null, null, 'is not null'),
     exists: notADynExpr,
-    '#': notADynExpr,
     SELECT: notADynExpr,
     SET: (p, o) => notADynExpr(p, o, null, null, null, null, 'UNION'),
     like: notADynExpr,
@@ -312,8 +311,16 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     else
       parentparent[parentprop] = xpr;
   };
+  transform['#'] = (parent, prop, xpr, csnPath, parentParent, parentprop, txt) => {
+    if (parent['#'] && parent.val) // enum reference that was resolved by the compiler
+      delete parent['#'];
+    else
+      notADynExpr(parent, prop, xpr, csnPath, parentParent, parentprop, txt);
+  };
   transform.ref = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
-    if (xpr.some(ps => ps.args || ps.where)) {
+    // until empty filter syntax is introduced for the annotation expressions,
+    // we ignore the filters in order to generate EDMX
+    if (xpr.some(ps => ps.args/* || ps.where */)) {
       error('odata-anno-xpr-ref', location, {
         anno, elemref: parent, '#': 'args',
       });
@@ -492,23 +499,21 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
           const td = EdmPrimitiveTypeMap[typeDef];
           if (td) {
             if (td.v2 !== options.isV2() && td.v4 !== options.isV4()) {
-              message('odata-spec-violation-type', location,
+              message('odata-unexpected-edm-type', location,
                       {
                         anno,
                         type: typeDef,
                         version: (options.isV4() ? '4.0' : '2.0'),
-                        '#': 'incompatible_anno',
+                        '#': 'anno',
                       });
             }
             evalArgs(td, typeFacets, typeDef);
             EdmTypeFacetNames.forEach((facetName) => {
               const facetDef = EdmTypeFacetMap[facetName];
-              const optional
-              = (facetDef.optional !== undefined)
-                ? (Array.isArray(facetDef.optional)
+              const optional = (facetDef.optional !== undefined) &&
+                (Array.isArray(facetDef.optional)
                   ? facetDef.optional.includes(typeDef)
-                  : facetDef.optional)
-                : false;
+                  : facetDef.optional);
 
               if (td[facetName]) {
                 // ignore facets that are not type relevant
@@ -516,13 +521,13 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
                 const facetArgs = typeFacets.filter(arg => arg.func === facetName || arg.func === `$${ facetName }`);
 
                 if (facetArgs.length === 0 && !optional && (options.isV2() === facetDef.v2 || options.isV4() === facetDef.v4)) {
-                  message('odata-spec-violation-type', location,
+                  message('odata-unexpected-edm-facet', location,
                           {
                             anno,
                             type: typeDef,
                             name: facetName,
                             version: (options.isV4() ? '4.0' : '2.0'),
-                            '#': 'facet_anno',
+                            '#': 'anno',
                           });
                 }
                 else if (facetArgs.length > 1) {
@@ -566,14 +571,12 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
                 const precision = Number.parseInt(parent.$Precision, 10);
                 const scale = Number.parseInt(parent.$Scale, 10);
                 if (!Number.isNaN(precision) && !Number.isNaN(scale) && scale > precision) {
-                  message('odata-spec-violation-type', location,
-                          {
-                            anno,
-                            type: typeDef,
-                            number: scale,
-                            rawvalue: precision,
-                            '#': 'scale_anno',
-                          });
+                  message('odata-invalid-scale', location, {
+                    '#': 'anno',
+                    anno,
+                    number: scale,
+                    rawvalue: precision,
+                  });
                 }
               }
               if (options.isV2() && parent.$Scale === 'variable') {

package/lib/edm/annotations/genericTranslation.js

@@ -267,7 +267,8 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
 
     Object.entries(cObject.actions).forEach(([ n, action ]) => {
       setProp(action, '$isBound', true);
-      const actionName = `${ serviceName }.${ isV2() ? `${ entityName }_` : '' }${ n }`;
+      const v2entity = isV2() ? `${ entityName }_` : '';
+      const actionName = `${ serviceName }.${ v2entity }${ n }`;
       handleAction(actionName, action, cObjectname, [ ...location, 'actions', n ]);
     });
   }
@@ -852,14 +853,13 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
 
       termNameWithoutQualifiers.split('.').forEach((id) => {
         if (!edmUtils.isODataSimpleIdentifier(id))
-          message('odata-spec-violation-id', msg.location, { id });
+          message('odata-invalid-name', msg.location, { id });
       });
       newAnno = new Edm.Annotation(v, termNameWithoutQualifiers);
       if (qualifier?.length) {
-        if (!edmUtils.isODataSimpleIdentifier(qualifier)) {
-          message('odata-spec-violation-id', msg.location,
-                  { id: qualifier, '#': 'qualifier' });
-        }
+        if (!edmUtils.isODataSimpleIdentifier(qualifier))
+          message('odata-invalid-qualifier', msg.location, { id: qualifier });
+
         newAnno.setEdmAttribute('Term', termNameWithoutQualifiers);
         newAnno.setEdmAttribute('Qualifier', qualifier);
       }
@@ -1428,7 +1428,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       //   in a record or term
       if (Array.isArray(value)) {
         message('odata-anno-value', msg.location,
-                { anno: msg.anno(), '#': 'nestedcollection' });
+                { anno: msg.anno(), '#': 'nestedCollection' });
       }
       else if (value && typeof value === 'object') {
         if (value['=']) {
@@ -1439,7 +1439,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
         }
         else if (value['#']) {
           message('odata-anno-value', msg.location,
-                  { anno: msg.anno(), '#': 'enumincollection' });
+                  { anno: msg.anno(), '#': 'enuminCollection' });
         }
         else if (value.$edmJson) {
           newCollection.append(handleEdmJson(value.$edmJson, msg));
@@ -1663,7 +1663,9 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
         message('odata-anno-dict', msg.location, { anno: msg.anno(), '#': 'experimental' });
         usedExperimentalTerms[termName] = true;
       }
-      if (dictTerm.$deprecated && !usedDeprecatedTerms[termName]) {
+      // TODO: remove this part "&& termName !== 'Common.DraftNode'" once the annotation is not part
+      // of the dictionaries
+      if (dictTerm.$deprecated && !usedDeprecatedTerms[termName] && termName !== 'Common.DraftNode') {
         message('odata-anno-def', msg.location,
                 { anno: msg.anno(), depr: dictTerm.$deprecationText, '#': 'deprecated' });
         usedDeprecatedTerms[termName] = true;
@@ -1774,7 +1776,7 @@ function mergeOdataVocabularies( options, message ) {
             defOk = false;
           }
           else if (name === 'Alias' && !edmUtils.isODataSimpleIdentifier(def[name])) {
-            message('odata-spec-violation-id', null, { id: name, value: def[name], '#': 'vocRefAlias' });
+            message('odata-invalid-vocabulary-alias', null, { id: name, value: def[name] });
             defOk = false;
           }
         });