@sap/cds-compiler 4.3.2 → 4.4.0

package/lib/compiler/populate.js

@@ -26,7 +26,7 @@ const {
 const {
   dictAdd, dictAddArray, dictFirst, dictForEach,
 } = require('../base/dictionaries');
-const { weakLocation } = require('../base/location');
+const { weakLocation, weakRefLocation } = require('../base/location');
 const { CompilerAssertion } = require('../base/error');
 
 const { kindProperties } = require('./base');
@@ -36,7 +36,6 @@ const {
   annotationVal,
   annotationIsFalse,
   annotationLocation,
-  augmentPath,
   linkToOrigin,
   setMemberParent,
   proxyCopyMembers,
@@ -113,6 +112,7 @@ function populate( model ) {
 
   /** Make sure that effectiveType() is called on all members and items */
   function traverseElementEnvironments( art ) {
+    // TODO: we could leave out foreign keys (but they are traversed via forEachMember)
     let type = effectiveType( art );
     while (type?.items)
       type = effectiveType( type.items );
@@ -376,8 +376,7 @@ function populate( model ) {
       art.items = 0;            // circular
       return true;
     }
-    const ref = art.type || art.value || art.name;
-    const location = ref && ref.location || art.location;
+    const location = weakRefLocation( art.type || art.value ) || weakLocation( art.location );
     art.items = { $inferred: 'expanded', location };
     setLink( art.items, '_outer', art );
     setLink( art.items, '_parent', art._parent );
@@ -403,10 +402,10 @@ function populate( model ) {
       return true;
     }
     const ref = art.type || art.value || art.name;
-    const location = ref && ref.location || art.location;
+    const location = weakRefLocation( ref ) || weakLocation( art.location );
     // console.log( message( null, location, art, {target:struct,art}, 'Info','EXPAND-ELEM')
     //              .toString(), Object.keys(struct.elements))
-    proxyCopyMembers( art, 'elements', struct.elements, weakLocation( location ),
+    proxyCopyMembers( art, 'elements', struct.elements, location,
                       null, isDeprecatedEnabled( options, 'noKeyPropagationWithExpansions' ) );
     // Set elements expansion status (the if condition is always true, as no
     // elements expansion will take place on artifact with existing other
@@ -421,8 +420,8 @@ function populate( model ) {
     if (art.enum)
       return false;
     const ref = art.type || art.value || art.name;
-    const location = weakLocation( ref && ref.location || art.location );
-    proxyCopyMembers( art, 'enum', origin.enum, weakLocation( location ) );
+    const location = weakRefLocation( ref ) || weakLocation( art.location );
+    proxyCopyMembers( art, 'enum', origin.enum, location );
     // Set elements expansion status (the if condition is always true, as no
     // elements expansion will take place on artifact with existing other
     // member property):
@@ -521,6 +520,9 @@ function populate( model ) {
     for (const id in (art.elements || art.enum)) {
       const ielem = art.elements ? art.elements[id] : art.enum[id];  // inferred element
       const selem = art.elements$ ? art.elements$[id] : art.enum$[id]; // specified element
+      // TODO: the positions are very strange, at least for enums
+      // see e.g. for test3/Queries/SpecifiedElements/SpecifiedElements.err.csn
+      // better to complain at the end position of the enum dict
       if (!selem) {
         info( 'query-missing-element', [ ielem.name.location, art ], {
           '#': ielem.kind === 'enum' ? 'enum' : 'std', id,
@@ -799,7 +801,9 @@ function populate( model ) {
   // TODO: disallow $self.elem.* and $self.*, toSelf.* (circular dependency)
   function expandWildcard( wildcard, siblingElements, colParent, query ) {
     const { elements } = query.items || query;
-    let location = wildcard.location || query.from && query.from.location || query.location;
+    let location = wildcard.location ||
+                   weakRefLocation( query.from ) ||
+                   weakLocation( query.location );
     const inferred = query._main.$inferred;
     const excludingDict = (colParent || query).excludingDict || Object.create( null );
 
@@ -845,19 +849,24 @@ function populate( model ) {
       }
       else {
         location = weakLocation( location );
+        // Usually, the location of a `*`-inferred element is the location of the `*`.
+        // For inferred entities, it is the location of the corresponding source elem
+        // (from all generated entities, only auto-exposed are “wildcard projections”):
+        const elemLocation = !query._main.$inferred && location;
         const origin = envParent ? navElem : navElem._origin;
-        const elem = linkToOrigin( origin, name, query, null, location );
+        const elem = linkToOrigin( origin, name, query, null, elemLocation );
         // TODO: check assocToMany { * }
         dictAdd( elements, name, elem, ( _name, loc ) => {
           // there can be a definition from a previous inline with the same name:
           error( 'duplicate-definition', [ loc, query ], { name, '#': 'element' } );
         } );
-        elem.$inferred = '*';
-        elem.name.$inferred = '*';
+        if (!query._main.$inferred || origin.$inferred)
+          elem.$inferred = '*';
+        elem.name.$inferred = '*'; // matters for A2J
         if (envParent)
           setWildcardExpandInline( elem, envParent, origin, name, location );
         else
-          setElementOrigin( elem, navElem, name, location );
+          setElementOrigin( elem, navElem, name, elem.location );
       }
     }
     if (envParent || query.kind !== 'select') {
@@ -1293,12 +1302,12 @@ function populate( model ) {
       return target;
     }
     // console.log(absolute)
-    const { location } = target.name;
-    const from = augmentPath( location, target.name.id );
+    const location = weakRefLocation( target.name );
+    const from = { path: [ { id: target.name.id, location } ], location };
     let art = {
       kind: 'entity',
       name: { location, id: absolute },
-      location: target.location,
+      location,
       query: { location, op: { val: 'SELECT', location }, from },
       $syntax: 'projection',
       $inferred: 'autoexposed',
@@ -1311,14 +1320,14 @@ function populate( model ) {
     if (target.params) {
       art.params = Object.create( null );
       // is art.query.from.path[0].$syntax: ':' required?
-      art.query.from.path[0].args = Object.create( null );
+      from.path[0].args = Object.create( null );
       forEachGeneric( target, 'params', (p, pn) => {
-        art.params[pn] = linkToOrigin( p, pn, art, 'params', p.location );
-        art.query.from.path[0].args[pn] = {
-          name: { id: p.name.id, location: p.location },
-          location: p.location,
+        art.params[pn] = linkToOrigin( p, pn, art, 'params' );
+        from.path[0].args[pn] = {
+          name: { id: p.name.id, location },
+          location,
           scope: 'param',
-          path: [ { id: pn, location: p.location } ],
+          path: [ { id: pn, location } ],
         };
       } );
     }

package/lib/compiler/propagator.js

@@ -48,7 +48,7 @@ function propagate( model ) {
     virtual,
     notNull,
     targetElement: onlyViaParent, // in foreign keys
-    value: onlyViaParent,      // enum symbol value
+    value: onlyViaParent,      // enum symbol value, calculated element
     // masked: special = done in definer
     // key: special = done in resolver
     // actions: struct includes & primary source = in definer/resolver
@@ -248,7 +248,10 @@ function propagate( model ) {
     for (const name in dict) {
       const member = linkToOrigin( dict[name], name, target, prop, location );
       member.$inferred = 'proxy';
-      setEffectiveType( member, dict[name] );
+      if (prop === 'foreignKeys')
+        setLink( member, '_effectiveType', member );
+      else
+        setEffectiveType( member, dict[name] );
     }
     target[prop][$inferred] = 'prop';
   }
@@ -380,6 +383,7 @@ function checkAndSetStatus( art ) {
 }
 
 function setEffectiveType( target, source ) {
+  // TODO: when is this already set?
   if (source._effectiveType !== undefined)
     setLink( target, '_effectiveType', source._effectiveType );
 }

package/lib/compiler/resolve.js

@@ -62,6 +62,8 @@ const {
   targetMaxNotOne,
   traverseQueryPost,
   linkToOrigin,
+  compositionTextVariant,
+  targetCantBeAspect,
 } = require('./utils');
 
 const detectCycles = require('./cycle-detector');
@@ -383,17 +385,31 @@ function resolve( model ) {
       }
     }
 
-    if (art.targetAspect && !(allowedInMain && isTopLevelElement)) {
-      message( 'type-managed-composition', [ art.targetAspect.location, art ],
-               { '#': allowedInMain ? 'sub' : 'std' } );
-    }
+    if (art.targetAspect && targetCantBeAspect( art, true )) {
+      // If not for anonymous aspect, this message can only occur for CSN input →
+      // we are more CSN specific (we could add more text variants, but this is
+      // CSN input with an undocumented CSN property…) For an anonymous target
+      // aspect, we could have more text variants, though…
+      const msg = art.targetAspect.elements
+        ? 'anonymous'
+        : (art.target || !art._parent?.query && art._parent?.kind !== 'event') && 'std';
+      error( 'type-unexpected-target-aspect', [ art.targetAspect.location, art ],
+             { '#': msg || 'target', prop: 'targetAspect', otherprop: 'target' },
+             {
+               std: 'Unexpected property $(PROP)',
+               anonymous: 'Unexpected anonymous target aspect',
+               target: 'Unexpected property $(PROP), adding property $(OTHERPROP) might help',
+             } );
+    } // TODO: else resolvePath() + test for cds.Composition?
+
     if (art.includes && !allowedInMain) {
+      // TODO: make this a check function for shared.js / or make it part of extend.js
       for (const include of art.includes) {
         const struct = include._artifact;
         if (struct && struct.kind !== 'type' && struct.elements &&
             Object.values( struct.elements ).some( e => e.targetAspect )) {
-          message( 'type-managed-composition', [ include.location, art ],
-                   { '#': struct.kind, art: struct } );
+          error( 'type-managed-composition', [ include.location, art ],
+                 { '#': struct.kind, art: struct } );
         }
       }
     }
@@ -425,16 +441,15 @@ function resolve( model ) {
       const elemtype = obj.type._artifact;
       if (elemtype && effectiveType( elemtype )) {
         const assocType = getAssocSpec( elemtype ) || {};
-        if (assocType.on && !obj.on)
+        if ((assocType.on || assocType.$assocFilter) && !obj.on)
           obj.on = { $inferred: 'rewrite' }; // TODO: no extra rewrite here
         if (assocType.targetAspect) {
           error( 'composition-as-type-of', [ obj.type.location, art ], {},
                  'A managed aspect composition element can\'t be used as type' );
           return;
         }
-        else if (assocType.on) {
-          error( 'assoc-as-type-of', [ obj.type.location, art ], {},
-                 'An unmanaged association can\'t be used as type' );
+        else if (assocType.on || assocType.$assocFilter) {
+          error( 'type-unexpected-assoc', [ obj.type.location, art ] );
           return;
         }
 
@@ -505,6 +520,7 @@ function resolve( model ) {
         checkStructureCast( art );
     }
 
+    resolveExprInAnnotations( art );
     forEachMember( art, resolveRefs, art.targetAspect );
     // After the resolving of foreign keys (and adding implicit ones):
     if (obj.target?.$inferred === '')
@@ -831,10 +847,12 @@ function resolve( model ) {
   function getAssocSpec( type ) {
     let unmanaged = null;
     while (type) {
-      if (type.on)              // if unmanaged, continue trying to find targetAspect
+      if (type.on)            // if unmanaged, continue trying to find targetAspect
         unmanaged = type;
       else if (type.foreignKeys || type.targetAspect)
         return type;
+      else if (type.value?.path?.[type.value.path.length - 1]?.where)
+        return { $assocFilter: true }; // filter -> always unmanaged
       type = getOrigin( type );
     }
     return unmanaged;
@@ -953,10 +971,8 @@ function resolve( model ) {
         // TODO: test of .items a bit unclear - we should somehow restrict the
         // use of unmanaged assocs in MANY, at least with $self
         // TODO: $self usage in anonymous aspects to be corrected in Core Compiler
-        const isComposition = obj.type && obj.type.path && obj.type.path[0] &&
-                              obj.type.path[0].id === 'cds.Composition';
         message( 'assoc-as-type', [ obj.on.location, art ],
-                 { '#': isComposition ? 'comp' : 'std' }, {
+                 { '#': compositionTextVariant( obj, 'comp' ) }, {
                    std: 'An unmanaged association can\'t be defined as type',
                    comp: 'An unmanaged composition can\'t be defined as type',
                  } );
@@ -1073,9 +1089,9 @@ function resolve( model ) {
     obj.foreignKeys = Object.create( null );
     forEachInOrder( target, 'elements', ( elem, name ) => {
       if (elem.key && elem.key.val) {
-        const { location } = obj.target;
+        const location = weakLocation( obj.target.location );
         const key = {
-          name: { location, id: elem.name.id, $inferred: 'keys' }, // more by setMemberParent()
+          name: { location, id: elem.name.id, $inferred: 'keys' },
           kind: 'key',
           targetElement: { path: [ { id: elem.name.id, location } ], location },
           location,
@@ -1086,7 +1102,9 @@ function resolve( model ) {
         // the following should be done automatically, since we run resolveRefs after that
         setArtifactLink( key.targetElement, elem );
         setArtifactLink( key.targetElement.path[0], elem );
-        setLink( key, '_effectiveType', effectiveType( elem ) );
+        // _origin/_effectiveType like we do in effectiveType() → … getOriginRaw():
+        setLink( key, '_origin', '' );
+        setLink( key, '_effectiveType', key );
         dependsOn( key, elem, location );
         // TODO TMP: instead, make managed composition of aspects and unmanaged
         // assocs not depend on their `on` condition (empty `_deps` after resolve)
@@ -1328,7 +1346,24 @@ function resolve( model ) {
       resolveTypeArgumentsUnchecked( art, typeArt, user );
   }
 
+  function resolveExprInAnnotations( art ) {
+    for (const anno in art) {
+      if (anno.charAt(0) === '@')
+        resolveAnnoExpr( art[anno], art );
+    }
+  }
+
+  function resolveAnnoExpr( expr, art ) {
+    if (expr.$tokenTexts)
+      resolveExpr( expr, 'annotation', art );
+    else if (expr.literal === 'array')
+      expr.val.forEach( val => resolveAnnoExpr( val, art ) );
+    else if (expr.literal === 'struct')
+      Object.values( expr.struct ).forEach( val => resolveAnnoExpr( val, art ) );
+  }
+
   function resolveExpr( expr, exprCtx, user ) {
+    // console.log(expr?.location.line,exprCtx)
     traverseExpr( expr, exprCtx, user, (e, c, u) => resolveExprItem( e, c, u ) );
   }
 

package/lib/compiler/shared.js

@@ -13,7 +13,7 @@ const {
   pathName,
   userQuery,
   definedViaCdl,
-  isDirectComposition,
+  targetCantBeAspect,
   pathStartsWithSelf,
   columnRefStartsWithSelf,
   isAssocToPrimaryKeys,
@@ -275,6 +275,28 @@ function fns( model ) {
       check: checkRefInQuery,
       param: paramSemantics,
     },
+    annotation: { // annotation assignments
+      lexical: justDollarSelf,  // TODO: forbid $projection
+      dollar: true,
+      dynamic: parentElements,
+      navigation: assocOnNavigation,
+      noDep: true,
+      notFound: undefinedParentElement,
+      messageMap: {
+        'ref-undefined-element': 'anno-undefined-element',
+        'ref-undefined-param': 'anno-undefined-param',
+      },
+      // check: checkAssocOn,
+      param: paramSemantics,
+      nestedColumn: () => ({       // in expand and inline - TODO
+        lexical: justDollarSelf,
+        dollar: true,
+        dynamic: parentElements,
+        navigation: assocOnNavigation,
+        notFound: undefinedParentElement,
+        rewriteProjectionToSelf: true,
+      }),
+    },
   };
 
   Object.assign( model.$functions, {
@@ -482,7 +504,7 @@ function fns( model ) {
     if (user._pathHead && !semantics.isMainRef) // in expand/inline
       semantics = semantics.nestedColumn();
     if (typeof scope === 'string') { // typeOf, param, global
-      semantics = semantics?.[scope] && semantics[scope]( ruser, path, location );
+      semantics = semantics?.[scope] && semantics[scope]( ruser, path, location, semantics );
       if (!semantics) {
         if (semantics == null)
           throw new CompilerAssertion( `Scope ${ scope } is not expected here` );
@@ -524,7 +546,7 @@ function fns( model ) {
       valid.push( model.$magicVariables.elements, removeDollarNames( dynamicDict ) );
     // TODO: streamline function arguments (probably: user, path, semantics )
     const undef = semantics.notFound( ruser, head, valid, dynamicDict,
-                                      !isMainRef && user._user && user._artifact, path );
+                                      !isMainRef && user._user && user._artifact, path, semantics );
     return setArtifactLink( head, undef || null );
   }
 
@@ -572,7 +594,7 @@ function fns( model ) {
         // TODO: streamline function arguments (probably: user, path, semantics, prev )
         // false returned by semantics.navigation: no further error:
         if (env !== false)
-          notFound( user, item, [ env ], null, prev, path );
+          notFound( user, item, [ env ], null, prev, path, semantics );
         return null;
       }
       // need to do that here, because we also need to disallow Service.AutoExposed:elem
@@ -699,9 +721,14 @@ function fns( model ) {
     return false;
   }
 
-  function paramSemantics() {
-    return { dynamic: artifactParams, notFound: undefinedParam };
+  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?
@@ -754,9 +781,17 @@ function fns( model ) {
   }
 
   function artifactParams( user ) {
-    const lexical = (user._main || user).$tableAliases;
     // TODO: already report error here if no parameters?
-    return lexical?.$parameters?.elements || Object.create( null );
+    return boundActionOrMain( user ).params || Object.create( null );
+  }
+
+  function boundActionOrMain( art ) {
+    while (art._main) {
+      if (art.kind === 'action' || art.kind === 'function')
+        return art;
+      art = art._parent;
+    }
+    return art;
   }
 
   function typeOfParentDict( user ) {
@@ -902,15 +937,16 @@ function fns( model ) {
   function undefinedForAnnotate( user, item, valid, _dict, prev ) {
     // in a CSN source, only one env was tested (valid.length 1):
     const art = (!prev) ? item.id : searchName( prev, item.id, 'absolute' );
-    signalNotFound( (valid.length > 1 ? 'anno-undefined-art' : 'anno-undefined-def'),
+    signalNotFound( (valid.length > 1 ? 'ext-undefined-art' : 'ext-undefined-def'),
                     // TODO: ext-undefined-xyz
                     [ item.location, user ], valid, { art } );
   }
 
-  function undefinedParam( user, head, valid ) {
-    // TODO: text variant if there are no parameters, or in artifactParameters()?
+  function undefinedParam( user, head, valid, _dict, _art, _path, semantics ) {
+    // TODO: text variant if there are no parameters, or in artifactParameters()
+    // TODO: use prepared message variants
     signalNotFound( 'ref-undefined-param', [ head.location, user ], valid,
-                    { art: user._main || user, id: head.id } );
+                    { art: boundActionOrMain( user ), id: head.id }, semantics );
   }
 
   function undefinedTargetElement( user, head, valid, _dict, pathItemArtifact ) {
@@ -953,7 +989,7 @@ function fns( model ) {
     }
   }
 
-  function undefinedParentElement( user, head, valid, dynamicDict ) {
+  function undefinedParentElement( user, head, valid, dynamicDict, _art, _path, semantics ) {
     // TODO: we might mention both the "direct" and the "effective" type and
     // always just mentioned one identifier as not found
     const { id } = head;
@@ -969,7 +1005,7 @@ function fns( model ) {
       const msgVar = userQuery( user ) ? 'query' : null;
       // TODO: better with ON in expand if that is supported
       signalNotFound( 'ref-undefined-element', [ head.location, user ], valid,
-                      { '#': msgVar, art: head.id } );
+                      { '#': msgVar, art: head.id }, semantics );
     }
   }
 
@@ -994,18 +1030,21 @@ function fns( model ) {
     return undefinedItemElement( user, head, valid, null, art, path );
   }
 
-  function undefinedItemElement( user, item, valid, _dict, art, path ) {
+  function undefinedItemElement( user, item, valid, _dict, art, path, semantics ) {
     const query = userQuery( art );
     if (query?.name?.id > 1) {
-      // TODO: 'The current query has no element $(MEMBER)' with $self.MEMBER
-      // and 'The sub query for alias $(ALIAS) has no element $(MEMBER)'
-      // both as text variants to ref-undefined-element
-      signalNotFound( 'query-undefined-element', [ item.location, user ],
-                      valid, { id: item.id } );
+      const root = userQuery( user ) !== query && path[0]._navigation;
+      const alias = (root?.kind === '$navElement')
+        ? root._parent
+        : root?.kind === '$tableAlias' && root;
+      // TODO: improve alias retrieval if inside expand/inline
+      signalNotFound( 'ref-undefined-element', [ item.location, user ], valid,
+                      { '#': (alias ? 'alias' : 'query'), art: item.id, alias: alias?.name?.id },
+                      semantics );
     }
     else if (art.kind === '$parameters') {
       signalNotFound( 'ref-undefined-param', [ item.location, user ],
-                      valid, { art: art._main, id: item.id } );
+                      valid, { art: art._main, id: item.id }, semantics );
     }
     else if (art.kind === 'builtin') { // magic variable / replacement variable
       // $magic.{ var } is a configurable error,
@@ -1015,27 +1054,24 @@ function fns( model ) {
       // eslint-disable-next-line no-cond-assign
       while ((head = head?._parent) && head.kind === 'builtin')
         id = `${ head.name.id }.${ id }`;
-      signalNotFound( ( art.$uncheckedElements ? 'ref-unknown-var' : 'ref-undefined-var'),
-                      [ item.location, user ], valid, { id } );
+      const msgId = (art.$uncheckedElements) ? 'ref-unknown-var' : 'ref-undefined-var';
+      signalNotFound( msgId, [ item.location, user ], valid, { id }, semantics );
     }
-    else if (art.kind === 'aspect' && !art.name) { // anonymous target aspect
-      signalNotFound( 'ref-undefined-element', [ item.location, user ],
-                      valid, { '#': 'aspect', id: item.id } );
+    else if (art.kind === 'aspect' && !art.name) { // anonymous target aspect - TODO: still?
+      signalNotFound( 'ref-undefined-element', [ item.location, user ], valid,
+                      { '#': 'aspect', id: item.id }, semantics );
     }
     else {
       const target = art._effectiveType?.target;
       if (target?._artifact) {
         signalNotFound( 'ref-undefined-element', [ item.location, user ], valid,
-                        { '#': 'target', art: target, id: item.id } );
+                        { '#': 'target', art: target, id: item.id }, semantics );
       }
       else if (!target) {
         const variant = art.kind === 'aspect' && !art.name && 'aspect';
-        signalNotFound( 'ref-undefined-element', [ item.location, user ],
-                        valid, {
-                          '#': variant,
-                          art: (variant ? '' : searchName( art, item.id, 'element' )),
-                          id: item.id,
-                        } );
+        const a = (variant) ? '' : searchName( art, item.id, 'element' );
+        signalNotFound( 'ref-undefined-element', [ item.location, user ], valid,
+                        { '#': variant, art: a, id: item.id }, semantics );
       }
     }
     return null;
@@ -1189,15 +1225,15 @@ function fns( model ) {
     return false;
   }
 
-  // Remember: an aspect should have already been moved to XSN targetAspect, but
+  // Remember: a valid aspect should have already been moved to XSN targetAspect, but
   // the error messages should still talk about potential aspects
   function acceptEntity( art, user, ref ) { // for target
     if (art.kind === 'entity')
       return art;
     // Extra msg text with Composition of NeitherEntityNorAspect:
     const bare = !art.elements || art.elements[$inferred];
-    const std = (art.targetAspect || !isDirectComposition( user ) || user.kind === 'mixin');
-    const msg = std && 'std' || (bare && art.kind === 'aspect' ? 'bare' : 'composition');
+    const std = targetCantBeAspect( user );
+    const msg = std || (bare && art.kind === 'aspect' ? 'bare' : 'composition');
     signalNotFound( 'ref-invalid-target', [ ref.location, user ], null,
                     { '#': msg } );
     return false;
@@ -1558,12 +1594,12 @@ function fns( model ) {
    * @param {object[]} valid
    * @param  {object} [textParams]
    */
-  function signalNotFound( msgId, location, valid, textParams ) {
+  function signalNotFound( msgId, location, valid, textParams, semantics ) {
     if (location.$notFound)     // TODO: still necessary?
       return;
     location.$notFound = true;
     /** @type {object} */
-    const err = message( msgId, location, textParams );
+    const err = message( semantics?.messageMap?.[msgId] || msgId, location, textParams );
     if (valid) {
       const user = Array.isArray( location ) && location[1];
       err.validNames = (user && definedViaCdl( user )); // viaCdl -> '.'?