@sap/cds-compiler 4.8.0 → 4.9.2

package/lib/compiler/propagator.js

@@ -20,30 +20,16 @@ const {
   linkToOrigin,
   withAssociation,
   viewFromPrimary,
+  copyExpr,
 } = require('./utils');
+const { propagationRules } = require('../base/builtins');
 const $inferred = Symbol.for( 'cds.$inferred' );
+const { xprRewriteFns } = require('./xpr-rewrite');
 // const { ref } = require( '../model/revealInternalProperties' )
 
 // Note that propagation here is also used for deep-copying (function `onlyViaParent`)
 function propagate( model ) {
   const props = {
-    '@com.sap.gtt.core.CoreModel.Indexable': never,
-    '@cds.persistence.exists': never, // also copied in generate.js
-    '@cds.persistence.table': never,
-    '@cds.persistence.calcview': never,
-    '@cds.persistence.udf': never,
-    '@cds.persistence.skip': notWithPersistenceTable, // also copied in generate.js
-    // '@cds.tenant.independent' is propagated as normal, but also copied in generate.js
-    '@sql.append': never,
-    '@sql.prepend': never,
-    '@sql.replace': never,
-    '@Analytics.hidden': never,
-    '@Analytics.visible': never,
-    '@cds.autoexpose': onlyViaArtifact,
-    '@cds.autoexposed': never,  // in case people set it themselves
-    '@cds.external': never,
-    '@cds.redirection.target': never,
-    '@fiori.draft.enabled': onlyViaArtifact,
     '@': annotation,            // always except in 'items' (and parameters for entity return types)
     doc: annotation,            // always except in 'items' (and parameters for entity return types)
     default: withKind,          // always except in 'items'
@@ -70,9 +56,20 @@ function propagate( model ) {
     enum: expensive,
     params: expensive,          // actually only with parent action
     returns,
-    $filtered: annotation,
+    $filtered: annotation, // TODO(v5): Remove
+    $enclosed: annotation,
   };
+  const ruleToFunction = {
+    __proto__: null,
+    never,
+    onlyViaArtifact,
+    notWithPersistenceTable,
+  };
+  for (const rule in propagationRules)
+    props[rule] = ruleToFunction[propagationRules[rule]];
+
   const { options } = model;
+  const { rewriteAnnotationsRefs } = xprRewriteFns( model );
   // eslint-disable-next-line max-len
   const oldVirtualNotNullPropagation = isDeprecatedEnabled( options, '_oldVirtualNotNullPropagation' );
   const { warning, throwWithError } = model.$messageFunctions;
@@ -103,7 +100,7 @@ function propagate( model ) {
       const news = [];
       for (const target of targets) {
         const origin = getOrigin( target );
-        if (origin) {
+        if (origin && origin.kind !== '$self') {
           // Calculated elements that are simple references: `calc = field;`.
           // Respect sibling properties in inheritance.
           if (target._calcOrigin?._origin && target.value?._artifact) {
@@ -202,6 +199,10 @@ function propagate( model ) {
       target[prop] = [ ...val ];
       target[prop].$inferred = 'prop';
     }
+    else if (prop.charAt(0) === '@' && val?.kind === '$annotation') {
+      target[prop] = Object.assign( copyExpr( val ), { $inferred: 'prop' } );
+      rewriteAnnotationsRefs( target, source, prop );
+    }
     else {
       target[prop] = Object.assign( {}, val, { $inferred: 'prop' } );
       if (val._artifact !== undefined)
@@ -270,6 +271,7 @@ function propagate( model ) {
     target[prop][$inferred] = 'prop';
   }
 
+  // Only propagate if parent object (which is not necessarily `_parent`) was propagated.
   function onlyViaParent( prop, target, source ) {
     if (target.$inferred === 'proxy' || target.$inferred === 'expanded')
       // assocs and enums do not have 'include'
@@ -279,6 +281,8 @@ function propagate( model ) {
   function targetAspect( prop, target, source ) {
     if (target.targetAspect)
       return;
+    if (target.type?._artifact === model.definitions['cds.Association'])
+      return; // don't propagate targetAspect to associations (e.g. via $enclosed)
     const ta = source.targetAspect;
     if (!ta.elements && !ta._origin) { // _origin set for elements in source
       notWithExpand( prop, target, source );

package/lib/compiler/resolve.js

@@ -44,7 +44,6 @@ const {
   forEachGeneric,
   forEachInOrder,
   isDeprecatedEnabled,
-  isBetaEnabled,
 } = require('../base/model');
 const { dictAdd } = require('../base/dictionaries');
 const { dictLocation, weakLocation } = require('../base/location');
@@ -126,6 +125,11 @@ function resolve( model ) {
     // Phase 4: resolve all artifacts:
     forEachDefinition( model, resolveRefs );
     forEachGeneric( model, 'vocabularies', resolveRefs );
+    if (model.options.lspMode) {
+      for (const name in model.sources)
+        resolveDefinitionName( model.sources[name].namespace );
+    }
+
     // create “super” ANNOTATE statements for annotations on unknown artifacts:
     createRemainingAnnotateStatements();
     // report cyclic dependencies:
@@ -178,9 +182,12 @@ function resolve( model ) {
           // Path could start with table alias; get start index
           let index = path.indexOf(nav.item);
           if (index === -1)
-            return;
+            return; // should not happen
 
           let navItem = nav.navigation;
+          if (!nav.item._navigation) // first non-table-alias
+            setLink( nav.item, '_navigation', navItem );
+
           if (path[index].where || path[index].args)
             return;
           ++index;
@@ -363,6 +370,9 @@ function resolve( model ) {
     const allowedInMain = [ 'entity', 'aspect', 'event' ].includes( adHocOrMainKind( art ) );
     const isTopLevelElement = parent && (parent.kind !== 'element' || parent.targetAspect);
 
+    if (model.options.lspMode && art.name && !art._main)
+      resolveDefinitionName( art );
+
     // Check KEY (TODO: make this an extra function)
     const { key } = art;
     if (key?.val && !key.$inferred) {
@@ -557,10 +567,12 @@ function resolve( model ) {
       const sType = specifiedElement.type?._artifact;
       const iTypeArt = getInferredPropFromOrigin( 'type' )?._artifact;
       const iType = iTypeArt || inferredElement;
-
-      // xor: could be missing a type;
       // FIXME: The coding above returns incorrect iType for expand on associations
 
+      // $enclosed: maybe composition was changed to association; we allow that change here.
+      const compToAssoc = sType === model.definitions['cds.Association'] && inferredElement.target;
+
+      // xor: could be missing a type;
       if (!specifiedElement.type && inferredElement.type) {
         error( 'query-mismatched-element', [ specifiedElement.location, user ], {
           '#': !specifiedElement.type ? 'missing' : 'extra', name: user.name.id, prop: 'type',
@@ -568,7 +580,7 @@ function resolve( model ) {
         return;
       }
       // If specified type is `null`, type could not be resolved.
-      else if (sType && sType !== iType &&
+      else if (!compToAssoc && sType && sType !== iType &&
         // Special case for $recompilation: allow one level of type indirection. See #12113.
         (!model.options.$recompile || sType !== iType.type?._artifact)) {
         const typeName = !iTypeArt && 'typeExtra' ||  // no inferred type prop
@@ -1348,6 +1360,19 @@ function resolve( model ) {
   // General resolver functions
   //--------------------------------------------------------------------------
 
+  // Resolve the n-1 path steps before the definition name for LSP.
+  function resolveDefinitionName( art ) {
+    const path = art?.name?.path;
+    if (!art || art._main || !path || path.length <= 1)
+      return;
+
+    let name = art.name.id;
+    for (let i = path.length - 1; i > 0; --i) {
+      name = name.substring(0, name.length - path[i].id.length - 1);
+      setArtifactLink( path[i - 1], model.definitions[name] || false );
+    }
+  }
+
   // Resolve the type and its arguments if applicable.
   function resolveTypeExpr( art, user ) {
     const typeArt = resolvePath( art.type, 'type', user );
@@ -1367,7 +1392,6 @@ function resolve( model ) {
       if (!anno.kind)
         initAnnotationForExpression( anno, art );
       resolveExpr( expr, 'annotation', anno );
-      reportUnsupportedAnnoExpr( expr );
     }
     else if (expr.literal === 'array') {
       expr.val.forEach( val => resolveAnnoExpr( val, art, anno ) );
@@ -1377,32 +1401,22 @@ function resolve( model ) {
     }
   }
 
-  function reportUnsupportedAnnoExpr( expr ) {
-    if (isBetaEnabled( model.options, 'annotationExpressions' ))
-      return;
-    const alreadyReported = model.$messageFunctions.messages
-      .find(msg => msg.messageId === 'anno-experimental-expressions');
-    if (!alreadyReported) {
-      // due to test mode and shuffling, we would get a different location on each compilation.
-      const loc = model.options.testMode ? null : [ expr.location ];
-      info( 'anno-experimental-expressions', loc, {
-        option: 'annotationExpressions',
-        // eslint-disable-next-line max-len
-      }, 'Expressions in annotation values are a beta feature. Use at your own risk. (This message can be suppressed with beta flag $(OPTION))' );
-    }
-  }
-
-  // for faster processing, mark artifacts and annotations which contain anno expressions
+  /**
+   * For faster processing, mark artifacts and annotations which contain anno expressions
+   *
+   * @param {object} anno
+   * @param {XSN.Artifact} art
+   */
   function initAnnotationForExpression( anno, art ) {
     anno.kind = '$annotation';
     setLink( anno, '_outer', art );
-    while (!art.$contains?.$annotation) {
-      art.$contains ??= {};
-      art.$contains.$annotation = true; // TODO: extra values for elem and $self refs
-      if (!art._main)
-        break;
-      art = art._parent;        // TODO: really go up?
-    }
+    art.$contains ??= {};
+    art.$contains.$annotation = { // set in resolveExprItem
+      $path: false,
+      $self: false,
+    };
+    // Think about tagging parents too (like before #12636).
+    // Might be useful for future recursive types.
   }
 
   function resolveExpr( expr, exprCtx, user ) {
@@ -1434,6 +1448,11 @@ function resolve( model ) {
           resolveParamsAndWhere( step, expected, user, step === last );
         // TODO: delete 4th arg
       }
+
+      if (expected === 'annotation') {
+        user._outer.$contains.$annotation.$path = true;
+        user._outer.$contains.$annotation.$self ||= expr.path[0]?._navigation?.kind === '$self';
+      }
     }
     else if (expr.query) {
       const { query } = expr;

package/lib/compiler/shared.js

@@ -19,6 +19,7 @@ const {
   isAssocToPrimaryKeys,
   artifactRefLocation,
 } = require('./utils');
+const { isBetaEnabled } = require('../base/model');
 
 const $inferred = Symbol.for( 'cds.$inferred' );
 const $location = Symbol.for( 'cds.$location' );
@@ -133,14 +134,14 @@ function fns( model ) {
       param: paramSemantics,
     },
     filter: {
-      lexical: justDollarSelf,
+      lexical: justDollarAliases,
       dollar: true,
       dynamic: targetElements,
       notFound: undefinedTargetElement,
       param: paramSemantics,
     },
     'calc-filter': {
-      lexical: justDollarSelf,
+      lexical: justDollarAliases,
       dollar: true,
       dynamic: targetElements,
       navigation: calcElemNavigation,
@@ -181,7 +182,7 @@ function fns( model ) {
       check: checkColumnRef,
       param: paramSemantics,
       nestedColumn: () => ({       // in expand and inline
-        lexical: justDollarSelf,
+        lexical: justDollarAliases,
         dollar: true,
         dynamic: nestedElements,
         notFound: undefinedNestedElement,
@@ -197,7 +198,7 @@ function fns( model ) {
       param: paramSemantics,
     },
     calc: {
-      lexical: justDollarSelf,
+      lexical: justDollarAliases,
       dollar: true,
       dynamic: parentElements,
       navigation: calcElemNavigation,
@@ -213,7 +214,7 @@ function fns( model ) {
       param: paramSemantics,
     },
     on: {     // unmanaged assoc: outside query, redirected or new assoc in column
-      lexical: justDollarSelf,
+      lexical: justDollarAliases,
       dollar: true,
       dynamic: parentElements,
       navigation: assocOnNavigation,
@@ -222,7 +223,7 @@ function fns( model ) {
       check: checkAssocOn,
       param: paramUnsupported,
       nestedColumn: () => ({       // in expand and inline
-        lexical: justDollarSelf,
+        lexical: justDollarAliases,
         dollar: true,
         dynamic: parentElements,
         navigation: assocOnNavigation,
@@ -276,7 +277,7 @@ function fns( model ) {
       param: paramSemantics,
     },
     annotation: { // annotation assignments
-      lexical: justDollarSelf,  // TODO: forbid $projection
+      lexical: justDollarAliases,
       dollar: true,
       dynamic: parentElements,
       navigation: assocOnNavigation,
@@ -287,8 +288,8 @@ function fns( model ) {
         'ref-undefined-param': 'anno-undefined-param',
       },
       param: paramSemantics,
-      nestedColumn: () => ({       // in expand and inline - TODO
-        lexical: justDollarSelf,
+      nestedColumn: () => ({
+        lexical: justDollarAliases,
         dollar: true,
         dynamic: parentElements,
         navigation: assocOnNavigation,
@@ -298,14 +299,21 @@ function fns( model ) {
     },
     // TODO: introduce some kind of inheritance
     annoRewrite: { // annotation assignments
-      lexical: justDollarSelf,  // TODO: forbid $projection
+      lexical: justDollarAliases,
       dollar: true,
       dynamic: parentElements,
       navigation: assocOnNavigation,
       noDep: true,
       notFound: null,           // no error, just falsy links
       param: paramSemantics,
-      // nestedColumn:     // in expand and inline - TODO
+      nestedColumn: () => ({
+        lexical: justDollarAliases,
+        dollar: true,
+        dynamic: parentElements,
+        navigation: assocOnNavigation,
+        notFound: undefinedParentElement,
+        rewriteProjectionToSelf: true,
+      }),
     },
   };
 
@@ -313,9 +321,11 @@ function fns( model ) {
     traverseExpr,
     resolveUncheckedPath,
     resolveTypeArgumentsUnchecked, // TODO: move to some other file
+    resolvePathRoot,
     resolvePath,
     checkExpr,
     checkOnCondition,
+    navigationEnv,
     nestedElements,
     attachAndEmitValidNames,
   } );
@@ -354,7 +364,6 @@ function fns( model ) {
     const { path } = ref;
     if (!path || path.broken) // incomplete type AST
       return undefined;
-
     const semantics = referenceSemantics[refCtx];
     if (!semantics.isMainRef)
       throw new CompilerAssertion( `resolveUncheckedPath() called for reference ctx '${ refCtx }'` );
@@ -628,6 +637,22 @@ function fns( model ) {
     return art;
   }
 
+  /**
+   * Resolve the _path-root_ only.  Used for rewriting annotation paths.
+   *
+   * @param ref
+   * @param {string} expected
+   * @param user
+   */
+  function resolvePathRoot( ref, expected, user ) {
+    if (ref == null || !ref.path) // no references -> nothing to do
+      return undefined;
+    const s = referenceSemantics[expected];
+    const semantics = (typeof s === 'string') ? referenceSemantics[s] : s;
+    const r = getPathRoot( ref, semantics, user );
+    return r && acceptPathRoot( r, ref, semantics, user );
+  }
+
   // Helper functions for resolve[Unchecked]Path, getPath{Root,Item}: -----------
 
   function acceptLexical( art, path, semantics, user ) {
@@ -687,9 +712,14 @@ function fns( model ) {
         // TODO: remove again, should be easy enough in to-csn without.
         if (path.length === 1 && art.kind === '$tableAlias')
           (user._user || user).$noOrigin = true;
+        if (head.id === '$projection' && user.kind === '$annotation') {
+          error( 'ref-unsupported-projection', [ head.location, user ],
+                 { code: '$projection', newcode: '$self' },
+                 '$(CODE) is not supported in annotations; replace by $(NEWCODE)' );
+        }
         return art;
       }
-      case '$parameters': {     // TODO: remove from CC
+      case '$parameters': {
         // TODO: if ref.scope='param' is handled, test that here, too ?
         const { id } = path[1];
         message( 'ref-obsolete-parameters', [ head.location, user ],
@@ -756,10 +786,10 @@ function fns( model ) {
   function userBlock( user ) {
     return definedViaCdl( user ) && user._block;
   }
-  function justDollarSelf( user ) {
+  function justDollarAliases( user ) {
     const query = userQuery( user );
     if (!query)
-      return user._main || user;
+      return user._main || user; // TODO: also contains `up_` for aspects; remove
     // query.$tableAliases contains both aliases and $self/$projection
     const aliases = query.$tableAliases;
     const r = Object.create( null );
@@ -783,7 +813,7 @@ function fns( model ) {
       const aliases = userQuery( user ).$tableAliases;
       user.$extended = Object.keys( aliases )[0];
     }
-    return justDollarSelf( user );
+    return justDollarAliases( user );
   }
 
   // Functions called via semantics.dynamic: ------------------------------------
@@ -829,7 +859,13 @@ function fns( model ) {
     return query._combined;     // TODO: do we need query._parent._combined ?
   }
   function parentElements( user ) {
-    return environment( user._main && user.kind !== 'select' ? user._parent : user );
+    // Note: We could have `$self` in bound actions refer to its entity, but reject it now.
+    // If users request it, we can either allow it later or point them to binding parameters.
+    const useParent = user._main &&
+      user.kind !== 'select' &&
+      user.kind !== 'action' &&
+      user.kind !== 'function';
+    return environment( useParent ? user._parent : user );
   }
 
   function queryElements( user ) {
@@ -1144,7 +1180,7 @@ function fns( model ) {
         // corresponding column expression; this might have references to elements
         // of invisible table aliases; at least one stakeholder uses this,
         // so it can't be an error (yet).
-        warning( 'ref-deprecated-self-element', [ ref.path[0].location, user._user ], {},
+        message( 'ref-deprecated-self-element', [ ref.path[0].location, user._user ], {},
                  // eslint-disable-next-line max-len
                  'Referring to the query\'s own elements here might lead to invalid SQL references; use source elements only' );
         return false;
@@ -1199,8 +1235,12 @@ function fns( model ) {
   }
 
   function acceptRealArtifact( art, user, ref ) {
-    // For compatibility, we accept `extend Unknown` without elements/actions/includes
-    if (art.kind !== 'namespace' || !(user.elements || user.actions || user.includes))
+    if (art.kind !== 'namespace')
+      return art;
+    // For compatibility (≤v4), we accept `extend Unknown` without elements/actions/includes
+    // In v5, only allow `extend with definitions`.
+    if (!isBetaEnabled( model.options, 'v5preview' ) &&
+      !(user.elements || user.actions || user.includes))
       return art;
     const { location } = ref.path[ref.path.length - 1];
     signalNotFound( 'ref-undefined-def', [ location, user ], null, { art } );