@sap/cds-compiler 6.4.2 → 6.4.6

package/lib/compiler/shared.js

@@ -49,6 +49,13 @@ function fns( model ) {
       dynamic: modelDefinitions,
       notFound: undefinedDefinition,
     },
+    // scope:'global': for cds.Association and auto-redirected targets
+    $global: {
+      isMainRef: 'all',
+      lexical: null,
+      dynamic: modelDefinitions,
+      notFound: undefinedDefinition,
+    },
     // only used for the main annotate/extend statements, not inner ones:
     annotate: {
       isMainRef: 'all',
@@ -85,7 +92,7 @@ function fns( model ) {
       accept: acceptEntity,
       noDep: true,
       // special `scope`s for auto-redirections:
-      global: () => ({ isMainRef: 'all', dynamic: modelDefinitions }),
+      global: () => '$global',
     },
     targetAspect: {
       isMainRef: 'no-autoexposed',
@@ -102,6 +109,7 @@ function fns( model ) {
       notFound: undefinedDefinition,
       accept: acceptQuerySource,
       noDep: '',                // dependency special for from
+      args: () => 'from-args',
     },
     type: {
       isMainRef: 'no-autoexposed',
@@ -112,11 +120,11 @@ function fns( model ) {
       accept: acceptTypeOrElement,
       // special `scope`s for CDL parser - TYPE OF (TODO generated?), cds.Association:
       typeOf: typeOfSemantics,
-      global: () => ({
-        isMainRef: 'no-autoexposed',
-        dynamic: modelDefinitions,
-        navigation: staticTarget, // TODO: Object.assign() with main
-      }),
+      global: () => '$global',  // TODO: do we need `navigation: staticTarget`?
+    },
+    $typeOf: {
+      dynamic: typeOfParentDict,
+      navigation: staticTarget,
     },
     // element references without lexical scope (except $self/$projection): -----
     targetElement: {
@@ -125,22 +133,24 @@ function fns( model ) {
       dynamic: targetElements,
       navigation: targetNavigation,
       notFound: undefinedTargetElement,
-      param: paramSemantics,
+      param: () => '$scopePar',
     },
     filter: {
       lexical: justDollarAliases,
       dollar: true,
       dynamic: targetElements,
       notFound: undefinedTargetElement,
-      param: paramSemantics,
+      param: () => '$scopePar',
+      nestedColumn: () => 'filter',
     },
-    'calc-filter': {
+    'calc-filter': {            // TODO: what is so special about this?
       lexical: justDollarAliases,
       dollar: true,
       dynamic: targetElements,
       navigation: calcElemNavigation,
       notFound: undefinedTargetElement,
       param: paramUnsupported,
+      filter: () => 'calc-filter',
     },
     default: {
       lexical: null,
@@ -154,7 +164,7 @@ function fns( model ) {
       dollar: true,
       dynamic: () => Object.create( null ),
       notFound: undefinedVariable,
-      param: paramSemantics,
+      param: () => '$scopePar',
     },
     'limit-offset': 'limit-rows',
     // general element / variable references --------------------------------------
@@ -164,7 +174,7 @@ function fns( model ) {
       dynamic: combinedSourcesOrParentElements,
       notFound: undefinedSourceElement,
       check: checkRefInQuery,
-      param: paramSemantics,
+      param: () => '$scopePar',
     },
     having: 'where',
     groupBy: 'where',
@@ -174,22 +184,15 @@ function fns( model ) {
       dynamic: combinedSourcesOrParentElements,
       notFound: undefinedSourceElement,
       check: checkColumnRef,
-      param: paramSemantics,
-      nestedColumn: () => ({       // in expand and inline
-        lexical: justDollarAliases,
-        dollar: true,
-        dynamic: nestedElements,
-        notFound: undefinedNestedElement,
-        check: checkColumnRef,
-        param: paramSemantics,
-      }),
+      param: () => '$scopePar',
+      nestedColumn: () => '$srcRefInNestedColumn',
     },
     'from-args': {
       lexical: null,
       dollar: true,
       dynamic: () => Object.create( null ),
       notFound: undefinedVariable,
-      param: paramSemantics,
+      param: () => '$scopePar',
     },
     calc: {
       lexical: justDollarAliases,
@@ -198,6 +201,7 @@ function fns( model ) {
       navigation: calcElemNavigation,
       notFound: undefinedParentElement,
       param: paramUnsupported,
+      filter: () => 'calc-filter',
     },
     'join-on': {
       lexical: tableAliasesAndSelf,
@@ -205,7 +209,7 @@ function fns( model ) {
       dynamic: combinedSourcesOrParentElements,
       rejectRoot: rejectOwnExceptVisibleAliases,
       notFound: undefinedSourceElement,
-      param: paramSemantics,
+      param: () => '$scopePar',
     },
     on: {     // unmanaged assoc: outside query, redirected or new assoc in column
       lexical: justDollarAliases,
@@ -216,15 +220,8 @@ function fns( model ) {
       accept: acceptElemOrVarOrSelf,
       check: checkAssocOn,
       param: paramUnsupported,
-      nestedColumn: () => ({       // in expand and inline
-        lexical: justDollarAliases,
-        dollar: true,
-        dynamic: parentElements,
-        navigation: assocOnNavigation,
-        notFound: undefinedParentElement,
-        rewriteProjectionToSelf: true,
-      }),
       rewriteProjectionToSelf: true,
+      nestedColumn: () => '$projRefInNestedColumn',
     },
     'mixin-on': {
       lexical: tableAliasesAndSelf,
@@ -234,7 +231,7 @@ function fns( model ) {
       notFound: undefinedSourceElement,
       accept: acceptElemOrVarOrSelf,
       check: checkAssocOn,
-      param: paramSemantics, // TODO: check that assocs containing param in ON is not published
+      param: () => '$scopePar', // TODO: check that assocs containing param in ON is not published
     },
     'orderBy-ref': {
       lexical: tableAliasesAndSelf,
@@ -242,7 +239,7 @@ function fns( model ) {
       dynamic: parentElements,
       notFound: undefinedOrderByElement,
       check: checkOrderByRef,
-      param: paramSemantics,
+      param: () => '$scopePar',
     },
     'orderBy-expr': {
       lexical: tableAliasesAndSelf,
@@ -250,7 +247,7 @@ function fns( model ) {
       dynamic: combinedSourcesOrParentElements,
       notFound: undefinedSourceElement,
       check: checkRefInQuery,
-      param: paramSemantics,
+      param: () => '$scopePar',
     },
     'orderBy-set-ref': {
       lexical: tableAliasesAndSelf, // TODO: reject own tab aliases
@@ -259,7 +256,7 @@ function fns( model ) {
       rejectRoot: rejectOwnAliasesAndMixins,
       notFound: undefinedParentElement,
       check: checkOrderByRef,
-      param: paramSemantics,
+      param: () => '$scopePar',
     },
     'orderBy-set-expr': {
       lexical: tableAliasesAndSelf, // TODO: reject own tab aliases
@@ -268,7 +265,7 @@ function fns( model ) {
       rejectRoot: rejectAllOwn,
       notFound: undefinedVariable,
       check: checkRefInQuery,
-      param: paramSemantics,
+      param: () => '$scopePar',
     },
     annotation: { // annotation assignments
       lexical: justDollarAliases,
@@ -277,19 +274,14 @@ function fns( model ) {
       navigation: assocOnNavigation,
       noDep: true,
       notFound: undefinedParentElement,
+      accept: acceptElemOrAnyVar,
+      variableFilter: (dict => dict),
       messageMap: {
         'ref-undefined-element': 'anno-undefined-element',
         'ref-undefined-param': 'anno-undefined-param',
       },
-      param: paramSemantics,
-      nestedColumn: () => ({
-        lexical: justDollarAliases,
-        dollar: true,
-        dynamic: parentElements,
-        navigation: assocOnNavigation,
-        notFound: undefinedParentElement,
-        rewriteProjectionToSelf: true,
-      }),
+      param: () => '$annotationScopePar',
+      nestedColumn: () => '$projRefInNestedColumn',
     },
     // TODO: introduce some kind of inheritance
     // used by xpr-rewrite.js to resolve rewritten path roots.
@@ -300,17 +292,36 @@ function fns( model ) {
       navigation: assocOnNavigation,
       noDep: true,
       notFound: null,           // no error, just falsy links
-      param: paramSemantics,
-      nestedColumn: () => ({
-        lexical: justDollarAliases,
-        dollar: true,
-        dynamic: parentElements,
-        navigation: assocOnNavigation,
-        notFound: undefinedParentElement,
-        rewriteProjectionToSelf: true,
-      }),
+      accept: acceptElemOrAnyVar,
+      param: () => '$scopePar',
+      nestedColumn: () => '$projRefInNestedColumn',
+    },
+    $scopePar: {
+      dynamic: artifactParams,
+      notFound: undefinedParam,
+    },
+    $annotationScopePar: {
+      messageMap: {
+        'ref-undefined-element': 'anno-undefined-element',
+        'ref-undefined-param': 'anno-undefined-param',
+      },
+      dynamic: artifactParams,
+      notFound: undefinedParam,
+    },
+    // for `nestedColumn`, these two will be merged with base semantics:
+    $projRefInNestedColumn: {       // for assoc-`on` and annotations
+      lexical: justDollarAliases,
+      dynamic: parentElements,
+      navigation: assocOnNavigation, // like std `environment`, but no dependency
+      rewriteProjectionToSelf: true,
+    },
+    $srcRefInNestedColumn: {       // for column refs
+      lexical: justDollarAliases,
+      dollar: true,
+      dynamic: nestedElements,
+      navigation: environment,
+      notFound: undefinedNestedElement,
     },
-    //
   };
 
   Object.assign( model.$functions, {
@@ -389,16 +400,13 @@ function fns( model ) {
     const exit = callback( step, exprCtx, user );
     if (exit === traverseExpr.STOP)
       return true;
-    if (step.where && exit !== traverseExpr.SKIP &&
-        traverseExpr( step.where,
-                      // TODO: use property in fn dictionary above
-                      ( exprCtx === 'calc' || exprCtx === 'calc-filter'
-                        ? 'calc-filter'
-                        : 'filter' ),
-                      step, callback ) === traverseExpr.STOP)
-      return true;
+    if (step.where && exit !== traverseExpr.SKIP) {
+      const ctx = referenceSemantics[exprCtx].filter?.() || 'filter';
+      if (traverseExpr( step.where, ctx, step, callback ) === traverseExpr.STOP)
+        return true;
+    }
     if (step.args) {
-      const ctx = (exprCtx === 'from') ? 'from-args' : exprCtx;
+      const ctx = referenceSemantics[exprCtx].args?.() || exprCtx;
       const args = Array.isArray( step.args ) ? step.args : Object.values( step.args );
       // TODO: there should be no array `args` on path item
       for (const arg of args) {
@@ -412,7 +420,7 @@ function fns( model ) {
   // Special expression traversal function for `resolveExpr`.  Let's see
   // later whether we can use this version as the general one.
   // If we continue to have separate ones, remove the STOP stuff – it is not
-  // needed for `resolveExpr`.
+  // needed for `resolveExpr`; SKIP is used, though.
 
   function traverseTypedExpr( expr, exprCtx, user, type, callback ) {
     if (!expr || typeof expr === 'string') // parse error or keywords in {xpr:...}
@@ -565,16 +573,13 @@ function fns( model ) {
     const exit = callback( step, exprCtx, user, null );
     if (exit === traverseExpr.STOP)
       return true;
-    if (step.where && exit !== traverseExpr.SKIP &&
-        traverseTypedExpr( step.where,
-                           // TODO: use property in fn dictionary above
-                           ( exprCtx === 'calc' || exprCtx === 'calc-filter'
-                             ? 'calc-filter'
-                             : 'filter' ),
-                           step, null, callback ) === traverseExpr.STOP)
-      return true;
+    if (step.where && exit !== traverseExpr.SKIP) {
+      const ctx = referenceSemantics[exprCtx].filter?.() || 'filter';
+      if (traverseTypedExpr( step.where, ctx, step, null, callback ) === traverseExpr.STOP)
+        return true;
+    }
     if (step.args) {
-      const ctx = (exprCtx === 'from') ? 'from-args' : exprCtx;
+      const ctx = referenceSemantics[exprCtx].args?.() || exprCtx;
       const args = Array.isArray( step.args ) ? step.args : Object.values( step.args );
       // TODO: there should be no array `args` on path item
       for (const arg of args) {
@@ -637,7 +642,6 @@ 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 );
@@ -778,19 +782,26 @@ function fns( model ) {
         ruser = ruser._outer._outer;
     }
 
-    // Handle expand/inline, `type of`, :param, global (internally for CDL):
+    // Handle expand/inline before `type of`, :param, global (internally for CDL):
     if (user._columnParent && !semantics.isMainRef) { // in expand/inline
-      const { name } = semantics;
-      semantics = semantics.nestedColumn();
-      semantics.name = name;
+      const func = semantics.nestedColumn;
+      if (!func)
+        throw new CompilerAssertion( 'Unexpected ref context in nested column' );
+      const ctx = func();
+      semantics = (typeof ctx === 'string')
+        ? ({ ...semantics, ...referenceSemantics[ctx] })
+        : ctx;
     }
     if (typeof scope === 'string') { // typeOf, param, global
-      semantics = semantics?.[scope] && semantics[scope]( ruser, path, location, semantics );
-      if (!semantics) {
-        if (semantics == null)
-          throw new CompilerAssertion( `Scope ${ scope } is not expected here` );
+      const func = semantics[scope] || scope === 'param' && paramUnsupported;
+      // 'param' is a user scope → useful default (error msg ref-unexpected-param)
+      // 'global' and 'typeOf' are internal scopes of the compiler → dump if not provided
+      if (!func)
+        throw new CompilerAssertion( `Unexpected scope ${ scope }, no handler defined in context` );
+      const ctx = func( ruser, path, location, semantics );
+      semantics = (typeof ctx === 'string') ? referenceSemantics[ctx] : ctx;
+      if (!semantics)
         return setArtifactLink( head, null );
-      }
     }
     const valid = [];
 
@@ -825,7 +836,8 @@ function fns( model ) {
       valid.push( dynamicDict );
     }
     else {
-      valid.push( removeInvalidMagicVariables( model.$magicVariables.elements, semantics ),
+      const filterFn = semantics.variableFilter || removeRestrictedVariables;
+      valid.push( filterFn( model.$magicVariables.elements ),
                   removeDollarNames( dynamicDict ) );
     }
     // TODO: streamline function arguments (probably: user, path, semantics )
@@ -1020,11 +1032,17 @@ function fns( model ) {
         return art;
       }
       case 'builtin': {
+        // TODO: use properties in builtins
         if (art.name.id === '$at') {
           message( 'ref-deprecated-variable', [ head.location, user ],
                    { code: '$at', newcode: '$valid' },
                    '$(CODE) is deprecated; use $(NEWCODE) instead' );
         }
+        else if (art.$restricted && semantics.accept !== acceptElemOrAnyVar) {
+          error( 'ref-unexpected-var', [ head.location, user ],
+                 { '#': 'annotation', name: head.id } );
+          return null;         // no further error on `unknown` for $draft.unknown
+        }
         return art;
       }
       default:
@@ -1059,20 +1077,12 @@ function fns( model ) {
     while (struct.kind === 'element')
       struct = struct._parent;
     if (struct === user._main && struct.kind !== 'annotation')
-      return { dynamic: typeOfParentDict, navigation: staticTarget };
+      return '$typeOf';
     error( 'type-unexpected-typeof', [ head.location, user ],
            { keyword: 'type of', '#': struct.kind } );
     return false;
   }
 
-  function paramSemantics( _user, _path, _loction, semantics ) {
-    return {
-      messageMap: semantics.messageMap,
-      dynamic: artifactParams,
-      notFound: undefinedParam,
-    };
-  }
-
   function paramUnsupported( user, _path, location ) {
     error( 'ref-unexpected-scope', [ location, user ], // TODO: ref-unexpected-param
            // why an extra text for calculated elements? or separate for all?
@@ -1430,8 +1440,7 @@ function fns( model ) {
       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 ],
-                      removeInvalidMagicVariables( valid, semantics ), { id }, semantics );
+      signalNotFound( msgId, [ item.location, user ], valid, { id }, semantics );
     }
     else if (art.kind === 'aspect' && !art.name) { // anonymous target aspect - TODO: still?
       signalNotFound( 'ref-undefined-element', [ item.location, user ], valid,
@@ -1513,16 +1522,17 @@ function fns( model ) {
       : acceptElemOrVar( art, user, ref );
   }
 
-  function acceptElemOrVar( art, user, ref, semantics ) {
+  function acceptElemOrVar( art, user, ref ) {
+    if (art.kind !== 'builtin' || !art.$restricted)
+      return acceptElemOrAnyVar( art, user, ref );
+    error( 'ref-unexpected-var', [ ref.location, user ],
+           { '#': 'annotation', name: pathName( ref.path ) } );
+    return null;
+  }
+
+  function acceptElemOrAnyVar( art, user, ref ) {
     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› }';
@@ -2035,7 +2045,8 @@ function fns( model ) {
     const err = message( semantics?.messageMap?.[msgId] || msgId, location, textParams );
     if (valid) {
       const user = Array.isArray( location ) && location[1];
-      err.validNames = (user && definedViaCdl( user )); // viaCdl -> '.'?
+      // TODO: see TODO missing param `viaCdl` in attachAndEmitValidNames:
+      err.validNames = (user && definedViaCdl( user ));
       valid.reverse();
       attachAndEmitValidNames( err, ...valid );
     }
@@ -2076,6 +2087,8 @@ function fns( model ) {
     const valid = Object.assign( Object.create( null ), ...validDicts );
     msg.validNames = Object.create( null );
     for (const name of Object.keys( valid )) {
+      if (!name)
+        continue;
       const art = valid[name];
       // ignore internal types such as cds.Association, ignore names with dot for
       // CDL references to main artifacts:
@@ -2100,14 +2113,19 @@ function fns( model ) {
   }
 }
 
-function removeInvalidMagicVariables( variables, semantics ) {
-  if (Array.isArray(variables))
-    return variables.map(variable => removeInvalidMagicVariables( variable, semantics ));
-
+/**
+ * Filter out restricted variables from a dictionary of variables.
+ * Variables with the `$restricted` property set to true are excluded.
+ *
+ * @param {object} variables - Dictionary of variable objects
+ * @returns {object} New dictionary with restricted variables removed
+ */
+function removeRestrictedVariables( variables ) {
+  // TODO: we could also do something with `deprecated`, $requiresBetaFlag, …
   const valid = Object.create(null);
   for (const name in variables) {
     const variable = variables[name];
-    if (!variable.$onlyInExprCtx || variable.$onlyInExprCtx.includes( semantics.name ))
+    if (!variable.$restricted)
       valid[name] = variable;
   }
   return valid;

package/lib/compiler/tweak-assocs.js

@@ -457,7 +457,7 @@ function tweakAssocs( model ) {
       return;
 
     if (elem._parent?.kind === 'element') {
-      // managed association as sub element not supported yet
+      // unmanaged association as sub element not supported yet
       // TODO: Only report once for multi-include chains, see
       //       Associations/SubElements/UnmanagedInSubElement.err.cds
       error( 'type-unsupported-rewrite', [ elem.location, elem ], { '#': 'sub-element' } );