@sap/cds-compiler 6.3.6 → 6.4.6

package/lib/compiler/extend.js

@@ -261,8 +261,7 @@ function extend( model ) {
       const { name } = ext;
       const { path } = name;
       if (name._artifact === undefined) {
-        const refCtx = (name.id.startsWith( 'localized.' )) ? '_extensions' : ext.kind;
-        resolvePath( name, refCtx, ext ); // for LSP
+        resolvePath( name, ext.kind, ext ); // induce error & for LSP
       }
       else if (model.options.lspMode && path?.[0]._artifact === undefined) {
         // we don't use resolvePath(…,'extend'), as that would add a dependency
@@ -487,13 +486,17 @@ function extend( model ) {
       return anno;
     const hasBase = previousAnno?.literal === 'array';
     if (!previousAnno) {
-      const location = firstEllipsis.location || anno.name.location;
-      message( 'anno-unexpected-ellipsis', [ location, art ], { code: '...' } );
+      const { location } = anno.name;
+      if (annoName !== '@extension.code') {
+        // Remark: we could allow that for all annotations which are not propagated
+        message( 'anno-unexpected-ellipsis', [ firstEllipsis.location || location, art ],
+                 { code: '...' } );
+      }
       previousAnno = {
         kind: '$annotation',
         val: [],
         literal: 'array',
-        name: { id: annoName.slice( 1 ) },
+        name: anno.name,
         location,
       };
     }
@@ -899,11 +902,9 @@ function extend( model ) {
   function createSuperAnnotate( annotate ) {
     const extensions = annotate._extensions;
     if (extensions && !annotate._main) {
-      const { id } = annotate.name;
-      const isLocalized = id.startsWith( 'localized.' ); // TODO: && anno
-      const art = model.definitions[id];
+      const art = model.definitions[annotate.name.id];
       for (const ext of extensions)
-        checkRemainingMainExtensions( art, ext, isLocalized );
+        checkRemainingMainExtensions( art, ext );
       if (art?.builtin && art.kind !== 'namespace') { // TODO: do not set `builtin` on cds, cds.hana
         setLink( annotate, '_extensions', art._extensions ); // for messages and member extensions
         // direct annotations on builtins or on the builtins for propagation, and
@@ -923,24 +924,14 @@ function extend( model ) {
     forEachMember( annotate, createSuperAnnotate );
   }
 
-  function checkRemainingMainExtensions( art, ext, localized ) {
-    const isExtend = ext.kind === 'extend';
-    if (localized) {
-      if (isExtend) {
-        // In v5, reject any `extend` on localized.
-        error( 'ref-undefined-art', [ ext.location || ext.name.location, ext ],
-               { '#': 'localized', keyword: 'annotate' } );
-      }
-      return;
-    }
-
+  function checkRemainingMainExtensions( art, ext ) {
     if (!resolvePath( ext.name, ext.kind, ext )) // error for extend, info for annotate
       return;
 
     if (art?.builtin) {
       info( 'anno-builtin', [ ext.name.location, ext ], {} ); // TODO: better location?
     }
-    else if (isExtend && art?.kind === 'namespace') {
+    else if (ext.kind === 'extend' && art?.kind === 'namespace') {
       // `annotate` on namespaces already handled before
       const hasAnnotations = Object.keys(ext).find(a => a.charAt(0) === '@');
       const firstAnno = ext[hasAnnotations];
@@ -992,7 +983,7 @@ function extend( model ) {
    * includes, do so without includes.
    */
   function applyExtensions() {
-    let noIncludes = false;
+    let cyclicIncludeNames = false;
     let extNames = Object.keys( extensionsDict ).sort();
 
     while (extNames.length) {
@@ -1000,35 +991,37 @@ function extend( model ) {
       for (const name of extNames) {
         const art = model.definitions[name];
         if (art && art.kind !== 'namespace' &&
-            extendArtifact( extensionsDict[name], art, noIncludes ))
+            extendArtifact( extensionsDict[name], art, cyclicIncludeNames ))
           delete extensionsDict[name];
       }
       extNames = Object.keys( extensionsDict ); // no sort() required anymore
       if (extNames.length >= length)
-        noIncludes = Object.keys( extensionsDict ); // = no includes
+        cyclicIncludeNames = Object.keys( extensionsDict ); // = no includes
     }
   }
 
   /**
-   * Extend artifact `art` by `extensions`.  `noIncludes` can have values:
-   * - false: includes are applied, extend and annotate is performed
-   * - true:  includes are not applied, extend and annotate is performed
-   * - 'gen': no includes and no extensions allowed, annotate is performed
+   * Extend artifact `art` by `extensions`.  `cyclicIncludeNames` can have values:
+   * - falsy: try to apply include, then perform extend and annotate
+   * - an array of include names with cyclic dependencies: includes are not applied,
+   *   extend and annotate is performed
+   *   remark: we could have applied includes without cycle
+   *
+   * Returns true if extend and annotate are performed.
    *
    * @param {XSN.Extension[]} extensions
    * @param {XSN.Definition} art
-   * @param {boolean|'gen'} [noIncludes=false]
+   * @param {String[]|false} [cyclicIncludeNames=false]
    */
-  function extendArtifact( extensions, art, noIncludes = false ) {
-    if (!noIncludes && !(canApplyIncludes( art, art ) &&
+  function extendArtifact( extensions, art, cyclicIncludeNames = null ) {
+    if (!cyclicIncludeNames && !(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 ) );
+    if (cyclicIncludeNames) {
+      canApplyIncludes( art, art, cyclicIncludeNames );
+      extensions.forEach( ext => canApplyIncludes( ext, art, cyclicIncludeNames ) );
     }
-    else if (!noIncludes &&
-             !(canApplyIncludes( art, art ) &&
+    else if (!(canApplyIncludes( art, art ) &&
                extensions.every( ext => canApplyIncludes( ext, art ) ))) {
       // console.log( 'FALSE:',art.name, extensions.map( e => e.name ) )
       return false;
@@ -1038,17 +1031,18 @@ function extend( model ) {
       art.$entity = ++model.$entity;
     }
     if (art.includes) {
-      if (!noIncludes) {
+      if (!cyclicIncludeNames) {
         applyIncludes( art, art );
       }
       else {
+        // resolve artifacts to induce errors: either ref-invalid-include or ref-cyclic
         for (const ref of art.includes)
           resolvePath( ref, 'include', art );
       }
     }
     // checkExtensionsKind( extensions, art );
-    extendMembers( extensions, art, noIncludes === 'gen' );
-    if (!noIncludes && art.includes) {
+    extendMembers( extensions, art );
+    if (!cyclicIncludeNames && art.includes) {
       // early propagation of specific annotation assignments
       propagateEarly( art, '@cds.autoexpose' );
       propagateEarly( art, '@fiori.draft.enabled' );
@@ -1057,7 +1051,7 @@ function extend( model ) {
     return true;
   }
 
-  function extendMembers( extensions, art, noExtend ) {
+  function extendMembers( extensions, art ) {
     // TODO: do the whole extension stuff lazily if the elements are requested
     const elemExtensions = [];
     if (art._main)              // extensions already sorted for main artifacts
@@ -1069,11 +1063,6 @@ function extend( model ) {
       //                      'Info', 'EXT').toString())
       if (ext.name._artifact === undefined) { // not already applied
         setArtifactLink( ext.name, art );
-        if (noExtend && ext.kind === 'extend') {
-          error( 'extend-for-generated', [ ext.name.location, ext ], { art, keyword: 'extend' },
-                 'You can\'t use $(KEYWORD) on the generated $(ART)' );
-          continue;
-        }
         if (ext.includes) {
           // TODO: currently, re-compiling from gensrc does not give the exact
           // element sequence - we need something like
@@ -1207,17 +1196,17 @@ function extend( model ) {
    *
    * @param {XSN.Definition} art
    * @param {XSN.Artifact} target
-   * @param {string[]} [justResolveCyclic]
+   * @param {string[]} [cyclicIncludeNames]
    * @returns {boolean}
    */
-  function canApplyIncludes( art, target, justResolveCyclic ) {
+  function canApplyIncludes( art, target, cyclicIncludeNames ) {
     if (!art.includes)
       return true;
     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 ))
+      // console.log('CAI:',cyclicIncludeNames, name, ref.path, Object.keys(extensionsDict))
+      if (cyclicIncludeNames) {
+        if (!cyclicIncludeNames.includes( name ))
           continue;
         delete ref._artifact;
       }

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

@@ -40,7 +40,7 @@ function finalizeParseCdl( model ) {
     // TODO: why not just use the extensions as they are from the first source?
     for (const name in late) {
       for (const ext of late[name]._extensions) {
-        ext.name.id = resolveUncheckedPath( ext.name, '_extensions', ext );
+        ext.name.id = resolveUncheckedPath( ext.name, '_uncheckedExtension', ext );
         // Initialize members and define annotations in sub-elements.
         initMembers( ext, ext, ext._block, true );
         extensions.push( ext );

package/lib/compiler/lsp-api.js

@@ -7,7 +7,7 @@
 //
 // This files includes an iterator over "semantic tokens" in an XSN model.
 // "Semantic tokens" are identifiers, but also the "return" parameter.
-// See `internalDoc/lsp/IdentifierCrawling.md` for details.
+// See <../../internalDoc/lsp/IdentifierCrawling.md> for details.
 
 const { CompilerAssertion } = require('../base/error');
 const $inferred = Symbol.for( 'cds.$inferred' );

package/lib/compiler/populate.js

@@ -882,7 +882,7 @@ function populate( model ) {
     for (const name in env) {
       const navElem = env[name];
       // TODO: remove all access to masked (use 'grep')
-      if (excludingDict[name] || navElem.masked && navElem.masked.val)
+      if (excludingDict[name] || navElem.masked?.val)
         continue;
       const sibling = siblingElements[name];
       if (sibling) {          // is explicitly provided (without duplicate)
@@ -917,7 +917,7 @@ function populate( model ) {
         const elemLocation = !query._main.$inferred && location;
         const origin = envParent ? navElem : navElem._origin;
         const elem = linkToOrigin( origin, name, query, null, elemLocation );
-        if (origin.$calcDepElement) // TODO: this will be changed in the next PR
+        if (origin.$calcDepElement)
           dependsOn( elem, origin.$calcDepElement, location );
 
         // TODO: check assocToMany { * }

package/lib/compiler/propagator.js

@@ -12,6 +12,7 @@ const {
   forEachDefinition,
   forEachMember,
   forEachGeneric,
+  isBetaEnabled,
 } = require( '../base/model');
 const {
   setLink,
@@ -34,7 +35,11 @@ function propagate( model ) {
     virtual,
     notNull,
     targetElement: onlyViaParent, // in foreign keys
-    value: onlyViaParent,      // enum symbol value, calculated element
+    value: enumOrCalcValue,      // enum symbol value, calculated element
+    // `value` is also used for column expression
+    // TODO(!): think of having an extra XSN property for calculated elements,
+    // replacing `value:…`+`$syntax:'calc'` and `$calc:…
+    $calc: enumOrCalcValue,
     // masked: special = done in definer
     // key: special = done in resolver
     // actions: struct includes & primary source = in definer/resolver
@@ -59,7 +64,7 @@ function propagate( model ) {
     //   enum: expensive,
     //   params: expensive,          // actually only with parent action
     //   returns,
-    $enclosed: annotation,
+    $enclosed: annotation,      // TODO: hm
   };
   const ruleToFunction = {
     __proto__: null,
@@ -71,7 +76,7 @@ function propagate( model ) {
   for (const rule in propagationRules)
     props[rule] = ruleToFunction[propagationRules[rule]];
 
-  const { rewriteAnnotationsRefs } = xprRewriteFns( model );
+  const { rewriteAnnotationsRefs, rewriteRefsInExpression } = xprRewriteFns( model );
 
   const { message, throwWithError } = model.$messageFunctions;
 
@@ -165,7 +170,9 @@ function propagate( model ) {
     // console.log('PROPS:',ref(source),'->',ref(target),keys.join('+'))
     for (const prop of keys) {
       // TODO: warning with competing props from multi-includes, but not in propagator.js
-      if (target[prop] !== undefined || source[prop] === undefined)
+      if (target[prop] !== undefined &&
+          (prop !== 'value' || !source.$calcDepElement || !target._main?.query) ||
+          source[prop] === undefined)
         continue;
       const transformer = props[prop] || props[prop.charAt(0)];
       if (transformer)
@@ -282,6 +289,22 @@ function propagate( model ) {
     }
   }
 
+  function enumOrCalcValue( prop, destination, origin ) {
+    // Remark: with include, the calc expression has been copied early
+    if (prop === 'value' && !origin.$calcDepElement) {
+      onlyViaParent( prop, destination, origin ); // enum value
+    }
+    else if (destination.kind === 'element' &&
+             destination._main?.query && // query element
+             !destination.$calc && origin.$calc !== true &&
+             isBetaEnabled( model.options, '$calcForDraft' )) {
+      destination.$calc
+        = Object.assign( copyExpr( origin[prop] ), { $inferred: 'prop' } );
+      if (rewriteRefsInExpression( destination, origin, '$calc' ))
+        destination.$calc = true; // TODO: or { val: true }?
+    }
+  }
+
   function notWithExpand( prop, target, source ) {
     if (!target.expand || prop === 'type' && source.elements)
       always( prop, target, source );
@@ -296,13 +319,13 @@ function propagate( model ) {
   function annotation( prop, target, source ) {
     const anno = source[prop];
     if (anno.val !== null)
-      withKind( prop, target, source );
+      withKind( prop, target, source ); // TODO: unfold
   }
 
   function docComment( prop, target, source ) {
     if (model.options.propagateDocComments)
       annotation( prop, target, source );
-    else // TODO: Probably just "never"
+    else // TODO: or just "never"
       onlyViaParent( prop, target, source );
   }
 

package/lib/compiler/resolve.js

@@ -1583,12 +1583,19 @@ function resolve( model ) {
     // (for code completion)
     const last = expr.path[expr.path.length - 1];
     if (!last || !(last.args || last.where || last.cardinality) ||
-        expr.$expected === 'approved-exists' ||
         user.expand || user.inline ||
         expWithFilter.includes( expected ) ||     // `from`, …
         last._navigation?.kind === '$tableAlias') // error already reported
       return ref;
 
+    if (expr.$expected === 'approved-exists') {
+      if (last.where?.args?.length === 0) {
+        // at the moment, empty filter is not allowed on last path step
+        reportUnexpectedArgsAndFilter( last, expected, user, null, 'last-empty-filter' );
+      }
+      return ref;
+    }
+
     const type = effectiveType( last._artifact );
     const art = type && (type.kind === 'entity' ? type : type.target?._artifact);
     if (!art)
@@ -1596,7 +1603,8 @@ function resolve( model ) {
     if (last.args || last.where || last.cardinality) {
       const unexpectedFilter = (expected !== 'annotation' && expected !== 'column' &&
           expected !== 'calc' && 'std') ||
-        isQuasiVirtualAssociation( type ) && 'model-only';
+        isQuasiVirtualAssociation( type ) && 'model-only' ||
+        last.where?.args?.length === 0 && 'last-empty-filter';
       reportUnexpectedArgsAndFilter( last, expected, user, art, unexpectedFilter );
     }
     // TODO: we should have different message-ids for the "last" stuff: adding
@@ -1696,7 +1704,9 @@ function resolve( model ) {
       error( 'expr-unexpected-argument', loc, { '#': variant } );
     }
     if ((step.where || step.cardinality) && variant) {
-      const location = combinedLocation( step.where, step.cardinality );
+      const location = step.where?.location || step.cardinality?.location
+        ? combinedLocation( step.where, step.cardinality )
+        : step.location;
       // XSN TODO: filter$location including […]
       error( 'expr-unexpected-filter', [ location, user ], { '#': variant } );
     }