@sap/cds-compiler 4.0.0 → 4.1.2

package/lib/checks/queryNoDbArtifacts.js

@@ -1,136 +1,196 @@
 'use strict';
 
 const { hasAnnotationValue, isPersistedOnDatabase, isBuiltinType } = require('../model/csnUtils');
+const { requireForeignKeyAccess } = require('./onConditions');
+const { pathId } = require('../model/csnRefs');
+
+const generalQueryProperties = [ 'from', 'columns', 'where', 'groupBy', 'orderBy', 'having', 'limit' ];
+
 /**
- * Make sure that all source artifacts and association targets reach the database
- * (otherwise the view can't be activated), but only if the source artifact is NOT activated against the database // <- what does this mean?
+ * Ensure that all source artifacts and association targets are persisted on the database.
+ * Otherwise, we would end up with a JOIN against a non-existent table.
  *
  * Check the given query for:
- * - Associations-traversal over skipped/abstract things
+ * - Association-traversal over skipped/abstract things
  * - Associations (indirectly) using managed associations without foreign keys
  *
  * Currently checked:
- * - "columns" for something like toF.id, where F is skipped. But publishing toF is fine, will be ignored later on
+ * - "columns" for something like toF.field, where F is skipped. But publishing toF is fine, will be ignored later on
  * - "from" for something like "select from E.toF" where E, F or E AND F are no-db.
  *
- *
  * @param {CSN.Query} query Query to check
  */
 function checkQueryForNoDBArtifacts( query ) {
   if (isPersistedOnDatabase(this.artifact) && !hasAnnotationValue(this.artifact, '@cds.persistence.table')) {
-    const generalQueryProperties = [ 'from', 'columns', 'where', 'groupBy', 'orderBy', 'having', 'limit' ];
     for (const prop of generalQueryProperties) {
       const queryPart = (query.SELECT || query.SET)[prop];
       if (Array.isArray(queryPart)) {
         for (const part of queryPart)
-          checkRef.call(this, part, prop === 'columns');
+          checkQueryRef.call(this, part, prop === 'columns');
       }
       else if (typeof queryPart === 'object') {
-        checkRef.call(this, queryPart, prop === 'columns');
+        checkQueryRef.call(this, queryPart, prop === 'columns');
       }
     }
   }
 }
 
 /**
- * Count the leaf-elements resulting from a given element.
+ * @param {CSN.Element} assoc Definition to check
+ * @returns {boolean} True, if there are any foreign keys.
+ */
+function hasForeignKeys( assoc ) {
+  if (!assoc || !assoc.keys)
+    return false;
+  return _hasForeignKeyOrElements.call(this, assoc);
+}
+
+/**
+ * Returns true if the given definition has at least one foreign key or element leaf node.
  *
- * @param {CSN.Element} def Definition to check
- * @returns {number} Number of leaf elements
+ * @param {CSN.Artifact} def
+ * @returns {boolean} True if there are FKs/element leaves.
  */
-function leafCount( def ) {
-  let c = 0;
-  if (!def)
-    return c;
-  if (def.elements) {
-    c += Object.values(def.elements).reduce((acc, e) => {
-      acc += leafCount.call(this, e);
-      return acc;
-    }, 0);
+function _hasForeignKeyOrElements( def ) {
+  if (!def) {
+    return false;
   }
   else if (def.keys) {
-    c += def.keys.reduce((acc, e) => {
-      acc += leafCount.call(this, e._art);
-      return acc;
-    }, 0);
+    return def.keys.some(e => _hasForeignKeyOrElements.call(this, e._art));
+  }
+  else if (def.elements) {
+    return Object.values(def.elements).some( e => _hasForeignKeyOrElements.call(this, e));
   }
   else if (def.type) {
     if (isBuiltinType(def.type) && !(def.target))
-      return 1;
-    c += leafCount.call(this, this.csn.definitions[def.type]);
+      return true;
+    return _hasForeignKeyOrElements.call(this, this.artifactRef(def.type, null));
   }
-  return c;
+  return false;
 }
 
 /**
- * Check the given ref for usage of skipped/abstract assoc targets
+ * Check the given `obj.ref` for usage of skipped/abstract assoc targets
  *
- * @param {object} obj CSN "thing" to check
+ * @param {CSN.Column} obj CSN "thing" to check
  * @param {boolean} inColumns True if the ref is part of a from
  */
-function checkRef( obj, inColumns ) {
-  if (!(obj && obj.ref) || !obj._links || obj.$scope === 'alias')
+function checkQueryRef( obj, inColumns ) {
+  if (!obj || obj.$scope === 'alias')
     return;
 
-  const links = obj._links;
+  if (obj.expand || obj.inline)
+    _checkExpandInline.call(this, obj);
+
+  else if (obj.ref && obj._links)
+    _checkRef.call(this, obj.ref, obj._links, obj.$path, inColumns);
+}
+
+/**
+ * Run _checkRef on all expand/inline structure leaf nodes.
+ * We do so by creating artificial paths that follow expand/inline nodes to their leaves.
+ *
+ * @param {CSN.Column} obj
+ * @param {CSN.Path} previousRefs
+ * @param {object[]} previousLinks
+ */
+function _checkExpandInline( obj, previousRefs = [], previousLinks = [] ) {
+  if (obj.ref && obj._links) { // There could be anonymous nested "expand".
+    previousRefs = previousRefs.concat(obj.ref);
+    previousLinks = previousLinks.concat(obj._links);
+  }
+
+  if (!obj.expand && !obj.inline) {
+    if (obj.ref && obj._links) {
+      // `inColumns: true` for expand/inline
+      _checkRef.call(this, previousRefs, previousLinks, obj.$path, true);
+    }
+    return;
+  }
+
+  for (const col of obj.expand || obj.inline)
+    _checkExpandInline.call(this, col, previousRefs, previousLinks);
+}
+
+/**
+ * Implementation of checkQueryRef() that works on ref/links arrays instead of a column.
+ *
+ * @param {CSN.Path} ref
+ * @param {object[]} _links
+ * @param {CSN.Path} $path
+ * @param {boolean} inColumns
+ */
+function _checkRef( ref, _links, $path, inColumns ) {
+  if (!ref || !_links )
+    return;
+
+  let nonPersistedTarget = null;
+  const isPublishedAssoc = this.csnUtils.isAssocOrComposition(_links[_links.length - 1].art);
 
   // Don't check the last element - to allow association publishing in columns
-  for (let i = 0; i < (inColumns ? links.length - 1 : links.length); i++) {
-    const link = links[i];
+  for (let i = 0; i < (inColumns ? _links.length - 1 : _links.length); i++) {
+    const link = _links[i];
     if (!link)
       continue;
-
     const { art } = link;
     if (!art)
       continue;
 
-    const endArtifact = art.target ? this.csn.definitions[art.target] : art;
-    const pathStep = obj.ref[i].id ? obj.ref[i].id : obj.ref[i];
-    const name = art.target ? art.target : pathStep;
-    if (!isPersistedOnDatabase(endArtifact)) {
-      const nextElement = obj.ref[i + 1];
-      /**
-       * if we only navigate to foreign keys of the managed association in a view, we do not need to join,
-       * thus we can produce the view even if the target of the association is not persisted
-       *
-       * @param {CSN.Element} assoc association in ref
-       * @param {string} nextStep the ref step following the association
-       * @returns {boolean} true if no join will be generated
-       */
-      const isJoinRelevant = (assoc, nextStep) => {
-        if (!assoc.keys)
-          return true;
-        const isExposedColumnAssocOrComposition = this.csnUtils.isAssocOrComposition(obj._art.type);
-        return !assoc.keys
-          .some(fk => fk.ref[0] === nextStep && !isExposedColumnAssocOrComposition);
-      };
-      if (isJoinRelevant(art, nextElement)) {
-        const cdsPersistenceSkipped = hasAnnotationValue(endArtifact, '@cds.persistence.skip');
-        this.error( null, obj.$path, {
-          id: pathStep, elemref: obj, name, '#': cdsPersistenceSkipped ? 'std' : 'abstract',
+    const isLast = i >= _links.length - 1;
+    const isUnmanagedOrNoKeys = !art.keys;
+    const targetArt = art.target ? this.artifactRef(art.target) : art;
+    const pathStep = pathId(ref[i]);
+    const name = art.target || pathStep;
+
+    // If any path-step is not persisted, then all following path steps must only access foreign keys.
+    // For example, it could be toF.toG.field, where toG is FK of toF; the FK-only-check would succeed,
+    // but we only check "field" in the next iteration, where it is seen as access on a non-skipped
+    // entity, hence the need to store if any target is skipped.
+    if (!isPersistedOnDatabase(targetArt))
+      nonPersistedTarget = { name, pathStep };
+
+    if (nonPersistedTarget) {
+      let isJoinRelevant = isPublishedAssoc || // publishing associations is always join relevant
+        isLast || // e.g. FROM targets are always join relevant.
+        isUnmanagedOrNoKeys; // unmanaged associations are always join relevant -> no FKs
+
+      if (!isJoinRelevant) {
+        // for managed, published associations with more than one $path-step, only FK
+        // access is allowed.
+        requireForeignKeyAccess({ ref, _links }, i, () => {
+          isJoinRelevant = true;
+        });
+      }
+
+      if (isJoinRelevant) {
+        const cdsPersistenceSkipped = hasAnnotationValue(targetArt, '@cds.persistence.skip');
+        this.error( null, $path, {
+          '#': cdsPersistenceSkipped ? 'std' : 'abstract',
+          id: nonPersistedTarget.pathStep,
+          elemref: { ref },
+          name: nonPersistedTarget.name,
         }, {
           std: 'Unexpected “@cds.persistence.skip” annotation on association target $(NAME) of $(ID) in path $(ELEMREF)',
           abstract: 'Unexpected “abstract” association target $(NAME) of $(ID) in path $(ELEMREF)',
         } );
+        break; // only one error per path
       }
     }
+
     // check managed association to have foreign keys array filled
-    if (art.keys && leafCount.call(this, art) === 0) {
-      this.error(null,
-                 obj.$path,
-                 { id: pathStep, elemref: obj },
+    if (art.keys && !hasForeignKeys.call(this, art)) {
+      this.error(null, $path, { id: pathStep, elemref: { ref } },
                  'Path step $(ID) of $(ELEMREF) has no foreign keys');
+      break; // only one error per path
     }
-
-    if (art.on) {
-      for (let j = 0; j < art.on.length; j++) {
-        if (j < art.on.length - 2 && art.on[j].ref && art.on[j + 1] === '=' && art.on[j + 2].ref) {
+    else if (art.on) {
+      for (let j = 0; j < art.on.length - 2; j++) {
+        if (art.on[j].ref && art.on[j + 1] === '=' && art.on[j + 2].ref) {
           const [ fwdAssoc, fwdPath ] = getForwardAssociation(pathStep, art.on[j], art.on[j + 2]);
-          if (fwdAssoc && fwdAssoc.keys && leafCount.call(this, fwdAssoc) === 0) {
-            this.error(null, obj.$path,
-                       { name: pathStep, elemref: obj, id: fwdPath },
+          if (fwdAssoc?.keys && !hasForeignKeys.call(this, fwdAssoc)) {
+            this.error(null, $path, { name: pathStep, elemref: { ref }, id: fwdPath },
                        'Path step $(NAME) of $(ELEMREF) is a $self comparison with $(ID) that has no foreign keys');
-            j += 2;
+            break; // only one error per path
           }
         }
       }
@@ -139,7 +199,7 @@ function checkRef( obj, inColumns ) {
 }
 
 /**
- * Get the forward association from a backling $self association.
+ * Get the forward association from a backlink $self association.
  *
  * @param {string} prefix Name of the association
  * @param {object} lhs Left hand side of the on-condition part

package/lib/checks/sql-snippets.js

@@ -18,14 +18,25 @@ function checkSqlAnnotationOnElement( member, memberName, prop, path ) {
     this.message('anno-invalid-sql-element', path, { anno: 'sql.prepend' }, 'Annotation $(ANNO) can\'t be used on elements' );
 
   if (member['@sql.append']) {
-    if (this.artifact.query || this.artifact.projection)
+    if (this.artifact.query || this.artifact.projection) {
       this.message('anno-invalid-sql-view-element', path, { anno: 'sql.append' }, 'Annotation $(ANNO) can\'t be used on elements in views' );
-    else if (this.csnUtils.isStructured(member))
+    }
+    else if (this.csnUtils.isStructured(member)) {
       this.message('anno-invalid-sql-struct', path, { anno: 'sql.append' }, 'Annotation $(ANNO) can\'t be used on structured elements' );
-    else if (member.value && !member.value.stored)
+    }
+    else if (this.csnUtils.isManagedAssociation(member)) {
+      this.message('anno-invalid-sql-assoc', path, { anno: 'sql.append', '#': member.type }, {
+        std: 'Annotation $(ANNO) can\'t be used here',
+        'cds.Association': 'Annotation $(ANNO) can\'t be used on association elements',
+        'cds.Composition': 'Annotation $(ANNO) can\'t be used on composition elements',
+      } );
+    }
+    else if (member.value && !member.value.stored) {
       this.message('anno-invalid-sql-calc', path, { anno: 'sql.append' }, 'Annotation $(ANNO) can\'t be used on calculated elements on read' );
-    else
+    }
+    else {
       checkValidAnnoValue(member, '@sql.append', path, this.error, this.options);
+    }
   }
 }
 

package/lib/checks/types.js

@@ -162,9 +162,9 @@ function errorAboutMissingType( error, path, artifact, name,
   let variant = isElement ? 'elm' : 'std';
   if (artifact.value?.stored)
     variant = 'calc';
-  error('check-proper-type', path, { art: name, '#': variant }, {
-    std: 'Dubious type $(ART) without type information',
-    elm: 'Dubious element $(ART) without type information',
+  error('def-missing-type', path, { art: name, '#': variant }, {
+    std: 'Missing type for $(ART)',
+    elm: 'Missing type for element $(ART)',
     calc: 'A stored calculated element must have a type',
   });
 }

package/lib/checks/utils.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { isBuiltinType } = require('../model/csnUtils');
-const { RelationalOperators } = require('../transform/transformUtilsNew');
+const { RelationalOperators } = require('../transform/transformUtils');
 /**
  * Prepare the ref steps so that they are loggable
  *

package/lib/compiler/assert-consistency.js

@@ -67,6 +67,9 @@
 'use strict';
 
 const { locationString, hasErrors } = require('../base/messages');
+const {
+  XsnSource, XsnName, XsnArtifact, CsnLocation,
+} = require('./classes');
 
 
 // Properties that can appear where a type can have type arguments.
@@ -84,7 +87,8 @@ class InternalConsistencyError extends Error {
 function assertConsistency( model, stage ) {
   const stageParser = typeof stage === 'object';
   const options = stageParser && stage || model.options || { testMode: true };
-  if (!options.testMode || options.parseOnly && !stageParser)
+  if (!options.testMode || options.testMode === '$noAssertConsistency' ||
+      options.parseOnly && !stageParser)
     return;
 
   const schema = {
@@ -105,6 +109,7 @@ function assertConsistency( model, stage ) {
         '$blocks',
         '$messageFunctions',
         '$functions',
+        '$assert',
         '_sortedSources',
       ],
     },
@@ -122,12 +127,14 @@ function assertConsistency( model, stage ) {
         '$withLocalized',
         '$sources',
       ],
+      instanceOf: XsnSource,
     },
     location: {
       // every thing with a $location in CSN must have a XSN location even
       // with syntax errors (currently even internal artifacts like $using):
       isRequired: parent => noSyntaxErrors() || parent && parent.kind,
       kind: true,
+      instanceOf: CsnLocation,
       requires: [ 'file' ],     // line is optional in top-level location
       optional: [ 'line', 'col', 'endLine', 'endCol', '$notFound' ],
       schema: {
@@ -138,8 +145,8 @@ function assertConsistency( model, stage ) {
         $notFound: { test: isBoolean },
       },
     },
-    sources: { test: isDictionary( isObject ) },
-    _sortedSources: { test: isArray( isObject ) },
+    sources: { test: isDictionary( isObject ), instanceOf: XsnSource },
+    _sortedSources: { test: isArray( isObject ), instanceOf: XsnSource },
     file: { test: isString },
     dirname: { test: isString },  // TODO: really necessary?
     realname: { test: isString }, // TODO: really necessary?
@@ -158,11 +165,13 @@ function assertConsistency( model, stage ) {
       test: isDictionary( definition ),
       requires: [ 'kind', 'location', 'name' ],
       optional: thoseWithKind,
+      instanceOf: XsnArtifact,
     },
     vocabularies: {
       test: isDictionary( definition ),
       requires: [ 'kind', 'name' ],
       optional: thoseWithKind,
+      instanceOf: XsnArtifact,
     },
     extensions: {
       kind: [ 'context' ],        // syntax error (as opposed to HANA CDS), but still there
@@ -174,7 +183,7 @@ function assertConsistency( model, stage ) {
     i18n: {
       test: isDictionary( ( val, parent, prop, spec, lang ) => {
         const textValueIsString = (v, p, textProp, s, textKey) => {
-          isString(v.val, p, textKey, s);
+          isString( v.val, p, textKey, s );
         };
         const innerDict = isDictionary( textValueIsString );
         return innerDict( val, parent, lang, spec );
@@ -197,7 +206,7 @@ function assertConsistency( model, stage ) {
           ],
           schema: {
             kind: { test: isString, enum: [ 'builtin' ] },
-            name: { test: isObject, requires: [ 'id', 'element' ] },
+            name: { test: isObject, instanceOf: XsnName, requires: [ 'id', 'element' ] },
             $autoElement: { test: isString },
             $uncheckedElements: { test: isBoolean },
             $requireElementAccess: { test: isBoolean },
@@ -240,7 +249,7 @@ function assertConsistency( model, stage ) {
     typeProps$: { kind: true, enumerable: false, test: TODO },
     actions: { kind: true, inherits: 'definitions' },
     enum: { kind: true, inherits: 'definitions' },
-    foreignKeys: { kind: true, inherits: 'definitions' },
+    foreignKeys: { kind: true, inherits: 'definitions', instanceOf: 'ignore' },
     $keysNavigation: { kind: true, test: TODO },
     params: { kind: true, inherits: 'definitions' },
     _extendType: { kind: true, test: TODO },
@@ -306,6 +315,7 @@ function assertConsistency( model, stage ) {
     columns: {
       kind: [ 'extend', '$column' ],
       test: isArray( column ),
+      instanceOf: XsnArtifact,
       optional: thoseWithKind,
       enum: [ '*' ],
       requires: [ 'location' ],
@@ -383,6 +393,7 @@ function assertConsistency( model, stage ) {
         'select', '$join', 'mixin',
         'source', 'namespace', 'using',
         '$tableAlias', '$navElement',
+        'builtin', // magic variables
       ],
     },
     // locations of parentheses pairs around expression:
@@ -501,6 +512,7 @@ function assertConsistency( model, stage ) {
     name: {
       isRequired: stageParser && (() => false), // not required in parser
       kind: true,
+      instanceOf: 'ignore', // TODO: XsnName,
       schema: {
         select: { test: TODO },
       }, // TODO: rename query prop in name
@@ -527,6 +539,7 @@ function assertConsistency( model, stage ) {
       kind: [ 'action', 'function' ],
       requires: [ 'kind', 'location' ],
       optional: thoseWithKind,
+      instanceOf: XsnArtifact,
     },
     items: {
       kind: true,
@@ -686,6 +699,7 @@ function assertConsistency( model, stage ) {
     $expected: { parser: true, test: isOneOf([ 'approved-exists', 'exists' ]) },
     $messageFunctions: { test: TODO },
     $functions: { test: TODO },
+    $assert: { test: TODO },    // currently just for missing Error[ref-cycle]
   };
   let _noSyntaxErrors = null;
   assertProp( model, null, stageParser ? ':parser' : ':model', null, true );
@@ -714,8 +728,10 @@ function assertConsistency( model, stage ) {
           : {}.propertyIsEnumerable.call( parent, prop ) !== enumerable)
         throw new InternalConsistencyError( `Unexpected enumerability ${ !enumerable }${ at( [ node, parent ], prop ) }` );
     }
-    (spec.test || standard)( node, parent, prop, spec,
-                             typeof noPropertyTest === 'string' && noPropertyTest );
+    if (node !== undefined) { // ignore if undefined
+      (spec.test || standard)( node, parent, prop, spec,
+                               typeof noPropertyTest === 'string' && noPropertyTest );
+    }
   }
 
   function definition( node, parent, prop, spec, name ) {
@@ -779,10 +795,11 @@ function assertConsistency( model, stage ) {
       const opt = Array.isArray(optional)
         ? optional.includes( n ) || optional.includes( n.charAt(0) )
         : optional( n, spec );
-      if (!(opt || requires.includes( n ) || n === '$extra'))
-        throw new InternalConsistencyError( `Property '${ n }' is not expected${ at( [ node[n], node, parent ], prop, name ) }` );
-
-      assertProp( node[n], node, n, spec.schema && spec.schema[n] );
+      if (node[n] !== undefined) {
+        if (!(opt || requires.includes( n ) || n === '$extra'))
+          throw new InternalConsistencyError( `Property '${ n }' is not expected${ at( [ node[n], node, parent ], prop, name ) }` );
+        assertProp( node[n], node, n, spec.schema && spec.schema[n] );
+      }
     }
   }
 
@@ -921,7 +938,9 @@ function assertConsistency( model, stage ) {
       const valSchema = { val: Object.assign( {}, spec, { test: func } ) };
       const requires = [ 'val', 'location' ];
       const optional = [ 'literal', '$inferred', '$priority', '_pathHead' ];
-      standard( node, parent, prop, { schema: valSchema, requires, optional }, name );
+      standard( node, parent, prop, {
+        schema: valSchema, requires, optional, instanceOf: spec.instanceOf,
+      }, name );
     };
   }
 
@@ -948,7 +967,7 @@ function assertConsistency( model, stage ) {
 
   function isString( node, parent, prop, spec ) {
     if (typeof node !== 'string')
-      throw new InternalConsistencyError( `Expected string${ at( [ node, parent ], prop ) }` );
+      throw new InternalConsistencyError( `Expected string but found ${ typeof node }${ at( [ node, parent ], prop ) }` );
       // TODO: also check getOwnPropertyNames(node)
     if (spec.enum && !spec.enum.includes( node ))
       throw new InternalConsistencyError( `Unexpected value '${ node }'${ at( [ node, parent ], prop ) }` );
@@ -962,10 +981,19 @@ function assertConsistency( model, stage ) {
   }
 
   function isObject( node, parent, prop, spec, name ) {
-    if (!node || typeof node !== 'object' || Object.getPrototypeOf( node ) !== Object.prototype)
-      throw new InternalConsistencyError( `Expected standard object${ at( [ null, parent ], prop, name ) }` );
+    if (!node || typeof node !== 'object' )
+      throw new InternalConsistencyError( `Expected object${ at( [ null, parent ], prop, name ) }` );
+    const found = Object.getPrototypeOf( node )?.constructor?.name || 'null';
+    if (!spec.instanceOf && Object.getPrototypeOf( node ) !== Object.prototype)
+      throw new InternalConsistencyError( `Expected standard object but found ${ found }${ at( [ null, parent ], prop, name ) }` );
+    // TODO
+    // else if (spec.instanceOf && spec.instanceOf !== 'ignore' &&
+    //    Object.getPrototypeOf( node ) !== spec.instanceOf.prototype)
+    // eslint-disable-next-line max-len
+    //  throw new InternalConsistencyError( `Expected object of class ${ spec.instanceOf.name } but found ${ found }${ at( [ null, parent ], prop, name ) }` );
   }
 
+
   function inDefinitions( art, parent, prop, spec, name ) {
     if (Array.isArray(art))   // do not check with redefinitions
       return;

package/lib/compiler/base.js

@@ -72,6 +72,7 @@ function propExists( prop, parent ) {
  * have a "sparse" name structure.
  *
  * @param {XSN.Artifact} art
+ * @returns {XSN.Name}
  */
 function getArtifactName( art ) {
   if (!art.name || art.name.absolute) // no name or “old style”

package/lib/compiler/builtins.js

@@ -390,7 +390,7 @@ function isRelationTypeName( typeName ) {
  * @returns {boolean}
  */
 function isInReservedNamespace( absolute ) {
-  return absolute.startsWith( 'cds.') &&
+  return absolute === 'cds' || absolute.startsWith( 'cds.') &&
     !absolute.match(/^cds\.foundation(\.|$)/) &&
     !absolute.match(/^cds\.outbox(\.|$)/) && // Requested by Node runtime
     !absolute.match(/^cds\.xt(\.|$)/); // Requested by Mtx
@@ -485,7 +485,10 @@ function initBuiltins( model ) {
     for (const name in builtins) {
       const magic = builtins[name];
       // TODO: rename to $builtinFunction
-      const art = { kind: 'builtin', name: { id: name, absolute: name } };
+      const art = {
+        kind: 'builtin',
+        name: { id: name, absolute: '', element: name },
+      };
       artifacts[name] = art;
 
       if (magic.$autoElement)
@@ -513,12 +516,8 @@ function initBuiltins( model ) {
 
     for (const n of names) {
       const magic = {
-        kind: 'builtin',
-        name: {
-          id: n,
-          absolute: art.name.absolute,
-          element: art.name.element ? `${ art.name.element }.${ n }` : n,
-        },
+        kind: 'builtin',        // TODO: '$variable'
+        name: { id: n, absolute: '', element: `${ art.name.element }.${ n }` },
       };
       // Propagate this property so that it is available for sub-elements.
       if (art.$uncheckedElements)