@sap/cds-compiler 2.15.2 → 3.0.2

package/lib/compiler/shared.js

@@ -11,6 +11,7 @@ const {
   setArtifactLink,
   dependsOn,
   pathName,
+  annotationHasEllipsis,
 } = require('./utils');
 
 function artifactsEnv( art ) {
@@ -512,7 +513,7 @@ function fns( model ) {
     if (args.length > 0) {
       const loc = [ args[args.length - 1].location, user ];
       if (typeArtifact.builtin)
-        warning( 'type-ignoring-argument', loc, { art: typeArtifact } );
+        message( 'type-ignoring-argument', loc, { art: typeArtifact } );
       else
         error( 'type-unexpected-argument', loc, { '#': 'std', art: typeArtifact });
     }
@@ -673,6 +674,9 @@ function fns( model ) {
         art = item._artifact;
         if (Array.isArray(art))
           return false;
+        if (art.$requireElementAccess && path.length === 1)
+          // Path with only one item, but we expect an element, e.g. `$at.from`.
+          signalMissingElementAccess(art, [ item.location, user ]);
         continue;
       }
 
@@ -808,11 +812,30 @@ function fns( model ) {
       attachAndEmitValidNames(err, ...valid.reverse());
   }
 
+  /**
+   * Emit a 'ref-expected-element' error for magic variable references
+   * that require element accesses but don't do.
+   * For example: `$at`, but `$at.from` or `$at.to` is required.
+   *
+   * @param {object} art
+   * @param {any} location
+   */
+  function signalMissingElementAccess(art, location) {
+    const err = message( 'ref-expected-element', location,
+                         { '#': 'magicVar', id: art.name.id } );
+    // Mapping for better valid names: from -> $at.from
+    const valid = Object.keys(art.elements || {}).reduce((prev, curr) => {
+      prev[`${ art.name.id }.${ curr }`] = true;
+      return prev;
+    }, Object.create(null));
+    attachAndEmitValidNames(err, valid);
+  }
+
   /**
    * Attaches a dictionary of valid names to the given compiler message.
    * In test mode, an info message is emitted with a list of valid names.
    *
-   * @param {CSN.Message} msg CDS Compiler message
+   * @param {CompileMessage} msg CDS Compiler message
    * @param  {...object} validDicts One ore more artifact dictionaries such as in `_block`.
    */
   function attachAndEmitValidNames(msg, ...validDicts) {
@@ -838,14 +861,10 @@ function fns( model ) {
     }
   }
 
-  // Resolve all annotation assignments for the node `art`.  Set `art.@` to all
-  // flattened assignments.  This function might issue error message for
-  // duplicate assignments.
-  // TODOs:
-  // * do something for extensions by CSN or Properties parsers
-  // * make sure that we do not issue repeated warnings due to flattening if an
-  //   annotation definition is missing
-  function defineAnnotations( construct, art, block, priority = 'define' ) {
+  // Set _block links for annotations (necessary for layering).
+  // Issue messages for annotations on namespaces and builtins (TODO: really here?)
+  // Also copy annotations from `construct` to `art` (TODO: separate that functionality).
+  function defineAnnotations( construct, art, block, priority = false ) {
     if (!options.parseCdl && construct.kind === 'annotate') {
       // Namespaces cannot be annotated in CSN but because they exist as XSN artifacts
       // they can still be applied. Namespace annotations are extracted in to-csn.js
@@ -862,77 +881,38 @@ function fns( model ) {
         info( 'anno-builtin', [ construct.name.location, construct ], {},
               'Builtin types should not be annotated. Use custom type instead' );
       }
-    }
-    // TODO: block should be construct._block
-    if (construct.$annotations && construct.$annotations.doc )
-      art.doc = construct.$annotations.doc; // e.g. through `annotate` statement in CDL
-    else if (construct.doc)
-      art.doc = construct.doc; // e.g. through `extensions` array in CSN
-    if (!construct.$annotations) {
-      if (!block || block.$frontend !== 'json')
-        return;                 // namespace, or in CDL source without @annos:
-      // CSN input: set _block and $priority, shallow-copy from extension
-      for (const annoProp in construct) {
-        if (annoProp.charAt(0) === '@') {
-          let annos = construct[annoProp];
-          if (!(Array.isArray(annos)))
-            annos = [ annos ];
-          for (const a of annos) {
-            setLink( a, '_block', block );
-            a.$priority = priority;
-            if (construct !== art)
-              addAnnotation( art, annoProp, a );
-          }
-        }
+      else if (construct.$syntax === 'returns' && art._block && art.kind !== 'action' &&
+        art.kind !== 'function' ) {
+        // `annotate ABC with returns {}` is handled just like `elements`. Warn if it is used
+        // for non-actions.  We can't only check for !art.returns, because `action A();` is valid.
+        // `art._block` ensures that `art` is a defined def.
+        warning('anno-unexpected-returns', [ construct.name.location, construct ],
+                { keyword: 'returns', kind: art.kind }, 'Unexpected $(KEYWORD) for $(KIND)');
       }
-      return;
     }
-    for (const anno of construct.$annotations) {
-      const ref = anno.name;
-      const name = resolveUncheckedPath( ref, 'annotation', { _block: block } );
-      const annoProp = (anno.name.variant)
-        ? `@${ name }#${ anno.name.variant.id }`
-        : `@${ name }`;
-      flatten( ref.path, annoProp, anno.value || {}, anno.name.variant, anno.name.location );
-    }
-    return;
-
-    function flatten( path, annoProp, value, iHaveVariant, location ) {
-      // Be robust if struct value has duplicate element names
-      if (Array.isArray(value)) // TODO: do that differently in CDL parser
-        return;                 // discard duplicates in flattened form
-
-      if (value.literal === 'struct') {
-        for (const item of value._struct || []) {
-          let prop = pathName(item.name.path);
-          if (item.name.variant) {
-            if (iHaveVariant) {
-              error( 'anno-duplicate-variant', [ item.name.variant.location, construct ],
-                     {},      // TODO: params
-                     'Annotation variant has been already provided' );
-            }
-            prop = `${ prop }#${ item.name.variant.id }`; // TODO: check for double variants
+    if (construct.doc)
+      art.doc = construct.doc; // e.g. through `extensions` array in CSN
+
+    // set _block (for layering) and $priority, shallow-copy from extension
+    // TODO: think of removing $priority, then
+    // no _block: define, _block: annotate/extend/edmx
+    // would fit with extending defs with props like length
+    for (const annoProp in construct) {
+      if (annoProp.charAt(0) === '@') {
+        let annos = construct[annoProp];
+        if (!(Array.isArray(annos)))
+          annos = [ annos ];
+        for (const a of annos) {
+          setLink( a, '_block', block );
+          a.$priority = priority; // is now: undefined (auto-set) | false | 'annotate' | 'extend'
+          if (construct !== art)
+            addAnnotation( art, annoProp, a );
+          if (!priority && annotationHasEllipsis( a )) {
+            error( 'anno-unexpected-ellipsis',
+                   [ a.name.location, art ], { code: '...' } );
           }
-          flatten( [ ...path, ...item.name.path ], `${ annoProp }.${ prop }`, item, iHaveVariant || item.name.variant);
-        }
-        for (const prop in value.struct) {
-          const item = value.struct[prop];
-          flatten( [ ...path, item.name ], `${ annoProp }.${ prop }`, item, iHaveVariant );
         }
-        return;
       }
-      const anno = Object.assign( {}, value ); // shallow copy
-      anno.name = {
-        path,
-        location: location ||
-          value.name && value.name.location ||
-          value.path && value.path.location,
-      };
-      setLink( anno, '_block', block );
-      // TODO: _parent, _main is set later (if we have ElementRef), or do we
-      // set _artifact?
-      anno.$priority = priority;
-      addAnnotation( art, annoProp, anno );
     }
   }
 }

package/lib/compiler/tweak-assocs.js

@@ -39,7 +39,7 @@ function tweakAssocs( model ) {
   const { environment } = model.$volatileFunctions;
 
   // behavior depending on option `deprecated`:
-  const enableExpandElements = !isDeprecatedEnabled( options, 'noElementsExpansion' );
+  const enableExpandElements = !isDeprecatedEnabled( options, '_noElementsExpansion' );
   // TODO: we should get rid of noElementsExpansion soon; both
   // beta.nestedProjections and beta.universalCsn do not work with it.
 
@@ -95,15 +95,14 @@ function tweakAssocs( model ) {
     if (!target || target._service) // assoc to other service is OK
       return;
     if (!elem.$inferred) {      // && !elem.target.$inferred
-      // TODO: spec meeting 2021-01-22: no warning
-      warning( 'assoc-target-not-in-service', [ elem.target.location, elem ],
-               { target, '#': (elem._main.query ? 'select' : 'define') }, {
-                 std: 'Target $(TARGET) of association is outside any service', // not used
-                 // eslint-disable-next-line max-len
-                 define: 'Target $(TARGET) of explicitly defined association is outside any service',
-                 // eslint-disable-next-line max-len
-                 select: 'Target $(TARGET) of explicitly selected association is outside any service',
-               } );
+      info( 'assoc-target-not-in-service', [ elem.target.location, elem ],
+            { target, '#': (elem._main.query ? 'select' : 'define') }, {
+              std: 'Target $(TARGET) of association is outside any service', // not used
+              // eslint-disable-next-line max-len
+              define: 'Target $(TARGET) of explicitly defined association is outside any service',
+              // eslint-disable-next-line max-len
+              select: 'Target $(TARGET) of explicitly selected association is outside any service',
+            } );
     }
     else {
       info( 'assoc-outside-service', [ elem.target.location, elem ],

package/lib/compiler/utils.js

@@ -31,6 +31,10 @@ function annotationVal( anno ) {
 function annotationIsFalse( anno ) {                   // falsy, but not null (unset)
   return anno && (anno.val === false || anno.val === 0 || anno.val === '');
 }
+function annotationHasEllipsis( anno ) {
+  const { val } = anno || {};
+  return Array.isArray( val ) && val.some( v => v.literal === 'token' && v.val === '...' );
+}
 
 /**
  * Set compiler-calculated annotation value.
@@ -184,8 +188,8 @@ function withAssociation( ref, test = testFunctionPlaceholder, alsoTestLast = fa
  *
  * @param {XSN.Path} path
  */
-function pathName(path) {
-  return (path.broken) ? '' : path.map( id => id.id ).join('.');
+function pathName( path ) {
+  return (path && !path.broken) ? path.map( id => id.id ).join('.') : '';
 }
 
 /**
@@ -381,6 +385,7 @@ module.exports = {
   pushLink,
   annotationVal,
   annotationIsFalse,
+  annotationHasEllipsis,
   annotateWith,
   setLink,
   setArtifactLink,

package/lib/edm/annotations/genericTranslation.js

@@ -333,7 +333,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
   function handleNestedElements(objname, baseElemName, elementsObj) {
     if(!elementsObj) return;
     Object.entries(elementsObj).forEach(([elemName, element]) => {
-      if (Object.keys(element).filter( x => x.substr(0,1) === '@' ).filter(filterKnownVocabularies).length > 0) {
+      if (Object.keys(element).filter( x => x[0] === '@' ).filter(filterKnownVocabularies).length > 0) {
         message(warning, null, `annotations at nested elements are not yet supported, object ${objname}, element ${baseElemName}.${elemName}`);
       }
 
@@ -437,11 +437,17 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
 
     // Filter unknown toplevel annotations
     // Final filtering of all annotations is done in handleTerm
-    const annoNames = Object.keys(carrier).filter( x => x.substr(0,1) === '@' );
+    
+    let annoNames = Object.keys(carrier).filter( x => x[0] === '@' );
     const nullWhitelist = [ '@Core.OperationAvailable' ];
-    const knownAnnos = annoNames.filter(filterKnownVocabularies).filter(x => carrier[x] !== null || nullWhitelist.includes(x));
+    let knownAnnos = annoNames.filter(filterKnownVocabularies).filter(x => carrier[x] !== null || nullWhitelist.includes(x));
     if (knownAnnos.length === 0) return;
 
+    if(rewriteInnerAnnotations()) {
+      annoNames = Object.keys(carrier).filter( x => x[0] === '@' );
+      knownAnnos = annoNames.filter(filterKnownVocabularies).filter(x => carrier[x] !== null || nullWhitelist.includes(x));
+      if (knownAnnos.length === 0) return;
+    }
     const prefixTree = createPrefixTree();
 
     // usually, for a given carrier there is one target
@@ -610,6 +616,51 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
       */
     }
 
+    function rewriteInnerAnnotations() {
+      let rc = false;
+      for (let a of knownAnnos) {
+        const [ prefix, innerAnnotation ] = a.split('.@');
+        /*
+          New inner annotation (de-)structuring of the core compiler to make
+          $value arrays extendable via ellipsis
+          @anno: { $value: [ ... ], @innerAnno: ... } is now cracked up by
+          the core compiler into:
+          @anno: [ ...]
+          @anno.@innerAnno: ...
+
+          Conflict handling if $value is present:
+          @anno
+          @anno.$value
+          @anno.@innerAnno
+
+          @anno has precedence (as it was before this change) but now
+          @anno.$value is overwritten with @anno and the inner annotations
+          are applied.
+
+          Trigger is always the inner annotation, if no inner annotation
+          is available, @anno has precedence.
+
+          Insert $value into $edmJson with inner annotation as well.
+        */
+        if(innerAnnotation) {
+          if(carrier[prefix]) {
+            const valPrefix = prefix + '.$value';
+            carrier[valPrefix] = carrier[prefix];
+            delete carrier[prefix];
+            rc = true;
+          }
+          const edmJsonPrefix = prefix + '.$edmJson';
+          if(carrier[edmJsonPrefix]) {
+            const valPrefix = prefix + '.$value.$edmJson';
+            carrier[valPrefix] = carrier[edmJsonPrefix];
+            delete carrier[edmJsonPrefix];
+            rc = true;
+          }
+        }
+      }
+      return rc;
+    }
+
     function createPrefixTree() {
       // in csn, all annotations are flattened
       // => values can be - primitive values (string, number)
@@ -619,6 +670,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
       //   by building a "prefix tree" for the annotations attached to the carrier
       //   see example at definition of function mergePathStepsIntoPrefixTree
       const prefixTree = {};
+
       for (let a of knownAnnos) {
       // remove leading @ and split at "."
       //   stop splitting at ".@" (used for nested annotations)
@@ -845,7 +897,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
         // "pseudo-structure" used for embedding a piece of JSON that represents "OData CSDL, JSON Representation"
         oTarget.append(handleEdmJson(cAnnoValue['$edmJson'], context));
       }
-      else if ( Object.keys(cAnnoValue).filter( x => x.substr(0,1) !== '@' ).length === 0) {
+      else if ( Object.keys(cAnnoValue).filter( x => x[0] !== '@' ).length === 0) {
         // object consists only of properties starting with "@"
         message(warning, context, 'nested annotations without corresponding base annotation');
       }
@@ -952,6 +1004,8 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
   //      Edm.Decimal -> Decimal
   //      integer tpye -> Int
   function handleSimpleValue(val, dTypeName, context) {
+    // these types must be represented as "String" values in XML:
+    const castToXmlString = [ 'Edm.PrimitiveType', 'Edm.Stream', 'Edm.Untyped' ];
     // caller already made sure that val is neither object nor array
     dTypeName = resolveType(dTypeName);
 
@@ -989,12 +1043,12 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
         message(warning, context, `found String, but expected enum type ${ dTypeName }`);
         typeName = 'EnumMember';
       }
-      else if (dTypeName && dTypeName.startsWith('Edm.') && dTypeName !== 'Edm.PrimitiveType') {
+      else if (dTypeName && dTypeName.startsWith('Edm.') && !castToXmlString.includes(dTypeName)) {
         // this covers also all paths
         typeName = dTypeName.substring(4);
       }
       else {
-        if(dTypeName == undefined || dTypeName === 'Edm.PrimitiveType')
+        if(dTypeName == undefined || castToXmlString.some(t => t === dTypeName))
           dTypeName = 'Edm.String';
         // TODO
         //message(warning, context, "type is not yet handled: found String, expected type: " + dTypeName);

package/lib/edm/annotations/preprocessAnnotations.js

@@ -1,7 +1,7 @@
 'use strict';
 
-const edmUtils = require('../edmUtils.js');
 const { makeMessageFunction } = require('../../base/messages.js');
+const { forEachDefinition } = require('../../model/csnUtils.js');
 
 
 /**************************************************************************************************
@@ -37,15 +37,14 @@ function preprocessAnnotations(csn, serviceName, options) {
     let targetName = (typeof assoc.target === 'object') ? assoc.target.name : assoc.target;
     let target     = (typeof assoc.target === 'object') ? assoc.target      : csn.definitions[assoc.target];
 
-    let keyNames = Object.keys(target.elements).filter(x => target.elements[x].key);
+    let keyNames = Object.keys(target.elements).filter(x => target.elements[x].key && !target.elements[x].target);
     if (keyNames.length === 0) {
       keyNames.push('MISSING');
       warning(null, null, `in annotation preprocessing: target ${targetName} has no key`);
     }
     else if (keyNames.length > 1)
       warning(null, null, `in annotation preprocessing: target ${targetName} has multiple key elements`);
-
-    // TODO: what happens if key of target is itself a managed association?
+    
     return keyNames[0];
   }
 
@@ -58,15 +57,15 @@ function preprocessAnnotations(csn, serviceName, options) {
   function resolveShortcuts() {
     let art = null;
 
-    edmUtils.forAll(csn.definitions, (artifact, artifactName) => {
+    forEachDefinition(csn, (artifact, artifactName) => {
       if(artifactName == serviceName || artifactName.startsWith(serviceName + '.')) {
         art = artifactName;
         handleAnnotations(artifactName, artifact);
-        edmUtils.forAll(artifact.elements, (element, elementName) => {
+        artifact.elements && Object.entries(artifact.elements).forEach(([elementName, element]) => {
           handleAnnotations(elementName, element);
         });
-        edmUtils.forAll(artifact.actions, (action) => {
-          edmUtils.forAll(action.params, (param, paramName) => {
+        artifact.actions && Object.values(artifact.actions).forEach(action => {
+          action.params && Object.entries(action.params).forEach(([paramName, param]) => {
             handleAnnotations(paramName, param);
           });
         });
@@ -155,7 +154,7 @@ function preprocessAnnotations(csn, serviceName, options) {
                 return false;
               }
               let assoc = csn.definitions[art].elements[assocName];
-              if (!assoc || !(assoc.type === 'cds.Association' || assoc.type === 'cds.Composition')) {
+              if (!assoc || !assoc.target) {
                 warning(null, null, `in annotation preprocessing/${aNameWithoutQualifier}: there is no association "${assocName}", ${ctx}`);
                 return false;
               }
@@ -196,7 +195,7 @@ function preprocessAnnotations(csn, serviceName, options) {
             //   name of the element carrying the value help annotation
             //   if this is a managed assoc, use fk field instead (if there is a single one)
             let localDataProp = carrierName.split('/').pop();
-            if (edmUtils.isManagedAssociation(carrier)) {
+            if (carrier.target && carrier.on === undefined) {
               localDataProp = localDataProp + fkSeparator + getKeyOfTargetOfManagedAssoc(carrier);
             }
 
@@ -212,7 +211,7 @@ function preprocessAnnotations(csn, serviceName, options) {
             // valueListProp: the (single) key field of the value list entity
             //   if no key or multiple keys -> warning
             let valueListProp = null;
-            let keys = Object.keys(vlEntity.elements).filter( x => vlEntity.elements[x].key );
+            let keys = Object.keys(vlEntity.elements).filter( x => vlEntity.elements[x].key && !vlEntity.elements[x].target );
             if (keys.length === 0) {
               warning(null, null, `in annotation preprocessing/value help shortcut: entity "${enameFull}" has no key, ${ctx}`);
               return false;