@sap/cds-compiler 4.2.4 → 4.3.2

package/lib/compiler/checks.js

@@ -10,16 +10,13 @@
 
 'use strict';
 
-const builtins = require('../compiler/builtins');
 const {
   forEachGeneric,
   forEachDefinition,
   forEachMember,
   forEachMemberRecursively,
-  isBetaEnabled,
 } = require('../base/model');
 const { CompilerAssertion } = require('../base/error');
-const { pathName } = require('./utils');
 const { typeParameters } = require('./builtins');
 
 const $location = Symbol.for( 'cds.$location' );
@@ -94,8 +91,8 @@ function check( model ) {
     const isKey = parentProps.key?.val || elem.key?.val;
     const isVirtual = parentProps.virtual?.val || elem.virtual?.val;
     if (isKey && isVirtual) {
-      error( 'def-unexpected-key', [ isKey.location, elem ],
-             { '#': 'virtual', art: elem.name.element, prop: 'key' } );
+      error( 'def-unexpected-key', [ (parentProps.key || elem.key).location, elem ],
+             { '#': 'virtual', prop: 'key' } );
     }
   }
 
@@ -116,7 +113,7 @@ function check( model ) {
 
 
   function checkName( construct ) { // TODO: move to define.js
-    if (model.options.$skipNameCheck)
+    if (model.options.$skipNameCheck || !construct._main)
       return;
     // TODO: Move a corrected version of this check to definer (but do not rely on it!):
     //       The code below misses to consider CSN input!
@@ -463,15 +460,7 @@ function check( model ) {
       }
     }
     if (elem.default) {
-      if (!isBetaEnabled( model.options, 'associationDefault' )) {
-        error( 'type-unsupported-default', [ elem.default.location, elem ], {
-          '#': isComposition( model, elem ) ? 'comp' : 'std',
-        }, {
-          std: 'Unsupported default value on an association',
-          comp: 'Unsupported default value on a composition',
-        } );
-      }
-      else if (elem.targetAspect || elem.on || fkCount !== 1) {
+      if (elem.targetAspect || elem.on || fkCount !== 1) {
         const variant = (elem.targetAspect && 'targetAspect') || (elem.on && 'onCond') || 'multi';
         error( 'type-unexpected-default', [ elem.default.location, elem ], {
           '#': variant, keyword: 'default', count: fkCount,
@@ -628,10 +617,9 @@ function check( model ) {
 
   function checkSelectItemValue( elem ) {
     checkExpressionAssociationUsage( elem.value, elem, false );
-    // If a direct SQL-style cast() has no type, but type props, the compiler does not copy the type
-    // props/does not use the cast().  To avoid duplicate messages, only run this check if there is
-    // no explicit type, as otherwise we will check the cast() twice (once here, once via element).
-    if (elem.value?.op?.val === 'cast' && !elem.type) {
+    // To avoid duplicate messages, only run this check if the type wasn't inferred from
+    // the cast, as otherwise we will check it twice (once here, once via element).
+    if (elem.value?.op?.val === 'cast' && elem.type?.$inferred !== 'cast') {
       requireExplicitTypeInSqlCast( elem.value, elem );
       checkTypeArguments( elem.value, elem );
     }
@@ -813,18 +801,24 @@ function check( model ) {
   // definitions from 'model'. Report errors on 'options.messages.
   //
   // TODO: rework completely!
+  // TODO: if we have such a check, consider #variant, anno.@anno, anno@anno
 
   // Has been slightly adapted for model.vocabularies but comments need to be
   // adapted, etc.
   function checkAnnotationAssignment1( art, anno ) {
     // Sanity checks (ignore broken assignments)
-    if (!anno.name?.path?.length)
+    if (!anno.name?.id)
       return;
+    // Just a little workaround to adapt to changed `name`s, not nice coding:
+    const hashIndex = anno.name.id.indexOf( '#' );
+    const path = (hashIndex > 0 ? anno.name.id.substring( 0, hashIndex ) : anno.name.id)
+      .split( '.' ).map( id => ({ id }) );
+
     // Annotation artifact for longest path step of annotation path
     let fromArtifact = null;
     let pathStepsFound = 0;
-    for (let i = anno.name.path.length; i > 0; i--) {
-      const absoluteName = anno.name.path.slice( 0, i ).map( path => path.id ).join( '.' );
+    for (let i = path.length; i > 0; i--) {
+      const absoluteName = path.slice( 0, i ).map( p => p.id ).join( '.' );
       if (model.vocabularies[absoluteName]) {
         fromArtifact = model.vocabularies[absoluteName];
         pathStepsFound = i;
@@ -837,7 +831,7 @@ function check( model ) {
       return;
     }
 
-    const { artifact, endOfPath } = resolvePathFrom( anno.name.path.slice( pathStepsFound ),
+    const { artifact, endOfPath } = resolvePathFrom( path.slice( pathStepsFound ),
                                                      fromArtifact );
 
     // Check what we actually want to check
@@ -859,7 +853,7 @@ function check( model ) {
     // Element must exist in annotation
     if (!elementDecl) {
       warning( null, [ anno.location || anno.name.location, art ],
-               { name: pathName( anno.name.path ), anno: annoDecl.name.absolute },
+               { name: anno.name.id, anno: annoDecl.name.id },
                'Element $(NAME) not found for annotation $(ANNO)' );
       return;
     }
@@ -870,14 +864,14 @@ function check( model ) {
 
 
     // Must have literal or path unless it is a boolean
-    if (!anno.literal && !anno.path && getFinalTypeNameOf( elementDecl ) !== 'cds.Boolean') {
-      if (elementDecl.type?._artifact.name.absolute) {
+    if (!anno.literal && !anno.path && elementDecl._effectiveType?.category !== 'boolean') {
+      if (elementDecl.type?._artifact) {
         warning( 'anno-expecting-value', [ anno.location || anno.name.location, art ],
                  { '#': 'type', type: elementDecl.type._artifact } );
       }
       else {
         warning( 'anno-expecting-value', [ anno.location || anno.name.location, art ],
-                 { '#': 'std', anno: anno.name.absolute } );
+                 { '#': 'std', anno: anno.name.id } );
       }
 
       return;
@@ -896,7 +890,7 @@ function check( model ) {
     if (value.path)
       return;
 
-    const anno = annoDef.name.absolute;
+    const anno = annoDef.name.id;
     const loc = [ value.location || value.name.location, art ];
 
     // Array expected?
@@ -925,47 +919,51 @@ function check( model ) {
 
     // Handle each (primitive) expected element type separately
     // TODO: Don't rely on name; use actual type
-    const type = getFinalTypeNameOf( elementDecl );
-    if (builtins.isStringTypeName( type )) {
+    const type = elementDecl._effectiveType;
+    if (!type)
+      return;
+    if (type.category === 'string') {
       if (value.literal !== 'string' && value.literal !== 'enum' &&
           !elementDecl._effectiveType.enum) {
         warning( null, loc, { type, anno },
                  'A string value is required for type $(TYPE) for annotation $(ANNO)' );
       }
     }
-    else if (builtins.isBinaryTypeName( type )) {
+    else if (type.category === 'binary') {
       if (value.literal !== 'string' && value.literal !== 'x') {
         warning( null, loc, { type, anno },
                  'A hexadecimal string value is required for type $(TYPE) for annotation $(ANNO)' );
       }
     }
-    else if (builtins.isNumericTypeName( type )) {
+    else if (type.category === 'decimal' || type.category === 'integer') {
       if (value.literal !== 'number' && value.literal !== 'enum' &&
           !elementDecl._effectiveType.enum) {
         warning( null, loc, { type, anno },
                  'A numerical value is required for type $(TYPE) for annotation $(ANNO)' );
       }
     }
-    else if (builtins.isDateOrTimeTypeName( type )) {
+    else if (type.category === 'dateTime') {
       if (value.literal !== 'date' && value.literal !== 'time' &&
           value.literal !== 'timestamp' && value.literal !== 'string') {
+        // Hm, actually date and time cannot be mixed
         warning( null, loc, { type, anno },
           // eslint-disable-next-line max-len
                  'A date/time value or a string is required for type $(TYPE) for annotation $(ANNO)' );
       }
     }
-    else if (builtins.isBooleanTypeName( type )) {
+    else if (type.category === 'boolean') {
       if (value.literal && value.literal !== 'boolean') {
         warning( null, loc, { type, anno },
                  'A boolean value is required for type $(TYPE) for annotation $(ANNO)' );
       }
     }
-    else if (builtins.isRelationTypeName( type ) || builtins.isGeoTypeName( type )) {
-      warning( null, loc, { type, anno },
+    else if (type.target || type.category === 'geo') {
+      warning( null, loc, { type: (type.target ? 'cds.Association' : type), anno },
                'Type $(TYPE) can\'t be assigned a value for annotation $(ANNO)' );
+      // TODO: complain at definition instead
     }
-    else if (!elementDecl._effectiveType.enum) {
-      throw new CompilerAssertion(`Unknown primitive type name: ${ type }`);
+    else if (!type.enum) {
+      throw new CompilerAssertion(`Unknown primitive type name: ${ type.name.id }`);
     }
 
     // Check enums
@@ -1027,17 +1025,6 @@ function check( model ) {
           from._effectiveType?.elements || [];
     return resolvePathFrom( path.slice(1), nextStepEnv[path[0].id], result );
   }
-
-  // TODO: remove
-  // Return the absolute name of the final type of 'node'. May return 'undefined'
-  // for anonymous types.  DO NOT USE THIS function, it has several assumptions
-  // which are not necessarily true.
-  function getFinalTypeNameOf( node ) {
-    let type = node._effectiveType;
-    if (type.type)
-      type = type.type._artifact;
-    return type?.name?.absolute;
-  }
 }
 
 /**

package/lib/compiler/define.js

@@ -124,6 +124,7 @@ const {
   forEachInOrder,
   forEachMember,
 } = require('../base/model');
+const { weakLocation } = require('../base/location');
 const shuffleGen = require('../base/shuffle');
 const {
   dictAdd, dictAddArray, dictForEach, pushToDict,
@@ -135,7 +136,6 @@ const {
   storeExtension,
   dependsOnSilent,
   pathName,
-  splitIntoPath,
   isDirectComposition,
 } = require('./utils');
 const { compareLayer } = require('./moduleLayers');
@@ -226,8 +226,12 @@ function define( model ) {
     if (!src.kind)
       src.kind = 'source';
 
-    let namespace = src.namespace && src.namespace.path;
-    let prefix = namespace ? `${ pathName( namespace ) }.` : '';
+    let { namespace } = src;
+    let prefix = '';
+    if (namespace?.path && !namespace.path.broken) {
+      namespace.id = pathName( namespace.path );
+      prefix = `${ namespace.id }.`;
+    }
     if (isInReservedNamespace( prefix )) {
       error( 'reserved-namespace-cds', [ src.namespace.location, src.namespace ], { name: 'cds' },
              'The namespace $(NAME) is reserved for CDS builtins' );
@@ -240,12 +244,12 @@ function define( model ) {
         src.artifacts = shuffleDict( src.artifacts );
         addPathPrefixes( src.artifacts, prefix ); // before addUsing
       }
-      else if (src.usings || src.namespace) {
+      else if (src.usings || namespace) {
         src.artifacts = Object.create( null );
       }
       if (src.usings)
         shuffleArray( src.usings ).forEach( u => addUsing( u, src ) );
-      if (namespace)
+      if (namespace?.id)        // successfully set a full name for namespace
         addNamespace( namespace, src );
       if (src.artifacts) {      // addArtifact needs usings for context extensions
         src.artifacts = shuffleDict( src.artifacts );
@@ -253,7 +257,7 @@ function define( model ) {
       }
     }
     else if (src.definitions) {      // CSN input
-      prefix = '';
+      prefix = '';                   // also for addVocabulary() below
       dictForEach( shuffleDict( src.definitions ), def => addDefinition( def, src, prefix ) );
     }
     if (src.vocabularies) {
@@ -267,11 +271,8 @@ function define( model ) {
   }
 
   function addDefinition( art, block, prefix ) {
-    if (!art.name.absolute) {
-      // TODO: art.name.absolute = art.name.id || …
-      art.name.absolute = (!art.name.path) ? art.name.id : prefix + pathName( art.name.path );
-    }
-    const { absolute } = art.name;
+    art.name.id ??= prefix + pathName( art.name.path );
+    const absolute = art.name.id;
     // TODO: check reserved, see checkName()/checkLocalizedObjects() of checks.js
     if (absolute === 'cds' || isInReservedNamespace( absolute )) {
       error( 'reserved-namespace-cds', [ art.name.location, art ], { name: 'cds' },
@@ -299,24 +300,21 @@ function define( model ) {
     for (const name in artifacts) {
       const d = artifacts[name];
       const a = Array.isArray( d ) ? d[0] : d;
-      if (!a.name.absolute)
-        a.name.absolute = prefix + name;
+      a.name.id ??= prefix + pathName( a.name.path );
       const index = name.indexOf( '.' );
       if (index < 0)
         continue; // also for newly added (i.e. does not matter whether visited or not)
-      const id = name.substring( 0, index );
-      if (artifacts[id])
+      const using = name.substring( 0, index );
+      if (artifacts[using])
         continue;
       // TODO: enable optional locations
       const location = a.name.path && a.name.path[0].location || a.location;
-      const absolute = prefix + id;
-      artifacts[id] = {
+      const absolute = prefix + using;
+      artifacts[using] = {
         kind: 'using',          // !, not namespace - we do not know artifact yet
-        name: {
-          id, absolute, location, $inferred: 'as',
-        },
+        name: { id: using, location, $inferred: 'as' },
         // TODO: use global ref (in general - all uses of splitIntoPath)
-        extern: { path: splitIntoPath( location, absolute ), location },
+        extern: { location, id: absolute },
         location,
         $inferred: 'path-prefix',
       };
@@ -342,37 +340,33 @@ function define( model ) {
     const { path } = decl.extern;
     if (path.broken || !path[0]) // syntax error
       return;
+    decl.extern.id = pathName( path );
     if (!decl.name)
       decl.name = { ...path[path.length - 1], $inferred: 'as' };
-    decl.name.absolute = pathName( path );
     const name = decl.name.id;
     // TODO: check name: no "."
     const found = src.artifacts[name];
-    if (found && found.$inferred === 'path-prefix' &&
-        found.name.absolute === decl.name.absolute)
+    // a real `using` declaration is “nicer” than a compiler-generated one:
+    if (found && found.$inferred === 'path-prefix' && found.extern.id === decl.extern.id)
       src.artifacts[name] = decl;
     else
       dictAddArray( src.artifacts, name, decl );
   }
 
   // must be called after addUsing().
-  function addNamespace( path, src ) {
-    const absolute = pathName( path );
-    if (path.broken) // parsing may have failed
-      return;
+  function addNamespace( namespace, src ) {
     // create using for own namespace:
-    const last = path[path.length - 1];
+    // TODO: should we really do that in v5? See also initNamespaceAndUsing().
+    const last = namespace.path[namespace.path.length - 1];
     const { id } = last;
     if (src.artifacts[id] || last.id.includes( '.' ))
       // not used as we have a definition/using with that name, or dotted last path id
       return;
     src.artifacts[id] = {
       kind: 'using',
-      name: {
-        id, absolute, location: last.location, $inferred: 'as',
-      },
-      extern: src.namespace,
-      location: src.namespace.location,
+      name: { id, location: last.location, $inferred: 'as' },
+      extern: namespace,
+      location: namespace.location,
       $inferred: 'namespace',
     };
   }
@@ -381,7 +375,7 @@ function define( model ) {
       return;
     addDefinition( art, block, prefix );
     if (art.artifacts) {
-      const p = `${ art.name.absolute }.`;
+      const p = `${ art.name.id }.`;
       // path prefixes (usings) must be added before extensions in artifacts:
       addPathPrefixes( art.artifacts, p );
       dictForEach( art.artifacts, a => addArtifact( a, art, p ) );
@@ -397,12 +391,12 @@ function define( model ) {
     if (!absolute)                    // broken path
       return;
     delete ext.name.path[0]._artifact; // might point to wrong JS object in phase 1
-    ext.name.absolute = absolute; // definition might not be there yet, no _artifact link
+    ext.name.id = absolute; // definition might not be there yet, no _artifact link
     const location = { file: '' }; // stupid required location
     const late = model.$collectedExtensions[absolute] ||
           (model.$collectedExtensions[absolute] = {
             kind: 'annotate',
-            name: { absolute, location },
+            name: { id: absolute, location },
             $inferred: '',
             location,
           });
@@ -415,7 +409,7 @@ function define( model ) {
       model.$blocks = Object.create( null );
     // Set block number for debugging (--raw-output):
     // eslint-disable-next-line no-multi-assign
-    ext.name.select = model.$blocks[absolute] = (model.$blocks[absolute] || 0) + 1;
+    ext.$effectiveSeqNo = model.$blocks[absolute] = (model.$blocks[absolute] || 0) + 1;
     // add "namespace" for the case that ext.artifacts is empty (TODO: later)
     // now add all definitions in ext.artifacts:
     const prefix = `${ absolute }.`;
@@ -449,13 +443,8 @@ function define( model ) {
   function addVocabulary( vocab, block, prefix ) {
     setLink( vocab, '_block', block );
     const { name } = vocab;
-    if (!name.absolute) {
-      // TODO: art.name.absolute = vocab.name.id || …
-      vocab.name.absolute = (!vocab.name.path)
-        ? vocab.name.id
-        : prefix + pathName( vocab.name.path );
-    }
-    dictAdd( model.vocabularies, name.absolute, vocab );
+    name.id ??= prefix + pathName( name.path );
+    dictAdd( model.vocabularies, name.id, vocab );
   }
 
   /**
@@ -509,7 +498,8 @@ function define( model ) {
 
   // TODO: message ids
   function checkRedefinition( art ) {
-    if (!art.$duplicates || art.$errorReported === 'syntax-duplicate-extend' ||
+    if (!art.$duplicates || !art.name.id ||
+        art.$errorReported === 'syntax-duplicate-extend' ||
         art.$errorReported === 'syntax-duplicate-annotate')
       return;
     if (art._main) {
@@ -522,7 +512,7 @@ function define( model ) {
       // TODO: better messages with definitions with the same name as builtin,
       // especially if there is just one
       error( 'duplicate-definition', [ art.name.location, art ], {
-        name: art.name.absolute,
+        name: art.name.id,
         '#': (art.kind === 'annotation' ? 'annotation' : 'absolute' ),
       } );
     }
@@ -533,24 +523,20 @@ function define( model ) {
       return;
     if (src.namespace) {
       const decl = src.namespace;
-      const { path } = decl;
-      if (path.broken) // parsing may have failed
+      if (!decl.id)             // parsing may have failed
         return;
-      const { id } = path[path.length - 1];
-      const absolute = pathName( path );
-      if (!model.definitions[absolute]) {
-        // TODO: do we really need this namespace entry - try without (msg change)
-        const location = path.location || decl.location;
+      if (!model.definitions[decl.id]) {
         // TODO: make it possible to have no location
-        const ns = { kind: 'namespace', name: { absolute, location }, location };
-        model.definitions[absolute] = ns;
+        const ns = { kind: 'namespace', name: decl, location: decl.location };
+        model.definitions[decl.id] = ns;
         initArtifactParentLink( ns, model.definitions );
       }
-      const builtin = model.$builtins[id];
+      const last = decl.path[decl.path.length - 1];
+      const builtin = model.$builtins[last.id];
       if (builtin && !builtin.internal &&
-          src.artifacts[id] && src.artifacts[id].extern === decl) {
+          src.artifacts[last.id] && src.artifacts[last.id].extern === decl) {
         warning( 'ref-shadowed-builtin', [ decl.location, null ], // no home artifact
-                 { id, art: absolute, code: `using ${ builtin.name.absolute };` },
+                 { id: last.id, art: decl.id, code: `using ${ builtin.name.id };` },
                  '$(ID) now refers to $(ART) - consider $(CODE)' );
       }
       // setArtifactLink( decl, model.definitions[absolute] ); // TODO: necessary?
@@ -602,53 +588,51 @@ function define( model ) {
     initMembers( art, art, block );
   }
 
-  function initArtifactParentLink( art, definitions ) {
+  function initArtifactParentLink( art, definitions, path, pathIndex ) {
     setLink( art, '_parent', null );
-    const { absolute } = art.name;
-    const dot = absolute.lastIndexOf( '.' );
+    const { id } = art.name;
+    const dot = id.lastIndexOf( '.' );
     if (dot < 0)
       return;
-    art.name.id = absolute.substring( dot + 1 ); // XSN TODO: remove name.id for artifacts
-    const prefix = absolute.substring( 0, dot );
+    const prefix = id.substring( 0, dot );
     let parent = definitions[prefix];
     if (!parent) {
-      const { location } = art.name; // TODO: make it possible to have no location
-      parent = { kind: 'namespace', name: { absolute: prefix, location }, location };
+      path ??= art.name.path;
+      pathIndex ??= path?.length - 1;
+      const pathItemOrName = (path && pathIndex) ? path[--pathIndex] : art.name;
+      const location = weakLocation( pathItemOrName.location );
+      parent = { kind: 'namespace', name: { id: prefix, location }, location };
       definitions[prefix] = parent;
-      initArtifactParentLink( parent, definitions );
+      initArtifactParentLink( parent, definitions, path, pathIndex );
     }
     setLink( art, '_parent', parent );
     if (!parent._subArtifacts)
       setLink( parent, '_subArtifacts', Object.create( null ) );
     if (art.$duplicates !== true) // no redef or "first def"
-      parent._subArtifacts[absolute.substring( dot + 1 )] = art; // not dictAdd()
+      parent._subArtifacts[id.substring( dot + 1 )] = art; // not dictAdd()
   }
 
   // Init special things: -------------------------------------------------------
 
   function initDollarSelf( art ) {
-    const selfname = '$self';
     // TODO: use setMemberParent() ?
-    const name = art.name || art._outer.name;
     const self = {
-      name: { id: selfname, alias: selfname, absolute: name.absolute },
+      name: { id: '$self', location: art.location },
       kind: '$self',
       location: art.location,
     };
-    if (name.element)          // $self for anonymous aspect
-      self.name.element = name.element;
     setLink( self, '_parent', art );
     setLink( self, '_main', art ); // used on main artifact
     setLink( self, '_origin', art );
     art.$tableAliases = Object.create( null );
-    art.$tableAliases[selfname] = self;
+    art.$tableAliases.$self = self;
   }
 
   function initDollarParameters( art ) {
-    // TODO: remove $parameters in v4?
+    // TODO: remove $parameters in v5?
     // TODO: use setMemberParent() ?
     const parameters = {
-      name: { id: '$parameters', param: '$parameters', absolute: art.name.absolute },
+      name: { id: '$parameters' },
       kind: '$parameters',
       location: art.location,
     };
@@ -687,7 +671,7 @@ function define( model ) {
         initMixins( query, art );
       if (!query.$tableAliases.$self) { // same as $projection
         const self = {
-          name: { alias: '$self', query: query.name.select, absolute: art.name.absolute },
+          name: { id: '$self', location: query.location },
           kind: '$self',
           location: query.location,
         };
@@ -727,10 +711,9 @@ function define( model ) {
                (art.kind === '$tableAlias' ? art._parent._$next : art ) );
       setLink( query, '_block', art._block );
       query.kind = 'select';
-      query.name = { location: query.location };
-      setMemberParent( query, main.$queries.length + 1, main );
+      query.name = { location: query.location, id: main.$queries.length + 1 };
+      setMemberParent( query, null, main );
       // console.log(art.kind,art.name,query.name,query._$next.name)
-      // if (query.name.query === 1 && query.name.absolute === 'S') throw new CompilerAssertion();
       main.$queries.push( query );
       setLink( query, '_parent', art ); // _parent should point to alias/main/query
       query.$tableAliases = Object.create( null ); // table aliases and mixin definitions
@@ -794,13 +777,13 @@ function define( model ) {
         } );
       }
       if (table.on) {         // after processing args to get the $tableAliases
-        setMemberParent( table, query.name.select, query ); // sets _parent,_main
+        setMemberParent( table, query.name.id, query ); // sets _parent,_main
         initSubQuery( table );  // init sub queries in ON
         const aliases = Object.keys( table.$tableAliases || {} );
         // Use first tabalias name on the right side of the join to name the
         // (internal) query, should only be relevant for --raw-output, not for
         // user messages or references - TODO: correct if join on left?
-        table.name.param = aliases[1] || aliases[0] || '<unknown>';
+        table.name.id = aliases[1] || aliases[0] || '<unknown>';
         setLink( table, '_user', query ); // TODO: do not set kind/name
         setLink( table, '_$next', query._$next );
         // TODO: probably set this to query if we switch to name restriction in JOIN
@@ -815,6 +798,8 @@ function define( model ) {
       dictAdd( query.$tableAliases, table.name.id, table, ( name, loc, tableAlias ) => {
         if (tableAlias.$inferred === '$internal') {
           const semanticLoc = tableAlias.query?.name ? tableAlias.query : tableAlias;
+          // TODO: the semanticLoc query is not initialized yet, and thus cannot
+          // be used here
           error( 'name-missing-alias', [ tableAlias.location, semanticLoc ],
                  { '#': 'duplicate', code: 'as ‹alias›' } );
         }
@@ -878,7 +863,6 @@ function define( model ) {
       const mixin = query.mixin[name];
       if (!(mixin.$duplicates)) {
         setMemberParent( mixin, name, query );
-        mixin.name.alias = mixin.name.id;
         setLink( mixin, '_block', art._block );
         // TODO: do some initMembers() ?  If people had annotation
         // assignments on the mixin... (also for future mixin definitions
@@ -1121,12 +1105,7 @@ function define( model ) {
       // another entity - might induce auto-redirection):
       if (inEntity && !targetAspect.elements.up_) {
         const up = {
-          name: {
-            id: 'up_',
-            alias: 'up_',
-            element: obj.name.element,
-            absolute: obj.name.absolute,
-          },
+          name: { id: 'up_' },
           kind: '$navElement',
           location: obj.location,
         };
@@ -1200,13 +1179,14 @@ function define( model ) {
     if (boundSelfParamType === true) { // first try
       const def = model.definitions.$self;
       if (def) {
-        // TODO v4: bring this always, probably even as error
+        // TODO v5: bring this always, probably even as error
         warning( 'name-deprecated-for-artifacts', [ def.location, def ], { name: '$self' },
                  'Do not use $(NAME) as name for an artifact definition' );
         boundSelfParamType = false;
         return;
       }
-      boundSelfParamType = { name: { absolute: '$self' } };
+      const location = { file: '' };
+      boundSelfParamType = { name: { id: '$self', location }, location };
     }
     const first = params[Object.keys( params )[0] || ''];
     const type = first?.type || first?.items?.type; // this sequence = no derived type