@sap/cds-compiler 3.6.0 → 3.7.2

package/lib/compiler/extend.js

@@ -10,20 +10,25 @@ const {
   isDeprecatedEnabled,
   forEachGeneric, forEachInOrder, forEachDefinition,
 } = require('../base/model');
-const { dictAdd } = require('../base/dictionaries');
+const { dictAdd, dictAddArray } = require('../base/dictionaries');
 const { kindProperties, dictKinds } = require('./base');
 const {
   setLink,
   setArtifactLink,
+  copyExpr,
   annotateWith,
   linkToOrigin,
   setMemberParent,
   dependsOnSilent,
   augmentPath,
-  splitIntoPath, isDirectComposition,
+  pathName,
+  splitIntoPath,
+  isDirectComposition,
+  annotationHasEllipsis,
 } = require('./utils');
 const layers = require('./moduleLayers');
 const { typeParameters } = require('./builtins');
+const { CompilerAssertion } = require('../base/error');
 
 function extend( model ) {
   const { options } = model;
@@ -34,9 +39,8 @@ function extend( model ) {
   const {
     resolvePath,
     resolveUncheckedPath,
-    checkAnnotate,
     initAnnotations,
-    copyAnnotationsForExtensions,
+    checkAnnotate,
     attachAndEmitValidNames,
     checkDefinitions,
     initArtifact,
@@ -46,9 +50,10 @@ function extend( model ) {
 
   Object.assign( model.$functions, {
     lateExtensions,
-    layeredAssignments,
-    assignmentsOfHighestLayers,
     applyTypeExtensions,
+    chooseAnnotationsInArtifact,
+    extensionFor,
+    copyAnnotationsForExtensions,
   } );
 
   applyExtensions();
@@ -150,7 +155,7 @@ function extend( model ) {
         }
         else if (phase === 1
                  ? extendContext( name, art )
-                 : extendArtifact( extensionsDict[name], art, phase > 2 )) { // >2: no self-include
+                 : extendArtifact( extensionsDict[name], art, Array.isArray( phase ) && phase )) {
           delete extensionsDict[name];
         }
       }
@@ -158,7 +163,7 @@ function extend( model ) {
       if (phase === 1)
         phase = 2;
       else if (extNames.length >= length)
-        phase = 3;
+        phase = Object.keys( extensionsDict ); // = no includes
     }
   }
 
@@ -210,6 +215,16 @@ function extend( model ) {
     if (!noIncludes && !(canApplyIncludes( art, art ) &&
         extensions.every( ext => canApplyIncludes(ext, art) )))
       return false;
+    if (Array.isArray( noIncludes )) {
+      canApplyIncludes( art, art, noIncludes );
+      extensions.forEach( ext => canApplyIncludes( ext, art, noIncludes ) );
+    }
+    else if (!noIncludes &&
+             !(canApplyIncludes( art, art ) &&
+               extensions.every( ext => canApplyIncludes( ext, art) ))) {
+      // console.log( 'FALSE:',art.name, extensions.map( e => e.name ) )
+      return false;
+    }
     if (!art.query) {
       model._entities.push( art ); // add structure with includes in dep order
       art.$entity = ++model.$entity;
@@ -425,7 +440,7 @@ function extend( model ) {
         break;
       }
 
-      const baseType = art._effectiveType; // may be an ENUM
+      const baseType = art._effectiveType; // may be an ENUM -- TODO: not here!
       if (!artType || (art.kind !== 'type' && art.kind !== 'element') || !baseType?.builtin) {
         // Only report first extension for non-scalar base type. Reduces noise.
         error('ref-expected-scalar-type', [ ext.name.location, ext ], { } );
@@ -547,7 +562,7 @@ function extend( model ) {
     // We only care about the highest layer
     const { assignments, issue } = assignmentsOfHighestLayers( extLayers );
 
-    if (issue) {
+    if (issue || assignments.length > 1) { // TODO: allow in same file?
       const id = (issue === 'unrelated')
         ? 'ext-duplicate-extend-type-unrelated-layer'
         : 'ext-duplicate-extend-type';
@@ -665,14 +680,25 @@ function extend( model ) {
    * @param {XSN.Artifact} target
    * @returns {boolean}
    */
-  function canApplyIncludes( art, target ) {
-    if (art.includes) {
-      const isView = !!target.query;
-      for (const ref of art.includes) {
-        const template = resolvePath( ref, isView ? 'viewInclude' : 'include', art );
-        if (template && template.name.absolute in extensionsDict)
-          return false;
+  function canApplyIncludes( art, target, justResolveCyclic ) {
+    if (!art.includes)
+      return true;
+    const isView = !!target.query;
+    for (const ref of art.includes) {
+      const name = resolveUncheckedPath( ref, 'include', art );
+      // console.log('CAI:',justResolveCyclic, name, ref.path, Object.keys(extensionsDict))
+      if (justResolveCyclic) {
+        if (!justResolveCyclic.includes( name ))
+          continue;
+        delete ref._artifact;
       }
+      else if (name && name in extensionsDict) {
+        return false;
+      }
+      else if (ref._artifact) {
+        delete ref._artifact;
+      }
+      resolvePath( ref, isView ? 'viewInclude' : 'include', art );
     }
     return true;
   }
@@ -710,7 +736,8 @@ function extend( model ) {
         }
       }
     }
-    includeMembers( ext, art, 'elements' );
+    if (!art.query)    // do not set art.elements and art.enums with query entity!
+      includeMembers( ext, art, 'elements' );
     includeMembers( ext, art, 'actions' );
   }
 
@@ -743,10 +770,17 @@ function extend( model ) {
             elem.masked = Object.assign( { $inferred: 'include' }, origin.masked );
           if (origin.key)
             elem.key = Object.assign( { $inferred: 'include' }, origin.key );
+          if (origin.value && origin.$syntax === 'calc') {
+            // TODO: If paths become invalid in the new artifact, should we mark
+            //       all usages in the expressions? Possibly just the first one?
+            elem.value = Object.assign( { $inferred: 'include' }, copyExpr( origin.value ));
+            elem.$syntax = 'calc';
+          }
           // TODO: also complain if elem is just defined in art
         });
       }
     }
+    checkRedefinitionThroughIncludes( parent, prop );
     // TODO: expand elements having direct elements (if needed)
     if (members) {
       forEachInOrder( { [prop]: members }, prop, ( elem, name ) => {
@@ -755,6 +789,24 @@ function extend( model ) {
     }
   }
 
+  /**
+   * Report duplicates in parent[prop] that happen due to multiple includes having the
+   * same member.  Covers `entity G : E, G {};` but not `entity G : E {};  extend G with F;`.
+   *
+   * TODO(v4): Make this a hard error; see checkRedefinition(); maybe combine both;
+   */
+  function checkRedefinitionThroughIncludes( parent, prop ) {
+    if (!parent[prop])
+      return;
+    forEachInOrder(parent, prop, ( member, name ) => {
+      if (member.$inferred === 'include' && Array.isArray(member.$duplicates)) {
+        const includes = [ member, ...member.$duplicates ].map(dup => dup._origin._main);
+        warning( 'ref-duplicate-include-member', [ parent.name.location, member ],
+                 { '#': prop, name, sorted_arts: includes } );
+      }
+    });
+  }
+
   // localized texts entities
 
   /**
@@ -1368,6 +1420,242 @@ function extend( model ) {
       dictAdd( proxyDict.elements, pname, proxy );
     }
   }
+
+
+  // Phase 4 - annotations ---------------------------------------------------
+
+  function extensionFor( art ) {
+    if (art.kind === 'annotate')
+      return art;
+    if (art._extension)
+      return art._extension;
+
+    // $extension means: already applied
+    const ext = {
+      kind: art.kind,           // set kind for setMemberParent()
+      $extension: 'exists',
+      location: art.location,    // location( extension to existing art ) = location(art)
+    };
+    const { location } = art.name;
+    if (!art._main) {
+      ext.name = {
+        path: [ { id: art.name.absolute, location } ],
+        location,
+        absolute: art.name.absolute,
+      };
+      if (model.extensions)
+        model.extensions.push(ext);
+      else
+        model.extensions = [ ext ];
+    }
+    else {
+      ext.name = { id: art.name.id, location };
+      const parent = extensionFor( art._parent );
+      const kind = kindProperties[art.kind].normalized || art.kind;
+      // enums would be first in elements
+      if ( parent[kindProperties[kind].dict]?.[art.name.id] )
+        throw new CompilerAssertion(art.name.id);
+      setMemberParent( ext, art.name.id, parent, kindProperties[kind].dict );
+    }
+    ext.kind = 'annotate';    // after setMemberParent()!
+    setLink( art, '_extension', ext );
+    setArtifactLink( ext.name, art );
+    if (art.returns)
+      ext.$syntax = 'returns';
+    return ext;
+  }
+
+  /**
+   * Goes through all (applied) annotations in the given artifact and chooses one
+   * if multiple exist according to the module layer.
+   *
+   * @param {XSN.Artifact} art
+   */
+  function chooseAnnotationsInArtifact( art ) {
+    for (const prop in art) {
+      if (prop.charAt(0) === '@')
+        chooseAssignment( prop, art );
+    }
+    if (art.doc)
+      chooseAssignment( 'doc', art );
+  }
+
+  function chooseAssignment( annoName, art ) {
+    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 );
+      // console.log( 'CA:', annoName, issue, assignments)
+      let index = assignments.length;
+      cont = !!index;           // safety
+      while (--index >= 0) {
+        const a = assignments[index];
+        scheduledAssignments.push( a );
+        if (!annotationHasEllipsis( a )) {
+          cont = false;
+          break;
+        }
+      }
+      if (issue) {
+        // eslint-disable-next-line no-nested-ternary
+        const msg = (index < 0)
+          ? 'anno-unstable-array'
+          : (issue === true)
+            ? 'anno-duplicate'
+            : 'anno-duplicate-unrelated-layer';
+        const variant = annoName === 'doc' ? 'doc' : 'std';
+        for (const a of assignments) {
+          if (!a.$errorReported) {
+            message( msg, [ a.name?.location || a.location, art ],
+                     { '#': variant, anno: annoName } );
+          }
+        }
+      }
+      else if (index > 0) {     // more than one set (not just ...)
+        const variant = annoName === 'doc' ? 'doc' : 'std';
+        while (index >= 0) {    // do not report for trailing [...]
+          const a = assignments[index--];
+          warning( 'anno-duplicate-same-file', [ a.name?.location || a.location, art ],
+                   { '#': variant, anno: annoName } );
+        }
+      }
+    }
+    // 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 );
+  }
+
+  function applyAssignment( previousAnno, anno, art, annoName ) {
+    const hasBase = previousAnno?.literal === 'array';
+    if (!previousAnno) {
+      const firstEllipsis = annotationHasEllipsis( anno );
+      if (!firstEllipsis)
+        return anno;
+      if (anno.$priority) {   // already complained about with Define
+        const loc = firstEllipsis.location || anno.name.location;
+        message( 'anno-unexpected-ellipsis-layers', [ loc, art ], { code: '...' } );
+      }
+      previousAnno = { val: [] };
+    }
+    else if (previousAnno.literal !== 'array') {
+      // TODO: If we introduce sub-messages, point to the non-array base value.
+      error( 'anno-mismatched-ellipsis', [ 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 && hasBase) {
+          // non-matched UP TO; if there is no base to apply to, there is already an error.
+          warning( null, [ item.upTo.location, art ], { anno: annoName, code: '... up to' },
+                   'The $(CODE) value does not match any item in the base annotation $(ANNO)' );
+        }
+      }
+    }
+    // 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, art, annoName, isFullUpTo ) {
+    const { literal } = upToSpec;
+    if (!isFullUpTo) {          // inside struct of UP TO
+      if (literal !== 'struct' && literal !== 'array' )
+        return true;
+    }
+    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 ) );
+    }
+    return false;
+  }
+
+  function normalizeRef( node ) { // see to-csn.js
+    const ref = pathName( node.path );
+    return node.variant ? `${ ref }#${ node.variant.id }` : ref;
+  }
+
+  // formerly in shared.js: -----------------------------------------------------
+
+  // Copy annotations from `ext` to `art`, overwriting inferred ones.
+  // TODO: move to extend.js if not used anymore in define.js
+  function copyAnnotationsForExtensions( ext, art ) {
+    for (const annoProp in ext) {
+      if (annoProp.charAt(0) === '@' || annoProp === 'doc') {
+        const extAnno = ext[annoProp];
+        if (art[annoProp]?.$inferred)
+          art[annoProp] = extAnno; // overwrite $inferred annos
+        else
+          dictAddArray( art, annoProp, extAnno );
+      }
+    }
+  }
 }
 
 /**
@@ -1399,9 +1687,10 @@ function layeredAssignments( assignments ) {
 /**
  * Return assignments of the highest layers.
  * Also returns whether there could be an issue:
- * - false: there is just one assignment
+ * - false: there are just assignments in one file,
  * - 'unrelated': there is just one assignment per layer
- * - true: there is at least one layer with two or more assignments
+ * - true: there is at least one layer with two or more assignments, and
+ *   at least two files are involved
  * TODO: make this usable for extend (elements), too.
  *
  * @param {Record<string, object>} layeredAnnos Structure as returned by layeredAssignments()
@@ -1414,7 +1703,7 @@ function assignmentsOfHighestLayers( layeredAnnos ) {
     const name = layerNames[0];
     const { assignments } = layeredAnnos[name] || { assignments: [] };
     delete layeredAnnos[name];
-    return { assignments, issue: assignments.length > 1 };
+    return { assignments, issue: inMoreThanOneFile( assignments ) };
   }
 
   // collect all layers which are lower than another layer
@@ -1436,13 +1725,27 @@ function assignmentsOfHighestLayers( layeredAnnos ) {
     }
   }
   assignments.sort( compareAssignments );
-  const good = highest.every( layer => layer.assignments.length === 1 );
+  const good = highest.every( layer => !inMoreThanOneFile( layer.assignments ));
   // 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 inMoreThanOneFile( assignments ) {
+  if (assignments.length <= 1)
+    return false;
+  // annotations have no location with implicit `true`, doc have no name:
+  const file = (assignments[0].name || assignments[0]).location?.file;
+  return !file || assignments.slice(1).some( a => (a.name || a).location?.file !== file );
+}
+
+/**
+ * Compare two assignments which are not comparable via layering:
+ * - via the fs.realpath of the file (not layer!) of the assignments, then
+ * - via the line, then column of the assignments.
+ * Returns <0 if `a`<`b`, >1 if `a`>`b`, i.e. can be used for ascending sort.
+ */
 function compareAssignments( a, b ) {
   const fileA = layers.realname( a._block );
   const fileB = layers.realname( b._block );

package/lib/compiler/finalize-parse-cdl.js

@@ -13,8 +13,7 @@
 
 'use strict';
 
-const { dictAddArray } = require('../base/dictionaries');
-const { forEachGeneric, forEachMember } = require('../base/model');
+const { forEachGeneric } = require('../base/model');
 const { setLink, setArtifactLink } = require('./utils');
 
 
@@ -42,7 +41,6 @@ function finalizeParseCdl( model ) {
     for (const name in extensionsDict) {
       for (const ext of extensionsDict[name]) {
         ext.name.absolute = resolveUncheckedPath( ext.name, 'extend', ext );
-        mergeAnnotatesForSameArtifact( ext ); // TODO: should not be necessary anymore
         // Initialize members and define annotations in sub-elements.
         initMembers( ext, ext, ext._block, true );
         extensions.push( ext );
@@ -96,8 +94,6 @@ function finalizeParseCdl( model ) {
 
     if (artifact.from) {
       const { from } = artifact;
-      // Note: `_from` only contains sources necessary for calculating elements,
-      //       not e.g. those from the `where exists` clause.
       resolveUncheckedPath(from, 'from', main);
       resolveTypesForParseCdl(from, main);
     }
@@ -108,11 +104,6 @@ function finalizeParseCdl( model ) {
       if (parseCdlSpeciallyHandledXsnProps.includes(prop) || parseCdlIgnoredXsnProps.includes(prop))
         continue;
 
-      // define.js (and initMembers()) initializes annotations.  If there is a duplicate, the
-      // annotation is an array in XSN.
-      if (prop[0] === '@' && Array.isArray(artifact[prop]))
-        chooseAndReportDuplicateAnnotation(artifact, prop);
-
       if (artifact[prop] && Object.getPrototypeOf(artifact[prop]) === null)
         // Dictionary in XSN
         forEachGeneric(artifact, prop, art => resolveTypesForParseCdl(art, art));
@@ -172,12 +163,10 @@ function finalizeParseCdl( model ) {
       const name = resolveUncheckedPath( artWithType.type, 'type', user );
       const type = name && model.definitions[name] || { name: { absolute: name } };
       resolveTypeArgumentsUnchecked( artWithType, type, user );
-      return;
     }
     else if (!user._main) {
       error( 'ref-undefined-typeof', [ artWithType.type.location, user ], {},
              'Current artifact has no element to refer to as type' );
-      return;
     }
     else if (root.id === '$self' || root.id === '$projection') {
       setArtifactLink( root, user._main );
@@ -206,49 +195,6 @@ function finalizeParseCdl( model ) {
       setArtifactLink( root, fake );
     }
   }
-
-  function chooseAndReportDuplicateAnnotation( artifact, annoName ) {
-    for (const anno of artifact[annoName])
-      message( 'anno-duplicate', [ anno.name.location, artifact ], { anno: annoName } );
-
-    // Choose any annotation, doesn't matter because of the error above.
-    artifact[annoName] = artifact[annoName][0];
-  }
-
-  /**
-   * For duplicate entries in `annotate {}` blocks, we de-duplicate the entries and merge them.
-   * Since it is allowed in "normal" compilations to have e.g.
-   * `annotate E with { @anno1 id, @anno2 id }`.
-   *
-   * @param {object} ext
-   */
-  function mergeAnnotatesForSameArtifact( ext ) {
-    if (!ext || typeof ext !== 'object')
-      return;
-
-    forEachMember(ext, sub => mergeAnnotatesForSameArtifact(sub));
-
-    // do not do a complex merge:
-    if (isComplexExtension( ext ) ||
-        !Array.isArray( ext.$duplicates ) || ext.$duplicates.some( isComplexExtension ))
-      return;
-    for (const dup of ext.$duplicates) {
-      for (const prop in dup) {
-        if (prop.charAt(0) === '@')
-          dictAddArray( ext, prop, dup[prop] );
-      }
-    }
-    delete ext.$duplicates;
-  }
-}
-
-/**
- * We only de-duplicate an extend/annotate `ext` in function
- * mergeAnnotatesForSameArtifact() if the extend/annotate is simple, i.e. has
- * no members like elements.
- */
-function isComplexExtension( ext ) {
-  return ext.kind !== 'annotate' || ext.elements || ext.parameters || ext.actions;
 }
 
 module.exports = finalizeParseCdl;

package/lib/compiler/kick-start.js

@@ -33,7 +33,7 @@ function kickStart( model ) {
     const art = model.definitions[name];
     if (!('_parent' in art))
       return;                   // nothing to do for builtins and redefinitions
-    if (art._from && !('_ancestors' in art))
+    if (art.query && !('_ancestors' in art))
       setProjectionAncestors( art );
 
     let parent = art._parent;
@@ -72,13 +72,12 @@ function kickStart( model ) {
     // no need to set preferredRedirectionTarget in the while loop as we would
     // use the projection having @cds.redirection.target anyhow instead of
     // `art` anyway (if we do the no-x-service-implicit-redirection TODO above)
-    while (art && !('_ancestors' in art) &&
-           art._from && art._from.length === 1 &&
-           (preferredRedirectionTarget || !annotationIsFalse( art['@cds.redirection.target'] ) ) &&
-           art.query.op && art.query.op.val === 'SELECT') {
+    while (art?.query?.from?.path && // direct select with one source
+           art._ancestors !== 0 &&        // prevent inf-loop
+           (preferredRedirectionTarget || !annotationIsFalse( art['@cds.redirection.target'] ) )) {
       chain.push( art );
-      setLink( art, '_ancestors', null ); // avoid infloop with cyclic from
-      const name = resolveUncheckedPath( art._from[0], 'include', art ); // TODO: 'include'?
+      setLink( art, '_ancestors', 0 ); // avoid infloop with cyclic from
+      const name = resolveUncheckedPath( art.query.from, 'include', art ); // TODO: 'include'?
       art = name && model.definitions[name];
       if (autoexposed)
         break;                  // only direct projection for auto-exposed