@sap/cds-compiler 6.3.6 → 6.4.6

package/lib/compiler/shared.js

@@ -40,6 +40,7 @@ function fns( model ) {
   } = model.$messageFunctions;
   const Functions = model.$functions;
 
+  // Map `exprCtx` (is a param of traversal functions) to reference semantics
   const referenceSemantics = {
     // global: ------------------------------------------------------------------
     using: {                    // only used to produce error message
@@ -48,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',
@@ -60,10 +68,10 @@ function fns( model ) {
       isMainRef: 'no-generated',
       lexical: userBlock,
       dynamic: modelDefinitions,
-      notFound: undefinedDefinition,
+      notFound: undefinedForExtend,
       accept: extendableArtifact,
     },
-    _extensions: {
+    _uncheckedExtension: {      // to be used only with resolveUncheckedPath()
       isMainRef: 'all',
       lexical: userBlock,
       dynamic: modelDefinitions,
@@ -76,12 +84,6 @@ function fns( model ) {
       notFound: undefinedDefinition,
       accept: acceptStructOrBare,
     },
-    _include: {                 // cyclic include: no accept
-      isMainRef: 'no-generated',
-      lexical: userBlock,
-      dynamic: modelBuiltinsOrDefinitions,
-      notFound: undefinedDefinition,
-    },
     target: {
       isMainRef: 'no-autoexposed',
       lexical: userBlock,
@@ -90,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',
@@ -107,6 +109,7 @@ function fns( model ) {
       notFound: undefinedDefinition,
       accept: acceptQuerySource,
       noDep: '',                // dependency special for from
+      args: () => 'from-args',
     },
     type: {
       isMainRef: 'no-autoexposed',
@@ -117,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: {
@@ -130,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,
@@ -159,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 --------------------------------------
@@ -169,7 +174,7 @@ function fns( model ) {
       dynamic: combinedSourcesOrParentElements,
       notFound: undefinedSourceElement,
       check: checkRefInQuery,
-      param: paramSemantics,
+      param: () => '$scopePar',
     },
     having: 'where',
     groupBy: 'where',
@@ -179,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,
@@ -203,6 +201,7 @@ function fns( model ) {
       navigation: calcElemNavigation,
       notFound: undefinedParentElement,
       param: paramUnsupported,
+      filter: () => 'calc-filter',
     },
     'join-on': {
       lexical: tableAliasesAndSelf,
@@ -210,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,
@@ -221,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,
@@ -239,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,
@@ -247,7 +239,7 @@ function fns( model ) {
       dynamic: parentElements,
       notFound: undefinedOrderByElement,
       check: checkOrderByRef,
-      param: paramSemantics,
+      param: () => '$scopePar',
     },
     'orderBy-expr': {
       lexical: tableAliasesAndSelf,
@@ -255,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
@@ -264,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
@@ -273,7 +265,7 @@ function fns( model ) {
       rejectRoot: rejectAllOwn,
       notFound: undefinedVariable,
       check: checkRefInQuery,
-      param: paramSemantics,
+      param: () => '$scopePar',
     },
     annotation: { // annotation assignments
       lexical: justDollarAliases,
@@ -282,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.
@@ -305,15 +292,35 @@ 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,
     },
   };
 
@@ -393,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) {
@@ -416,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:...}
@@ -569,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) {
@@ -641,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 );
@@ -782,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 = [];
 
@@ -829,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 )
@@ -853,7 +861,7 @@ function fns( model ) {
     const { isMainRef } = semantics;
     if (isMainRef) {
       artItemsCount = (typeof ref.scope === 'number' && ref.scope) ||
-                      (ref.scope ? 1 : path.length);
+        (ref.scope ? 1 : path.length);
     }
     let art = null;
     const elementsEnv = semantics.navigation || environment;
@@ -1024,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:
@@ -1063,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?
@@ -1287,26 +1293,36 @@ function fns( model ) {
 
   function undefinedForAnnotate( user, item, valid, _dict, prev, path ) {
     // in a CSN source, only one env was tested (valid.length 1):
-    const art = (!prev) ? item.id : searchName( prev, item.id, 'absolute' );
+    const name = (prev) ? `${ prev.name.id }.${ item.id }` : item.id;
     if (!user.elements && !user.actions && !user.enum && !user.params &&
-        couldBeDraftsEntity( item.id, valid, prev, path ))
-      return;
-    if (couldBeDraftAdminDataEntity( item ) )
+        endsWithSuffix( name, '.drafts', art => art?._service && art.kind === 'entity' ) ||
+        endsWithSuffix( name, '.DraftAdministrativeData',
+                        ( art, prefix ) => (art?.kind === 'service' || prefix === 'DRAFT') ) ||
+        name === 'DRAFT' && path?.length === 2 && path[1].id === 'DraftAdministrativeData' ||
+        name.startsWith( 'localized.' )) // TODO: only if suffix is defined
       return;
     signalNotFound( (valid.length > 1 ? 'ext-undefined-art' : 'ext-undefined-def'),
                     // TODO: ext-undefined-xyz
-                    [ item.location, user ], valid, { art } );
+                    [ item.location, user ], valid, { art: name } );
   }
 
-  function couldBeDraftsEntity( id, valid, prev, path ) {
-    const entity = prev
-      ? prev === path[path.length - 2]._artifact && prev // TODO: Should check for '.drafts'?
-      : path.length === 1 && id.endsWith( '.drafts' ) && model.definitions[id.slice( 0, -7 )];
-    return entity?.kind === 'entity' && !!entity._service;
+  function undefinedForExtend( user, item, valid, _dict, prev ) {
+    // in a CSN source, only one env was tested (valid.length 1):
+    const name = (prev) ? `${ prev.name.id }.${ item.id }` : item.id;
+    if (name.startsWith( 'localized.' )) {
+      error( 'ref-undefined-art', [ user.name.location || user.location, user ],
+             { '#': 'localized', keyword: 'annotate' } );
+    }
+    else {
+      undefinedDefinition( user, item, valid, _dict, prev );
+    }
   }
 
-  function couldBeDraftAdminDataEntity( item ) {
-    return item.id === 'DraftAdministrativeData' && !item._artifact;
+  function endsWithSuffix( name, suffix, cond ) {
+    if (!name.endsWith( suffix ))
+      return false;
+    const prefix = name.slice( 0, -suffix.length );
+    return cond( model.definitions[prefix], prefix, name );
   }
 
   function undefinedParam( user, head, valid, _dict, _art, _path, semantics ) {
@@ -1424,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,
@@ -1507,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› }';
@@ -1537,7 +1553,7 @@ function fns( model ) {
     }
     // TODO: combine $requireElementAccess/$autoElement to $bareRoot ?
     else if (!user.expand && !user.inline &&  // $self._artifact to main artifact
-        !(art._main && art.kind !== 'select') && ref.path[0]._navigation?.kind === '$self') {
+             !(art._main && art.kind !== 'select') && ref.path[0]._navigation?.kind === '$self') {
       // TODO: better ref-invalid-self
       const { location, id } = path[0];
       error( 'ref-unexpected-self', [ location, user ], { id } );
@@ -1655,7 +1671,7 @@ function fns( model ) {
       }
     }
     else if (source.kind !== 'entity' &&
-        !acceptEventProjectionSource( source, user )) {
+             !acceptEventProjectionSource( source, user )) {
       signalNotFound( 'ref-invalid-source', [ ref.location, user ], null,
                       { '#': user._main.kind } );
       return (source === art) ? art : false; // art to show cyclic issues
@@ -1937,8 +1953,8 @@ function fns( model ) {
     // has to be run after foreign-key rewrite
     const outer = user._columnParent?._origin;
     let assoc = outer?.foreignKeys &&
-                pathStartsWithSelf( { path } ) == null && // not $self or CDS var like $now
-                outer;
+      pathStartsWithSelf( { path } ) == null && // not $self or CDS var like $now
+      outer;
     for (let index = startIndex; index < path.length; ++index) {
       if (assoc?.target) {
         if (!assoc.foreignKeys) {
@@ -2029,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 );
     }
@@ -2070,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:
@@ -2094,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;