@sap/cds-compiler 2.15.8 → 3.1.0

package/lib/compiler/resolve.js

@@ -49,13 +49,13 @@ const { dictAdd } = require('../base/dictionaries');
 const { dictLocation } = require('../base/location');
 const { searchName, weakLocation } = require('../base/messages');
 const { combinedLocation } = require('../base/location');
-const { forEachValue } = require('../utils/objectUtils');
 const { typeParameters } = require('./builtins');
 
 const { kindProperties } = require('./base');
 const {
   setLink,
   setArtifactLink,
+  annotationHasEllipsis,
   pathName,
   linkToOrigin,
   setMemberParent,
@@ -73,9 +73,6 @@ const layers = require('./moduleLayers');
 
 const $location = Symbol.for('cds.$location');
 
-const annotationPriorities = {
-  define: 1, extend: 2, annotate: 2, edmx: 3,
-};
 const $inferred = Symbol.for('cds.$inferred');
 
 // Export function of this file.  Resolve type references in augmented CSN
@@ -90,6 +87,7 @@ function resolve( model ) {
   } = model.$messageFunctions;
   const {
     resolvePath,
+    checkAnnotate,
     defineAnnotations,
     attachAndEmitValidNames,
     lateExtensions,
@@ -106,11 +104,6 @@ function resolve( model ) {
 
   /** @type {any} may also be a boolean */
 
-  // 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.
-
   return doResolve();
 
   function doResolve() {
@@ -211,9 +204,9 @@ function resolve( model ) {
       info( 'query-from-many', [ toMany.location, query ], { art: toMany },
             {
               // eslint-disable-next-line max-len
-              std: 'Selecting from to-many association $(ART) - key properties are not propagated',
+              std: 'Key properties are not propagated because a to-many association $(ART) is selected',
               // eslint-disable-next-line max-len
-              element: 'Selecting from to-many association $(MEMBER) of $(ART) - key properties are not propagated',
+              element: 'Key properties are not propagated because a to-many association $(MEMBER) of $(ART) is selected',
             } );
     }
     // Check that all keys from the source are projected:
@@ -317,7 +310,7 @@ function resolve( model ) {
     if (obj.type)             // TODO: && !obj.type.$inferred ?
       resolveTypeExpr( obj, art );
     const type = effectiveType( obj ); // make sure implicitly redirected target exists
-    if (!obj.items && type && type.items && enableExpandElements) {
+    if (!obj.items && type && type.items) {
       // TODO: shouldn't be this part of populate.js ?
       const items = {
         location: weakLocation( (obj.type || obj).location ),
@@ -330,8 +323,7 @@ function resolve( model ) {
     }
     if (obj.items) {            // TODO: make this a while in v2 (also items proxy)
       obj = obj.items || obj; // the object which has type properties
-      if (enableExpandElements)
-        effectiveType(obj);
+      effectiveType(obj);
     }
     if (obj.type) {             // TODO: && !obj.type.$inferred ?
       if (obj !== (art.returns || art)) // not already checked
@@ -484,10 +476,7 @@ function resolve( model ) {
     if (ext.$extension) // extension for known artifact -> already applied
       return;
     annotateMembers( ext );
-    for (const prop in ext) {
-      if (prop.charAt(0) === '@')
-        chooseAssignment( prop, ext );
-    }
+    chooseAnnotationsInArtifact( ext );
   }
 
   /**
@@ -522,6 +511,8 @@ function resolve( model ) {
       setArtifactLink( ext.name, art );
 
       if (art) {
+        if (art.kind === 'annotate')
+          checkAnnotate( ext, art );
         defineAnnotations( ext, art, ext._block, ext.kind );
         // eslint-disable-next-line no-shadow
         forEachMember( ext, ( elem, name, prop ) => {
@@ -544,7 +535,7 @@ function resolve( model ) {
         }
         else if (prop === 'actions') {
           if (!feature) {
-            warning( 'anno-unexpected-actions', [ ext.name.location, art ], {},
+            warning( 'anno-unexpected-actions', [ ext.name.location, art._parent || art ], {},
                      'Actions and functions only exist top-level and for entities' );
           }
           else {
@@ -575,7 +566,7 @@ function resolve( model ) {
       // Currently(?), effectiveType() does not calculate the effective type of
       // its line item:
       effectiveType( obj );
-      if (art._annotate.elements)
+      if (art._annotate.elements) // explicit $expand on aor needed
         setExpandStatusAnnotate( aor, 'annotate' );
       annotate( obj, 'element', 'elements', 'enum', art );
       annotate( art, 'action', 'actions' );
@@ -599,6 +590,8 @@ function resolve( model ) {
     // eslint-disable-next-line no-shadow
     function annotate( obj, kind, prop, altProp, parent = obj ) {
       const dict = art._annotate[prop];
+      if (dict && art._annotate[prop])
+        setExpandStatusAnnotate( art, 'annotate' );
       const env = obj[prop] || altProp && obj[altProp] || null;
       for (const n in dict)
         annotateMembers( env && env[n], dict[n], prop, n, parent, kind );
@@ -621,7 +614,7 @@ function resolve( model ) {
 
   function expandParameters( action ) {
     // see also expandElements()
-    if (!enableExpandElements || !effectiveType( action ))
+    if (!effectiveType( action ))
       return;
     const chain = [];
     // Should we be able to consider params and returns separately?
@@ -714,241 +707,219 @@ function resolve( model ) {
   }
 
   function chooseAssignment( annoName, art ) {
-    // TODO: getPath an all names
-    const anno = art[annoName];
-    if (!Array.isArray(anno)) { // just one assignment -> use it
-      if (removeEllipsis( anno )) {
-        error( 'anno-unexpected-ellipsis',
-               [ anno.name.location, art ], { code: '...' } );
+    let anno = art[annoName];
+    if (!Array.isArray( anno )) { // just one assignment -> use it
+      if (!annotationHasEllipsis( anno ))
+        return;
+      anno = [ anno ];
+    }
+    // console.log('ASSIGN:',art.name.absolute,annoName)
+    const scheduledAssignments = [];
+    // sort assignment according to layer (define is bottom layer):
+    const layeredAnnos = layeredAssignments( anno );
+    let cont = true;
+    while (cont) {
+      const { assignments, issue } = assignmentsOfHighestLayers( layeredAnnos );
+      let index = assignments.length;
+      cont = !!index;           // safety
+      while (--index >= 0) {
+        const a = assignments[index];
+        scheduledAssignments.push( a );
+        if (!annotationHasEllipsis( a )) {
+          cont = false;
+          break;
+        }
       }
-      return;
-    }
-    // sort assignment according to layer
-    const layerAnnos = Object.create(null);
-    for (const a of anno) {
-      const layer = layers.layer( a._block );
+      if (issue) {
+        // eslint-disable-next-line no-nested-ternary
+        const msg = (issue === true)
+          ? 'anno-duplicate'
+          : (index >= 0) ? 'anno-duplicate-unrelated-layer' : 'anno-unstable-array';
+        for (const a of assignments) {
+          if (!a.$errorReported)
+            message( msg, [ a.name.location, art ], { anno: annoName } );
+        }
+      }
+      // else if (index > 0)  -- if we allow multiple assignments in one file - the last wins
+    }
+    // Now apply the assignments - all but the first have a '...'
+    let result = null;
+    scheduledAssignments.reverse();
+    for (const a of scheduledAssignments)
+      result = applyAssignment( result, a, art, annoName );
+    art[annoName] = result.name ? result
+      : Object.assign( {}, scheduledAssignments[scheduledAssignments.length - 1], result );
+  }
+
+  // Group assignments by their layers.  An assignment provided with a definition
+  // is considered to be provided in a layer named '', the lowest layer.
+  // TODO: make this usable for extend (elements), too =
+  // do not use $priority, make assignments on define do not have own _block
+  function layeredAssignments( assignment ) {
+    const layered = Object.create(null);
+    for (const a of assignment) {
+      const layer = a.$priority && layers.layer( a );
+      // just consider layer if Extend/Annotate, not Define
       const name = (layer) ? layer.realname : '';
-      const done = layerAnnos[name];
+      const done = layered[name];
       if (done)
-        done.annos.push( a );
+        done.assignments.push( a );
       else
-        layerAnnos[name] = { layer, annos: [ a ] };
+        layered[name] = { name, layer, assignments: [ a ] };
+      // TODO: file - if set: unique in layer
     }
-    mergeArrayInSCCs();
-    art[annoName] = mergeLayeredArrays( findLayerCandidate( ) );
-    return;
+    return layered;
+  }
 
-    // Merge annotations in each layer, i.e. multiple annotations in the same layer are
-    // stored in an array and need to be merged before different layers can be merged.
-    function mergeArrayInSCCs( ) {
-      let pos = 0;
-      forEachValue(layerAnnos, (layer) => {
-        const mergeSource = layer.annos.find(v => (v.$priority === undefined ||
-           annotationPriorities[v.$priority] === annotationPriorities.define));
-        if (mergeSource) {
-          // If the source annotation (at 'define' level) contains an ellipsis,
-          // there is no base to apply to.
-          if (removeEllipsis( mergeSource )) {
-            error( 'anno-unexpected-ellipsis',
-                   [ mergeSource.name.location, art ], { code: '...' } );
-          }
-          // merge source into ellipsis array annotates
-          layer.annos.forEach( (mergeTarget) => {
-            if (mergeTarget.$priority &&
-                annotationPriorities[mergeTarget.$priority] > annotationPriorities.define) {
-              pos = findEllipsis( mergeTarget );
-              if (pos > -1) {
-                if (mergeSource.literal !== 'array') {
-                  error( 'anno-mismatched-ellipsis',
-                         [ mergeSource.name.location, art ], { code: '...' } );
-                  return;
-                }
-                mergeTarget.val = mergeArrayValues( mergeSource.val, mergeTarget.val );
-              }
-            }
-          });
-        }
-      });
-    }
-
-    function mergeLayeredArrays( mergeTarget ) {
-      if (mergeTarget.literal === 'array') {
-        let layer = layers.layer( mergeTarget._block );
-        delete layerAnnos[(layer) ? layer.realname : ''];
-        let pos = findEllipsis( mergeTarget );
-        let hasRun = false;
-        while (pos > -1 && Object.keys( layerAnnos ).length ) {
-          hasRun = true;
-          const mergeSource = findLayerCandidate();
-          if (mergeSource.literal !== 'array') {
-            error( 'anno-mismatched-ellipsis',
-                   [ mergeSource.name.location, art ], { code: '...' } );
-            return mergeTarget;
-          }
-          mergeTarget.val = mergeArrayValues( mergeSource.val, mergeTarget.val );
-          layer = layers.layer( mergeSource._block );
-          delete layerAnnos[(layer) ? layer.realname : ''];
-          pos = findEllipsis( mergeTarget );
-        }
-        // All layers were processed. Remove excess ellipsis.
-        if (removeEllipsis( mergeTarget, pos ) && hasRun) {
-          // There shouldn't be any ellipsis or we don't have a base annotation.
-          // But only if the loop above has run. Otherwise the in-layer merge
-          // already warned about this case.
-          message( 'anno-unexpected-ellipsis-layers',
-                   [ mergeTarget.name.location, art ], { code: '...' } );
-        }
+  // Return assignments of the highest layers.
+  // Also return whether there could be an issue:
+  // - false: there is just one assignment
+  // - 'unrelated': there is just one assignment per layer
+  // - true: there is at least one layer with two or more assignments
+  // TODO: make this usable for extend (elements), too
+  function assignmentsOfHighestLayers( layeredAnnos ) {
+    const layerNames = Object.keys( layeredAnnos );
+    // console.log('HIB:',layerNames)
+    if (layerNames.length <= 1) {
+      const name = layerNames[0];
+      const { assignments } = layeredAnnos[name] || { assignments: [] };
+      delete layeredAnnos[name];
+      return { assignments, issue: assignments.length > 1 };
+    }
+
+    // collect all layers which are lower than another layer
+    const allExtends = Object.create(null);
+    allExtends[''] = {};        // the "Define" layer
+    for (const name of layerNames) {
+      if (name)                 // not the "Define" layer
+        Object.assign( allExtends, layeredAnnos[name].layer._layerExtends );
+    }
+    // console.log('HIE:',Object.keys(allExtends))
+    const assignments = [];
+    const highest = [];
+    for (const name of layerNames) {
+      if (!(name in allExtends)) {
+        const layer = layeredAnnos[name];
+        delete layeredAnnos[name];
+        highest.push( layer );
+        assignments.push( ...layer.assignments );
       }
-      return mergeTarget;
     }
+    assignments.sort( compareAssignments );
+    const good = highest.every( layer => layer.assignments.length === 1 );
+    // TODO: use layer.file instead
+    const issue = !good || highest.length > 1 && 'unrelated';
+    // console.log('HI:',highest.map(l=>l.name),issue,issue&&assignments)
+    return { assignments, issue };
+  }
 
-    function mergeArrayValues( previousValue, arraySpec ) {
-      let prevPos = 0;
-      const result = [];
-      for (const item of arraySpec) {
-        const ell = item && item.literal === 'token' && item.val === '...';
-        if (!ell) {
-          result.push( item );
-        }
-        else {
-          let upToSpec = item.upTo && checkUpToSpec( item.upTo, true );
-          while (prevPos < previousValue.length) {
-            const prevItem = previousValue[prevPos++];
-            result.push( prevItem );
-            if (upToSpec && prevItem && equalUpTo( prevItem, item.upTo)) {
-              upToSpec = false;
-              break;
-            }
-          }
-          if (upToSpec) {       // non-matched UP TO
-            warning( null, [ item.upTo.location, art ], { anno: annoName, code: '... up to' },
-                     'The $(CODE) value does not match any item in the base annotation $(ANNO)' );
+  function compareAssignments( a, b ) {
+    const fileA = layers.realname( a._block );
+    const fileB = layers.realname( b._block );
+    if (fileA !== fileB)
+      return (fileA > fileB) ? 1 : -1;
+    return (a?.location?.line || 0) - (b?.location?.line || 0) ||
+           (a?.location?.col || 0) - (b?.location?.col || 0);
+  }
+
+  function applyAssignment( previousAnno, anno, art, annoName ) {
+    if (!previousAnno) {
+      if (!annotationHasEllipsis( anno ))
+        return anno;
+      if (anno.$priority) {   // already complained about with Define
+        message( 'anno-unexpected-ellipsis-layers', // TODO: better location
+                 [ anno.name.location, art ], { code: '...' } );
+      }
+      previousAnno = { val: [] };
+    }
+    else if (previousAnno.literal !== 'array') {
+      error( 'anno-mismatched-ellipsis', // TODO: better location
+             [ anno.name.location, art ], { code: '...' } );
+      previousAnno = { val: [] };
+    }
+    const previousValue = previousAnno.val;
+    let prevPos = 0;
+    const result = [];
+    for (const item of anno.val) {
+      const ell = item && item.literal === 'token' && item.val === '...';
+      if (!ell) {
+        result.push( item );
+      }
+      else {
+        let upToSpec = item.upTo && checkUpToSpec( item.upTo, art, annoName, true );
+        while (prevPos < previousValue.length) {
+          const prevItem = previousValue[prevPos++];
+          result.push( prevItem );
+          if (upToSpec && prevItem && equalUpTo( prevItem, item.upTo)) {
+            upToSpec = false;
+            break;
           }
         }
+        if (upToSpec) {       // non-matched UP TO
+          warning( null, [ item.upTo.location, art ], { anno: annoName, code: '... up to' },
+                   'The $(CODE) value does not match any item in the base annotation $(ANNO)' );
+        }
       }
-      return result;
     }
+    // console.log('TP:',previousValue.map(se),anno.val.map(se),'->',result.map(se))
+    return { val: result, literal: 'array' };
+  }
+  // function se(a) { return a.upTo ? [a.val,a.upTo.val] : a.val ; }
 
-    function checkUpToSpec( upToSpec, trueIfFullUpTo ) {
-      const { literal } = upToSpec;
-      if (trueIfFullUpTo !== true) { // inside struct of UP TO
-        if (literal !== 'struct' && literal !== 'array' )
-          return true;
-      }
-      else if (literal === 'struct') {
-        return Object.values( upToSpec.struct ).every( checkUpToSpec );
-      }
-      else if (literal !== 'array' && literal !== 'boolean' && literal !== 'null') {
+  function checkUpToSpec( upToSpec, art, annoName, isFullUpTo ) {
+    const { literal } = upToSpec;
+    if (!isFullUpTo) {          // inside struct of UP TO
+      if (literal !== 'struct' && literal !== 'array' )
         return true;
-      }
-      error( null, [ upToSpec.location, art ],
-             { anno: annoName, code: '... up to', '#': literal },
-             {
-               std: 'Unexpected $(CODE) value type in the assignment of $(ANNO)',
-               array: 'Unexpected array as $(CODE) value in the assignment of $(ANNO)',
-               // eslint-disable-next-line max-len
-               struct: 'Unexpected structure as $(CODE) structure property value in the assignment of $(ANNO)',
-               boolean: 'Unexpected boolean as $(CODE) value in the assignment of $(ANNO)',
-               null: 'Unexpected null as $(CODE) value in the assignment of $(ANNO)',
-             } );
-      return false;
     }
+    else if (literal === 'struct') {
+      return Object.values( upToSpec.struct ).every( v => checkUpToSpec( v, art, annoName ) );
+    }
+    else if (literal !== 'array' && literal !== 'boolean' && literal !== 'null') {
+      return true;
+    }
+    error( null, [ upToSpec.location, art ],
+           { anno: annoName, code: '... up to', '#': literal },
+           {
+             std: 'Unexpected $(CODE) value type in the assignment of $(ANNO)',
+             array: 'Unexpected array as $(CODE) value in the assignment of $(ANNO)',
+             // eslint-disable-next-line max-len
+             struct: 'Unexpected structure as $(CODE) structure property value in the assignment of $(ANNO)',
+             boolean: 'Unexpected boolean as $(CODE) value in the assignment of $(ANNO)',
+             null: 'Unexpected null as $(CODE) value in the assignment of $(ANNO)',
+           } );
+    return false;
+  }
 
-    function equalUpTo( previousItem, upToSpec ) {
-      if (!previousItem)
-        return false;
-      if ('val' in upToSpec) {
-        if (previousItem.val === upToSpec.val) // enum, struct and ref have no val
-          return true;
-        const typeUpTo = typeof upToSpec.val;
-        const typePrev = typeof previousItem.val;
-        if (typeUpTo === 'number')
-          return typePrev === 'string' && previousItem.val === upToSpec.val.toString();
-        if (typePrev === 'number')
-          return typeUpTo === 'string' && upToSpec.val === previousItem.val.toString();
-      }
-      else if (upToSpec.path) {
-        return previousItem.path && normalizeRef( previousItem ) === normalizeRef( upToSpec );
-      }
-      else if (upToSpec.sym) {
-        return previousItem.sym && previousItem.sym.id === upToSpec.sym.id;
-      }
-      else if (upToSpec.struct && previousItem.struct) {
-        return Object.entries( upToSpec.struct )
-          .every( ([ n, v ]) => equalUpTo( previousItem.struct[n], v ) );
-      }
+  function equalUpTo( previousItem, upToSpec ) {
+    if (!previousItem)
       return false;
+    if ('val' in upToSpec) {
+      if (previousItem.val === upToSpec.val) // enum, struct and ref have no val
+        return true;
+      const typeUpTo = typeof upToSpec.val;
+      const typePrev = typeof previousItem.val;
+      if (typeUpTo === 'number')
+        return typePrev === 'string' && previousItem.val === upToSpec.val.toString();
+      if (typePrev === 'number')
+        return typeUpTo === 'string' && upToSpec.val === previousItem.val.toString();
     }
-
-    function normalizeRef( node ) { // see to-csn.js
-      const ref = pathName( node.path );
-      return node.variant ? `${ ref }#${ node.variant.id }` : ref;
-    }
-
-    function removeEllipsis(a, pos = findEllipsis( a )) {
-      let count = 0;
-      while (a.literal === 'array' && pos > -1) {
-        count++;
-        a.val.splice(pos, 1);
-        pos = findEllipsis( a );
-      }
-      return count;
-    }
-
-    function findEllipsis(a) {
-      return (a.literal === 'array' && a.val)
-        ? a.val.findIndex(v => v.literal === 'token' && v.val === '...') : -1;
+    else if (upToSpec.path) {
+      return previousItem.path && normalizeRef( previousItem ) === normalizeRef( upToSpec );
     }
-
-    function findLayerCandidate() {
-      // collect assignments of upper layers (are in no _layerExtends)
-      const exts = Object.keys( layerAnnos ).map( layerExtends );
-      const allExtends = Object.assign( Object.create(null), ...exts );
-      const collected = [];
-      for (const name in layerAnnos) {
-        if (!(name in allExtends))
-          collected.push( prioritizedAnnos( layerAnnos[name].annos ) );
-      }
-      // inspect collected assignments - choose the one or signal error
-      const justOnePerLayer = collected.every( annos => annos.length === 1);
-      if (!justOnePerLayer || collected.length > 1) {
-        for (const annos of collected) {
-          for (const a of annos ) {
-          // Only the message ID is different.
-            if (justOnePerLayer) {
-              message( 'anno-duplicate-unrelated-layer',
-                       [ a.name.location, art ], { anno: annoName },
-                       'Duplicate assignment with $(ANNO)' );
-            }
-            else {
-              message( 'anno-duplicate', [ a.name.location, art ], { anno: annoName } );
-            }
-          }
-        }
-      }
-      return collected[0][0];  // just choose any one with error
+    else if (upToSpec.sym) {
+      return previousItem.sym && previousItem.sym.id === upToSpec.sym.id;
     }
-
-    function layerExtends( name ) {
-      const { layer } = layerAnnos[name];
-      return layer && layer._layerExtends;
+    else if (upToSpec.struct && previousItem.struct) {
+      return Object.entries( upToSpec.struct )
+        .every( ([ n, v ]) => equalUpTo( previousItem.struct[n], v ) );
     }
+    return false;
   }
 
-  function prioritizedAnnos( annos ) {
-    let prio = 0;
-    let r = [];
-    for (const a of annos) {
-      const p = annotationPriorities[a.$priority] || annotationPriorities.define;
-      if (p === prio) {
-        r.push(a);
-      }
-      else if (p > prio) {
-        r = [ a ];
-        prio = p;
-      }
-    }
-    return r;
+  function normalizeRef( node ) { // see to-csn.js
+    const ref = pathName( node.path );
+    return node.variant ? `${ ref }#${ node.variant.id }` : ref;
   }
 
   // Phase 4 - queries and associations --------------------------------------
@@ -984,7 +955,7 @@ function resolve( model ) {
       resolveBy( query.$orderBy, 'order-by-union', query.elements, query._parent );
     if (query.orderBy) {       // ORDER BY
     // search in `query.elements` after having checked table aliases of the current query
-      resolveBy( query.orderBy, 'expr', query.elements );
+      resolveBy( query.orderBy, 'order-by', query.elements );
       // TODO: disallow resulting element ref if in expression!
       // Necessary to check it in the compiler as it might work with other semantics on DB!
       // (we could downgrade it to a warning if name is equal to unique source element name)
@@ -1292,7 +1263,7 @@ function resolve( model ) {
     const typeArt = resolveType( art.type, user );
     if (typeArt) {
       resolveTypeArgumentsUnchecked( art, typeArt, user );
-      checkTypeArguments( art );
+      checkTypeArguments( art, typeArt );
     }
   }
 
@@ -1300,13 +1271,13 @@ function resolve( model ) {
    * Check the type arguments on `artWithType`.
    * If the effective type is an array or structured type, an error is emitted.
    */
-  function checkTypeArguments( artWithType ) {
+  function checkTypeArguments( artWithType, typeArt ) {
     // Note: `_effectiveType` may point to `artWithType` itself, if the type is structured.
     //       Also: For enums, it points to the enum type, which is why this trick is needed.
     // TODO(#8942): May not be necessary if effectiveType() is adapted.  Furthermore, the enum
     //              trick may be removed if effectiveType() does not stop at enums.
     const cyclic = new Set();
-    let effectiveTypeArt = effectiveType( artWithType );
+    let effectiveTypeArt = effectiveType( typeArt );
     while (effectiveTypeArt && effectiveTypeArt.enum && !cyclic.has(effectiveTypeArt)) {
       cyclic.add(effectiveTypeArt);
       const underlyingEnumType = directType(effectiveTypeArt);