@sap/cds-compiler 4.9.4 → 5.0.6

package/lib/compiler/shared.js

@@ -19,7 +19,6 @@ const {
   isAssocToPrimaryKeys,
   artifactRefLocation,
 } = require('./utils');
-const { isBetaEnabled } = require('../base/model');
 
 const $inferred = Symbol.for( 'cds.$inferred' );
 const $location = Symbol.for( 'cds.$location' );
@@ -56,13 +55,14 @@ function fns( model ) {
       lexical: userBlock,
       dynamic: modelDefinitions,
       notFound: undefinedForAnnotate,
+      accept: extendableArtifact,
     },
     extend: {
       isMainRef: 'no-generated',
       lexical: userBlock,
       dynamic: modelDefinitions,
       notFound: undefinedDefinition,
-      accept: acceptRealArtifact,
+      accept: extendableArtifact,
     },
     _extensions: {
       isMainRef: 'all',
@@ -163,7 +163,7 @@ function fns( model ) {
       param: paramSemantics,
     },
     'limit-offset': 'limit-rows',
-    // general element references -----------------------------------------------
+    // general element / variable references --------------------------------------
     where: {
       lexical: tableAliasesAndSelf,
       dollar: true,
@@ -279,7 +279,7 @@ function fns( model ) {
     annotation: { // annotation assignments
       lexical: justDollarAliases,
       dollar: true,
-      dynamic: parentElements,
+      dynamic: parentElementsOrKeys,
       navigation: assocOnNavigation,
       noDep: true,
       notFound: undefinedParentElement,
@@ -298,6 +298,7 @@ function fns( model ) {
       }),
     },
     // TODO: introduce some kind of inheritance
+    // used by xpr-rewrite.js to resolve rewritten path roots.
     annoRewrite: { // annotation assignments
       lexical: justDollarAliases,
       dollar: true,
@@ -323,6 +324,7 @@ function fns( model ) {
     resolveTypeArgumentsUnchecked, // TODO: move to some other file
     resolvePathRoot,
     resolvePath,
+    resolveDefinitionName,
     checkExpr,
     checkOnCondition,
     navigationEnv,
@@ -405,6 +407,7 @@ function fns( model ) {
 
     const s = referenceSemantics[expected];
     const semantics = (typeof s === 'string') ? referenceSemantics[s] : s;
+    semantics.name = expected;
 
     const r = getPathRoot( ref, semantics, origUser );
     const root = r && acceptPathRoot( r, ref, semantics, origUser );
@@ -512,6 +515,25 @@ function fns( model ) {
     artifact.$typeArgs = undefined;
   }
 
+  // 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;
+
+    // Don't resolve paths in an annotation as a definition!
+    const definitions = art.kind === 'annotation' ? model.vocabularies : model.definitions;
+
+    let name = art.name.id;
+    if (art.kind === 'namespace') // namespace-statements are ref-only.
+      setArtifactLink( path[path.length - 1], definitions[name] || false );
+
+    for (let i = path.length - 1; i > 0; --i) {
+      name = name.substring(0, name.length - path[i].id.length - 1);
+      setArtifactLink( path[i - 1], definitions[name] || false );
+    }
+  }
+
   function getPathRoot( { path, scope, location }, semantics, user ) {
     // TODO: use string value of isMainRef?
     const head = path[0];
@@ -524,8 +546,11 @@ function fns( model ) {
       ruser = ruser._outer;
 
     // Handle expand/inline, `type of`, :param, global (internally for CDL):
-    if (user._pathHead && !semantics.isMainRef) // in expand/inline
+    if (user._pathHead && !semantics.isMainRef) { // in expand/inline
+      const { name } = semantics;
       semantics = semantics.nestedColumn();
+      semantics.name = name;
+    }
     if (typeof scope === 'string') { // typeOf, param, global
       semantics = semantics?.[scope] && semantics[scope]( ruser, path, location, semantics );
       if (!semantics) {
@@ -563,10 +588,13 @@ function fns( model ) {
     if (r)
       return setArtifactLink( head, r );
 
-    if (!semantics.dollar)
+    if (!semantics.dollar) {
       valid.push( dynamicDict );
-    else
-      valid.push( model.$magicVariables.elements, removeDollarNames( dynamicDict ) );
+    }
+    else {
+      valid.push( removeInvalidMagicVariables( model.$magicVariables.elements, semantics ),
+                  removeDollarNames( dynamicDict ) );
+    }
     // TODO: streamline function arguments (probably: user, path, semantics )
     const undef = semantics.notFound?.( user._user || user, head, valid, dynamicDict,
                                         !isMainRef && user._user && user._artifact,
@@ -629,7 +657,6 @@ function fns( model ) {
         // simple 'ref-undefined-art'/'ref-undefined-def' - TODO: which we
         // could "change" to this message at the end of compile():
         error( 'ref-unexpected-autoexposed', [ item.location, user ], { art },
-               // eslint-disable-next-line max-len
                'An auto-exposed entity can\'t be referred to - expose entity $(ART) explicitly' );
         return null;            // continuation semantics: like “not found”
       }
@@ -663,9 +690,13 @@ function fns( model ) {
     // Do not accept a lonely table alias and `$projection`
     // TODO: test table alias and mixin named `$projection`
     if (path.length !== 1 || user.expand || user.inline) {
-      // Rewrite $projection to $self
-      if (semantics.rewriteProjectionToSelf && art.kind === '$self' && path[0].id === '$projection')
+      if (semantics.rewriteProjectionToSelf &&
+          art.kind === '$self' && path[0].id === '$projection') {
+        // Rewrite $projection to $self
         path[0].id = '$self';
+        warning( 'ref-expecting-$self', [ path[0].location, user ],
+                 { code: '$projection', newcode: '$self' });
+      }
       return art.name?.$inferred !== '$internal'; // not a compiler-generated internal alias
     }
 
@@ -725,7 +756,14 @@ function fns( model ) {
         message( 'ref-obsolete-parameters', [ head.location, user ],
                  { code: `$parameters.${ id }`, newcode: `:${ id }` },
                  'Obsolete $(CODE) - replace by $(NEWCODE)' );
-        // TODO: replace it in to-csn correspondingly, probably v5 or later in v4 ?
+        return art;
+      }
+      case 'builtin': {
+        if (art.name.id === '$at') {
+          warning( 'ref-deprecated-variable', [ head.location, user ],
+                   { code: '$at', newcode: '$valid' },
+                   '$(CODE) is deprecated; use $(NEWCODE) instead' );
+        }
         return art;
       }
       default:
@@ -868,6 +906,13 @@ function fns( model ) {
     return environment( useParent ? user._parent : user );
   }
 
+  function parentElementsOrKeys( user ) {
+    // annotations on foreign keys only ever have access to their keys (except of course via $self)
+    if (user.kind === 'key')
+      return user._parent?.foreignKeys || Object.create( null );
+    return parentElements( user );
+  }
+
   function queryElements( user ) {
     return environment( user );
   }
@@ -1113,11 +1158,11 @@ function fns( model ) {
       // TODO: if it becomes non-configurable, we can omit this warning
       let id = pathName( path );
       let head = path[0]._artifact || { _parent: art };
-      // eslint-disable-next-line no-cond-assign
       while ((head = head?._parent) && head.kind === 'builtin')
         id = `${ head.name.id }.${ id }`;
       const msgId = (art.$uncheckedElements) ? 'ref-unknown-var' : 'ref-undefined-var';
-      signalNotFound( msgId, [ item.location, user ], valid, { id }, semantics );
+      signalNotFound( msgId, [ item.location, user ],
+                      removeInvalidMagicVariables( valid, semantics ), { id }, semantics );
     }
     else if (art.kind === 'aspect' && !art.name) { // anonymous target aspect - TODO: still?
       signalNotFound( 'ref-undefined-element', [ item.location, user ], valid,
@@ -1199,9 +1244,16 @@ function fns( model ) {
       : acceptElemOrVar( art, user, ref );
   }
 
-  function acceptElemOrVar( art, user, ref ) {
+  function acceptElemOrVar( art, user, ref, semantics ) {
     const { path } = ref;
     if (art.kind === 'builtin') {
+      if (art.$onlyInExprCtx && !art.$onlyInExprCtx.includes(semantics.name)) {
+        error( 'ref-unexpected-var', [ ref.location, user ], {
+          '#': art.$onlyInExprCtx[0], name: pathName( path ),
+        });
+        return null;
+      }
+
       if (user.expand || user.inline) {
         const location = (user.expand || user.inline)[$location];
         const code = (user.expand) ? '{ ‹expand› }' : '.{ ‹inline› }';
@@ -1234,16 +1286,19 @@ function fns( model ) {
     return art;
   }
 
-  function acceptRealArtifact( art, user, ref ) {
+  /**
+   * Returns true, if the artifact is a _real_ artifact that can be used for `extend`/`annotate`.
+   */
+  function extendableArtifact( art, user, ref ) {
     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 } );
+    if (user.kind === 'extend' && !(user.elements || user.actions || user.includes))
+      return art; // allow `extend with definitions` and empty extends
+
+    // for `annotate`, handle "namespaces" just like unknown artifacts: only emit a warning
+    signalNotFound( user.kind === 'annotate' ? 'ext-undefined-def' : 'ref-undefined-def',
+                    [ location, user ], null, { art } );
     return false;
   }
 
@@ -1459,7 +1514,7 @@ function fns( model ) {
     // console.log('NAV:',expr.path.map(r=>r.id),self)
     if (self || self == null && columnRefStartsWithSelf( user )) {
       checkOnlyForeignKeyNavigation( user, expr.path, 0, 'self-' );
-      checkNoUnmanaged( expr, user, 'self-unmanaged' );
+      checkNoUnmanaged( expr, user, true, 'self-unmanaged' );
     }
     // TODO: set navigation dependencies later to avoid both ref-cyclic and
     // ref-invalid-navigation/ref-unexpected-assoc
@@ -1469,18 +1524,20 @@ function fns( model ) {
     const { path } = expr;
     if (!path)
       return;
-    if (path?.[0]?._navigation?.kind !== '$tableAlias')
+    const self = path?.[0]?._navigation?.kind !== '$tableAlias';
+    if (self)
       checkOnlyForeignKeyNavigation( user, expr.path );
-    checkNoUnmanaged( expr, user );
+    checkNoUnmanaged( expr, user, self );
   }
 
   function checkRefInQuery( expr, exprCtx, user ) {
     const { path } = expr;
     if (!path)
       return;
-    if (pathStartsWithSelf( expr ))
+    const self = pathStartsWithSelf( expr );
+    if (self)
       checkOnlyForeignKeyNavigation( user, expr.path, 0, 'self-' );
-    checkNoUnmanaged( expr, user );
+    checkNoUnmanaged( expr, user, self );
   }
 
   function checkExpandInlineRef( art, user, ref ) {
@@ -1523,10 +1580,10 @@ function fns( model ) {
     }
     const index = userTargetElementPathIndex( user, path );
     checkOnlyForeignKeyNavigation( user, path, index );
-    if (ref._artifact?.on) {
+    const last = path[path.length - 1];
+    if (!last.where && ref._artifact?.on) { // filter already complained about
       const target = index > 0 && index < path.length && ref._artifact?.target;
       const msg = (target?._artifact === user._main) ? 'self' : 'unmanaged';
-      const last = path[path.length - 1];
       error( 'ref-unexpected-assoc', [ last.location, user ],
              { '#': msg, code: '= $self' } );
     }
@@ -1614,6 +1671,16 @@ function fns( model ) {
         index = checkCoveredByForeignKey( assoc, path, index, user, msgPrefix );
       }
       assoc = path[index]?._artifact;
+      if (assoc?.target) {
+        // testing this above is not enough: we would not complain about $self
+        // assoc filter at end of ref with expand/inline. We might also move the
+        // unmanaged test above to here.
+        if (path[index]?.where) {
+          error( 'ref-unexpected-assoc', [ path[index].location, user ],
+                 { '#': `${ msgPrefix }with-filter`, alias: '$self' } );
+          return;
+        }
+      }
     }
   }
 
@@ -1635,7 +1702,6 @@ function fns( model ) {
     const txt = index >= path.length
       ? 'complete'
       : (isAssocToPrimaryKeys( assoc ) ? 'keys' : 'std');
-    // eslint-disable-next-line max-len
     error( 'ref-invalid-navigation', [ last.location, user ], {
       '#': msgPrefix + txt, art: assoc, name: last.id, alias: '$self',
     }, {
@@ -1653,10 +1719,12 @@ function fns( model ) {
     return path.length;
   }
 
-  function checkNoUnmanaged( ref, user, messageVariant = 'unmanaged' ) {
+  function checkNoUnmanaged( ref, user, self, messageVariant = 'unmanaged' ) {
     if (ref._artifact?.on && !ref.$expected) {
       const { path } = ref;
       const last = path[path.length - 1];
+      if (self && last.where)   // already complained about filter
+        return;
       error( 'ref-unexpected-assoc', [ last.location, user ],
              { '#': messageVariant, alias: '$self' } );
     }
@@ -1745,6 +1813,19 @@ function fns( model ) {
   }
 }
 
+function removeInvalidMagicVariables( variables, semantics ) {
+  if (Array.isArray(variables))
+    return variables.map(variable => removeInvalidMagicVariables( variable, semantics ));
+
+  const valid = Object.create(null);
+  for (const name in variables) {
+    const variable = variables[name];
+    if (!variable.$onlyInExprCtx || variable.$onlyInExprCtx.includes( semantics.name ))
+      valid[name] = variable;
+  }
+  return valid;
+}
+
 function removeDollarNames( dict ) {
   const r = Object.create( null );
   for (const name in dict) {

package/lib/compiler/tweak-assocs.js

@@ -5,7 +5,6 @@
 const {
   forEachGeneric,
   forEachInOrder,
-  isBetaEnabled,
 } = require('../base/model');
 const { dictLocation, weakLocation, weakRefLocation } = require('../base/location');
 
@@ -45,8 +44,6 @@ function tweakAssocs( model ) {
     firstProjectionForPath,
   });
 
-  const isV5preview = isBetaEnabled( model.options, 'v5preview' );
-
   // Phase 5: rewrite associations
   model._entities.forEach( rewriteArtifact );
   // Think hard whether an on condition rewrite can lead to a new cyclic
@@ -111,9 +108,7 @@ function tweakAssocs( model ) {
       info( 'assoc-target-not-in-service', loc,
             { 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',
             } );
     }
@@ -129,7 +124,7 @@ function tweakAssocs( model ) {
   }
 
   function rewriteAssociationCheck( element ) {
-    const elem = element.items || element; // TODO v5: nested items
+    const elem = element.items || element; // TODO v6: nested items
     if (elem.elements)
       forEachGeneric( elem, 'elements', rewriteAssociationCheck );
     if (!elem.target)
@@ -236,7 +231,7 @@ function tweakAssocs( model ) {
   }
 
   function rewriteAssociation( element ) {
-    let elem = element.items || element; // TODO v5: nested items
+    let elem = element.items || element; // TODO v6: nested items
     if (elem.elements)
       forEachGeneric( elem, 'elements', rewriteAssociation );
     if (elem.targetAspect?.elements)
@@ -456,15 +451,6 @@ function tweakAssocs( model ) {
     };
     setArtifactLink( elem.type, assocType._artifact );
 
-    if (!isV5preview) { // TODO(v5): Remove, only use $enclosed
-      elem.$filtered = {
-        val: true,
-        literal: 'boolean',
-        location,
-        $inferred: '$generated',
-      };
-    }
-
     const isComp = (getUnderlyingBuiltinType( assoc )?.name?.id === 'cds.Composition');
     if (isComp) {
       elem.$enclosed = {

package/lib/compiler/utils.js

@@ -125,7 +125,8 @@ function proxyCopyMembers( art, dictProp, originDict, location, kind, tmpDepreca
       // TODO throughout the compiler: do not set art.‹prop›.$inferred if art.$inferred
       if (kind)
         member.kind = kind;
-      else if (origin.key && !tmpDeprecated) // TODO(v5/v6): remove tmpDeprecated
+      else if (origin.key && !tmpDeprecated)
+        // TODO(v6): remove tmpDeprecated once `noKeyPropagationWithExpansions` is removed
         member.key = Object.assign( { $inferred: 'expanded' }, origin.key );
       if (kind && origin.masked)  // TODO: remove!
         member.masked = Object.assign( { $inferred: 'nav' }, origin.masked );

package/lib/compiler/xsn-model.js

@@ -27,6 +27,10 @@ class XsnSource {
   artifacts = Object.create( null );
   vocabularies = Object.create( null );
   extensions = [];
+  $frontend;
+  constructor( frontend ) {
+    this.$frontend = frontend;
+  }
 }
 
 class XsnArtifact {