@sap/cds-compiler 2.15.8 → 3.1.0

package/lib/compiler/shared.js

@@ -5,12 +5,14 @@
 
 const { searchName } = require('../base/messages');
 const { dictAddArray } = require('../base/dictionaries');
+const { isDeprecatedEnabled } = require('../base/model');
 
 const {
   setLink,
   setArtifactLink,
   dependsOn,
   pathName,
+  annotationHasEllipsis,
 } = require('./utils');
 
 function artifactsEnv( art ) {
@@ -143,6 +145,13 @@ function fns( model ) {
     rewrite: {
       next: '_$next', dollar: true, escape: 'param', noDep: true, rewrite: true,
     }, // TODO: assertion that there is no next/escape used
+    'order-by': {
+      next: '_$next',
+      dollar: true,
+      escape: 'param',
+      assoc: 'nav',
+      deprecatedSourceRefs: true,
+    },
     'order-by-union': {
       next: '_$next', dollar: true, escape: 'param', noDep: true, noExt: true,
     },
@@ -159,6 +168,7 @@ function fns( model ) {
     resolveUncheckedPath,
     resolveTypeArgumentsUnchecked,
     resolvePath,
+    checkAnnotate,
     defineAnnotations,
     attachAndEmitValidNames,
   } );
@@ -512,7 +522,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 });
     }
@@ -601,6 +611,21 @@ function fns( model ) {
       else if (r) {
         return setArtifactLink( head, r );
       }
+      else if (spec.deprecatedSourceRefs && env._combined &&
+               isDeprecatedEnabled( options, 'autoCorrectOrderBySourceRefs' )) {
+        // User has provided a source element without table alias where a query
+        // element is expected.  Possible on many DBs (and compiler v1), in CAP
+        // only with table alias.  Auto-correct it if no duplicate.
+        // TODO: we could use that info also in messages when the deprecated flag is not set
+        const s = env._combined[head.id];
+        if (s && !Array.isArray(s)) {
+          path.$prefix = s.name.alias; // pushing it to path directly could be problematic
+          warning( null, [ head.location, user ],
+                   { id: head.id, newcode: `${ s.name.alias }.${ head.id }` },
+                   'Replace source element reference $(ID) by $(NEWCODE); auto-corrected' );
+          return setArtifactLink( head, s );
+        }
+      }
     }
     if (spec.noMessage || msgArt === true && extDict === model.definitions)
       return null;
@@ -673,6 +698,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 +836,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,101 +885,61 @@ 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' ) {
-    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
-      // In parseCdl mode USINGs and other unknown references are generated as
-      // namespaces which would lead to false positives.
-      // TODO: should this really be different to annotate-unknown?
-      if (art.kind === 'namespace') {
-        info( 'anno-namespace', [ construct.name.location, construct ], {},
-              'Namespaces can\'t be annotated' );
-      }
-      // Builtin annotations would also get lost. Same as for namespaces:
-      // extracted in to-csn.js
-      else if (art.builtin === true) {
-        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 );
-          }
-        }
-      }
-      return;
+  // Issue messages for annotations on namespaces and builtins
+  // (TODO: really here?, probably split main artifacts vs returns)
+  // see also lateExtensions() where similar messages are reported
+  function checkAnnotate( construct, art ) {
+    // 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
+    // In parseCdl mode USINGs and other unknown references are generated as
+    // namespaces which would lead to false positives.
+    // TODO: should this really be different to annotate-unknown?
+    if (art.kind === 'namespace') {
+      info( 'anno-namespace', [ construct.name.location, construct ], {},
+            'Namespaces can\'t be annotated' );
+    }
+    // Builtin annotations would also get lost. Same as for namespaces:
+    // extracted in to-csn.js
+    else if (art.builtin === true) {
+      info( 'anno-builtin', [ construct.name.location, construct ], {},
+            'Builtin types should not be annotated. Use custom type instead' );
+    }
+    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)');
     }
-    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
+  }
+
+  // Set _block links for annotations (necessary for layering).
+  // Also copy annotations from `construct` to `art` (TODO: separate that functionality).
+  function defineAnnotations( construct, art, block, priority = false ) {
+    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

@@ -3,7 +3,6 @@
 'use strict';
 
 const {
-  isDeprecatedEnabled,
   forEachDefinition,
   forEachGeneric,
   forEachInOrder,
@@ -26,7 +25,6 @@ const $location = Symbol.for('cds.$location');
 
 // Export function of this file.
 function tweakAssocs( model ) {
-  const { options } = model;
   // Get shared functionality and the message function:
   const {
     info, warning, error,
@@ -38,11 +36,6 @@ function tweakAssocs( model ) {
   } = model.$functions;
   const { environment } = model.$volatileFunctions;
 
-  // behavior depending on option `deprecated`:
-  const enableExpandElements = !isDeprecatedEnabled( options, 'noElementsExpansion' );
-  // TODO: we should get rid of noElementsExpansion soon; both
-  // beta.nestedProjections and beta.universalCsn do not work with it.
-
   // Phase 5: rewrite associations
   forEachDefinition( model, rewriteSimple );
   // TODO: sequence not good enough with derived type of structure with
@@ -95,15 +88,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 ],
@@ -114,7 +106,7 @@ function tweakAssocs( model ) {
 
   function rewriteAssociationCheck( element ) {
     const elem = element.items || element; // TODO v2: nested items
-    if (elem.elements && enableExpandElements)
+    if (elem.elements)
       forEachGeneric( elem, 'elements', rewriteAssociationCheck );
     if (!elem.target)
       return;
@@ -208,7 +200,7 @@ function tweakAssocs( model ) {
 
   function rewriteAssociation( element ) {
     let elem = element.items || element; // TODO v2: nested items
-    if (elem.elements && enableExpandElements)
+    if (elem.elements)
       forEachGeneric( elem, 'elements', rewriteAssociation );
     if (!originTarget( elem ))
       return;
@@ -287,7 +279,7 @@ function tweakAssocs( model ) {
     // same (TODO later: set status whether rewrite changes anything),
     // especially problematic are refs starting with $self:
     setExpandStatus( elem, 'target' );
-    if (enableExpandElements && elem._parent && elem._parent.kind === 'element') {
+    if (elem._parent && elem._parent.kind === 'element') {
       // managed association as sub element not supported yet
       error( null, [ elem.location, elem ], {},
         // eslint-disable-next-line max-len
@@ -370,7 +362,8 @@ function tweakAssocs( model ) {
       const item = expr.path[root.kind === '$self' ? 1 : 0];
       if (!item)
         return;                                   // just $self
-      const elem = assoc._main.elements[item.id]; // corresponding elem in including structure
+      // corresponding elem in including structure
+      const elem = (assoc._main.items || assoc._main).elements[item.id];
       if (!(Array.isArray(elem) ||              // no msg for redefs
             elem === item._artifact ||          // redirection for explicit def
             elem._origin === item._artifact)) {

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.
@@ -91,6 +95,14 @@ function linkToOrigin( origin, name, parent, prop, location, silentDep ) {
   return elem;
 }
 
+/**
+ * Set the member `elem` to have a _parent link to `parent` and a corresponding
+ * _main link.  Also set the member's name accordingly, where argument `name`
+ * is most often the property `elem.name.id`.
+ *
+ * If argument `prop` is provided, add `elem` to the dictionary of that name,
+ * e.g. `elements`.
+*/
 function setMemberParent( elem, name, parent, prop ) {
   if (prop) {              // extension or structure include
     // TODO: consider nested ARRAY OF and RETURNS, COMPOSITION OF type
@@ -103,9 +115,10 @@ function setMemberParent( elem, name, parent, prop ) {
     parent = parent._outer;
   setLink( elem, '_parent', parent );
   setLink( elem, '_main', parent._main || parent );
-  const parentName = parent.name || parent._outer.name;
-  elem.name.absolute = parentName.absolute;
-  if (name == null)
+  const parentName = parent.name || parent._outer?.name;
+  if (parentName) // may not be available in e.g. cast() - TODO recheck (#9503)
+    elem.name.absolute = parentName.absolute;
+  if (!parentName || name == null)
     return;
   const normalized = kindProperties[elem.kind].normalized || elem.kind;
   [ 'element', 'alias', 'select', 'param', 'action' ].forEach( ( kind ) => {
@@ -184,8 +197,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('.') : '';
 }
 
 /**
@@ -353,7 +366,7 @@ function traverseQueryExtra( main, callback ) {
 //             that value is only on elements, types, and params -> no other members
 //             when set, only on elem/art with expanded elements
 // - 'target': all expanded (sub) elements might only have new target/on, but
-//             no indivual annotations on any (sub) member
+//             no individual annotations on any (sub) member
 //             when set, traverse all parents where the value has been 'origin' before
 // - 'annotate': at least one inferred (sub) member has an individual annotation,
 //               not counting propagated ones; set up to the definition (main artifact)
@@ -381,6 +394,7 @@ module.exports = {
   pushLink,
   annotationVal,
   annotationIsFalse,
+  annotationHasEllipsis,
   annotateWith,
   setLink,
   setArtifactLink,

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) => {
-      if(artifactName == serviceName || artifactName.startsWith(serviceName + '.')) {
+    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;
               }
@@ -165,7 +164,7 @@ function preprocessAnnotations(csn, serviceName, options) {
             }
             else if (aNameWithoutQualifier === '@Common.ValueList.entity') {
               // if both annotations are present, ignore 'entity' and raise a message
-              if (annoNames.map(x=>x.split('#')[0]).find(x=>(x=='@Common.ValueList.viaAssociation'))) {
+              if (annoNames.map(x=>x.split('#')[0]).find(x=>(x==='@Common.ValueList.viaAssociation'))) {
                 warning(null, null, `in annotation preprocessing/@Common.ValueList: 'entity' is ignored, as 'viaAssociation' is present, ${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;