@sap/cds-dk 10.1.1 → 10.2.0

package/node_modules/@sap/cds-compiler/lib/compiler/generate.js

@@ -2,6 +2,16 @@
 
 'use strict';
 
+// Texts entity is created with the following elements in (weird) order:
+//  - if @fiori.draft.enabled: key `ID_texts` and non-key `locale`
+//    (de-keyed `locale` from sap.common.TextsAspect, or generated),
+//    then other elements from sap.common.TextsAspect
+//  - if not @fiori.draft.enabled: elements from sap.common.TextsAspect
+//    (with `locale` at its place!), or generated key `locale`
+//  - `language` with option `addTextsLanguageAssoc` (can't then be in sap.common.TextsAspect)
+//  - keys (de-keyed if @fiori.draft.enabled) and localized of base entity in definition order
+//    (can shadow elements from sap.common.TextsAspect, then at that position)
+
 /* eslint-disable no-nested-ternary */
 
 const { isDeprecatedEnabled } = require('../base/specialOptions');
@@ -19,6 +29,7 @@ const {
   forEachGeneric,
 } = require('./utils');
 const { weakLocation, weakRefLocation, weakEndLocation } = require('../base/location');
+const { XsnArtifact, XsnName } = require('./xsn-model');
 
 const $location = Symbol.for( 'cds.$location' );
 
@@ -34,7 +45,6 @@ function generate( model ) {
     resolveUncheckedPath,
     initMainArtifact,
     extendArtifactBefore,
-    applyIncludes,
   } = model.$functions;
   Object.assign( model.$functions, {
     hasTruthyProp,
@@ -106,36 +116,38 @@ function generate( model ) {
   function useTextsAspect( report = false ) {
     if (!report && enableTextsAspect != null)
       return enableTextsAspect;
-
-    const locale = Functions.effectiveType( textsAspect )?.elements?.locale;
-    const err = (!textsAspect || textsAspect.$inferred )
-      ? false
-      : (textsAspect.kind !== 'aspect' || !textsAspect.elements)
-        ? 'no-aspect'
-        : (!locale || locale.$inferred)
-          ? 'missing'
-          : (locale.key?.val ? null : 'key');  // TODO: better eslint @stylistic/indent
+    if (!textsAspect || textsAspect.$inferred ) {
+      enableTextsAspect = false;
+      return false;
+    }
+    const elements = Functions.effectiveType( textsAspect )?.elements;
+    const locale = elements?.locale;
+    const err = (textsAspect.kind !== 'aspect' || !textsAspect.elements)
+      ? 'no-aspect'
+      : (!locale || locale.$inferred)
+        ? 'missing'
+        : (!locale.key?.val)
+          ? 'key'
+          : elements?.language && options.addTextsLanguageAssoc && 'language';
+    const address = (err === 'key')
+      ? locale
+      : (err === 'language') ? elements?.language : textsAspect;
     if (report && err) {
-      const loc = (err === 'key' ? locale : textsAspect)?.name?.location || null;
-      error( 'def-invalid-texts-aspect', [ loc, (err === 'key' ? locale : textsAspect) ],
-             { '#': err, art: textsAspect, name: 'locale' } );
+      const name = (err === 'language') ? 'language' : 'locale';
+      error( 'def-invalid-texts-aspect', [ address?.name?.location, address ],
+             // eslint-disable-next-line @stylistic/object-curly-newline
+             { '#': err, art: textsAspect, name, option: 'addTextsLanguageAssoc' } );
     }
-    enableTextsAspect = (err == null);
+    enableTextsAspect = !err;
     return enableTextsAspect;
   }
 
   function checkGenerateConditions() {
+    // TODO: we can probably check this now directly
     addLanguageAssoc( true );
     if (!useTextsAspect( true ))
       return;
 
-    if (enableLanguageAssoc && textsAspect.elements.language) {
-      const lang = textsAspect.elements.language;
-      error( 'def-unexpected-element', [ lang.name.location, lang ],
-             { option: 'addTextsLanguageAssoc', art: textsAspect, name: 'language' },
-             'Element $(NAME) of $(ART) is not used because option $(OPTION) is set' );
-    }
-
     for (const name in textsAspect.elements) {
       const elem = textsAspect.elements[name];
       const include = elem.$inferred === 'include';
@@ -295,8 +307,9 @@ function generate( model ) {
   function createTextsEntity( base, absolute, textElems, fioriEnabled ) {
     const location = weakLocation( base.elements[$location] || base.location );
     const art = Functions.registerGeneratedEntity( {
+      __proto__: XsnArtifact.prototype,
       kind: 'entity',
-      name: { id: absolute, location },
+      name: { __proto__: XsnName.prototype, id: absolute, location },
       location,
       elements: Object.create( null ),
       $inferred: 'localized-entity',
@@ -312,12 +325,14 @@ function generate( model ) {
     }
     else {
       const textId = {
-        name: { location, id: 'ID_texts' },
+        __proto__: XsnArtifact.prototype,
+        name: { __proto__: XsnName.prototype, location, id: 'ID_texts' },
         kind: 'element',
         key: { val: true, location },
         type: linkMainArtifact( location, 'cds.UUID' ),
         location,
       };
+      // Do not set $inferred, otherwise $postponeInclude does not work
       art.elements.ID_texts = textId;
     }
     // _service links and "consider as composition target" must be set already here
@@ -335,7 +350,8 @@ function generate( model ) {
 
     if (addLanguageAssoc()) {
       const language = {
-        name: { location, id: 'language' },
+        __proto__: XsnArtifact.prototype,
+        name: { __proto__: XsnName.prototype, location, id: 'language' },
         kind: 'element',
         location,
         type: linkMainArtifact( location, 'cds.Association' ),
@@ -363,17 +379,7 @@ function generate( model ) {
     // do the kick-start relevant stuff: _service, there are no _ancestors,
     // _descendants would have been set already for a gap artifact
 
-    if (art.includes) {   // i.e. sap.common.TextsAspect
-      // do not insert sap.common.TextsAspect elements before `locale`:
-      // add elements `locale`, etc. which are required below.
-      art.includes.$original = []; // do not apply via extendArtifactAdd()
-      applyIncludes( art, art );   // apply now
-    }
-
     if (fioriEnabled) {
-      // The includes mechanism puts TextsAspect's elements before .texts' elements.
-      // Because ID_texts is not copied from TextsAspect, the order is messed
-      // up.  Fix it.  TODO: introduce $includeAfter from Extensions.md
       const { elements } = art;
       art.elements = Object.create( null );
       const names = [ 'ID_texts', 'locale', ...Object.keys( elements ) ];
@@ -437,10 +443,11 @@ function generate( model ) {
     propagateEarly( art, '@fiori.draft.enabled' );
 
     if (fioriEnabled) {
-      // "Early" include; only for element `locale`, which has its `key` property
-      // removed (or rather: it is not copied).
+      art.includes[0].$postponeInclude = 2; // first: ID_texts, locale
+      // (weird: `locale` is not necessarily the first without @fiori.draft.enabled')
+      // Element `locale` from sap.common.TextsAspect without `key` property:
       linkToOrigin( textsAspect.elements.locale, 'locale', art, 'elements', location );
-      art.elements.locale.$inferred = 'localized';
+      // Do not set $inferred, otherwise $postponeInclude does not work
     }
 
     if (addLanguageAssoc() && art.elements.language)
@@ -458,7 +465,8 @@ function generate( model ) {
     const hasLocaleType = model.definitions['sap.common.Locale']?.kind === 'type';
     const { location } = art;   // is already a weak location
     const locale = {
-      name: { location, id: 'locale' },
+      __proto__: XsnArtifact.prototype,
+      name: { __proto__: XsnName.prototype, location, id: 'locale' },
       kind: 'element',
       type: linkMainArtifact( location, hasLocaleType ? 'sap.common.Locale' : 'cds.String' ),
       location,
@@ -483,7 +491,8 @@ function generate( model ) {
     const keys = textElems.filter( e => e.key && e.key.val );
     const location = weakEndLocation( art.elements[$location] ) || weakLocation( art.location );
     const texts = {
-      name: { location, id: 'texts' },
+      __proto__: XsnArtifact.prototype,
+      name: { __proto__: XsnName.prototype, location, id: 'texts' },
       kind: 'element',
       location,
       $inferred: 'localized',
@@ -498,7 +507,8 @@ function generate( model ) {
     //             localized.ID=ID and localized.locale = $user.locale;
     keys.push( [ 'localized.locale', '$user.locale' ] );
     const localized = {
-      name: { location, id: 'localized' },
+      __proto__: XsnArtifact.prototype,
+      name: { __proto__: XsnName.prototype, location, id: 'localized' },
       kind: 'element',
       location,
       $inferred: 'localized',
@@ -687,7 +697,8 @@ function generate( model ) {
     };
 
     const up_ = { // elements.up_ = ...
-      name: { location, id: 'up_' },
+      __proto__: XsnArtifact.prototype,
+      name: { __proto__: XsnName.prototype, location, id: 'up_' },
       kind: 'element',
       location,
       key: { location, val: true },
@@ -704,8 +715,10 @@ function generate( model ) {
       },
     };
     const art = Functions.registerGeneratedEntity( {
+      __proto__: XsnArtifact.prototype,
       kind: 'entity',
       name: {
+        __proto__: XsnName.prototype,
         id: entityName,
         // for code navigation (e.g. via `extend`s): point to the element's name
         location: weakLocation( elem.name.location ),
@@ -873,7 +886,7 @@ function augmentEqual( location, assocname, relations, prefix = '' ) {
 /**
  * Propagate the given `prop` (e.g. annotation) early, i.e. copy it from all `.includes`
  * if they have the property.
- * TEMPORARY copy from ./extend.js
+ * TODO: move to ./utils.js,
  *
  * @param {XSN.Definition} art
  * @param {string} prop

package/node_modules/@sap/cds-compiler/lib/compiler/populate.js

@@ -23,6 +23,7 @@ const {
 } = require('./dictionaries');
 const { weakLocation, weakRefLocation } = require('../base/location');
 const { CompilerAssertion } = require('../base/error');
+const { XsnArtifact, XsnName } = require('./xsn-model');
 
 const { kindProperties } = require('./base');
 const {
@@ -216,12 +217,14 @@ function populate( model ) {
       // Without type, value.path or _origin at beginning, link to itself:
       extendArtifactBefore( a );
       populateGeneratedEntity( a );
-      if (a.includes)
+      if (a.includes)           // TODO: make this part of populateArtifact()
         a.includes.forEach( i => resolveInclude( i, a ) );
       art = populateArtifact( a, art ) || a;
       extendArtifactAdd( a );
       setLink( a, '_effectiveType', art );
       a.$effectiveSeqNo = ++effectiveSeqNo;
+      if (!a._main && !a._outer)
+        model._entities.push( a ); // for propagation of keys
       // console.log('PE:',require('../model/revealInternalProperties').ref(a))
       if (a.elements$ || a.enum$)
         mergeSpecifiedElementsOrEnum( a );
@@ -238,10 +241,11 @@ function populate( model ) {
 
   function resolveInclude( include, art ) {
     // includes have been resolved with resolveUncheckedPath() with art/ext
-    // before, i.e. it is ok to just use `a` as "user"
+    // before, i.e. it is ok to just use `art` as "user"
     const name = resolveUncheckedPath( include, 'include', art );
     // use effectiveType(), which applies extensions, before resolvePath()
     // where we check for the number of elements in the accept functions
+    // TODO: not necessary anymore - accept function doesn't do that anymore
     if (name)
       effectiveType( model.definitions[name] );
     resolvePath( include, 'include', art );
@@ -421,7 +425,7 @@ function populate( model ) {
       return true;
     }
     const location = weakRefLocation( art.type || art.value ) || weakLocation( art.location );
-    art.items = { $inferred: 'expanded', location };
+    art.items = { __proto__: XsnArtifact.prototype, $inferred: 'expanded', location };
     setLink( art.items, '_outer', art );
     setLink( art.items, '_parent', art._parent );
     setLink( art.items, '_origin', origin.items );
@@ -480,7 +484,10 @@ function populate( model ) {
       // TODO: make linkToOrigin() work for returns, kind/name?
       const location = weakLocation( origin.returns.location );
       art.returns = {
-        name: Object.assign( {}, art.name, { id: '', location } ),
+        __proto__: XsnArtifact.prototype,
+        name: {
+          __proto__: XsnName.prototype, ...art.name, id: '', location,
+        },
         kind: 'param',
         location,
         $inferred: 'expanded',
@@ -537,8 +544,6 @@ function populate( model ) {
   // Views
   //--------------------------------------------------------------------------
 
-  // TODO: delete XSN._entities
-
   /**
    * Merge _specified_ elements with _inferred_ elements in the given view/element,
    * where specified elements can appear through CSN.
@@ -749,7 +754,9 @@ function populate( model ) {
     const { targetMax } = path[path.length - 1].cardinality ||
                           getInheritedProp( assoc, 'cardinality' ) || {};
     if (targetMax && (targetMax.val === '*' || targetMax.val > 1)) {
-      elem.items = { location: elem.expand[$location], $inferred: 'query' };
+      elem.items = {
+        __proto__: XsnArtifact.prototype, location: elem.expand[$location], $inferred: 'query',
+      };
       setLink( elem.items, '_outer', elem );
     }
     return initFromColumns( elem, elem.expand );
@@ -784,7 +791,7 @@ function populate( model ) {
         const q = userQuery( query );
         q.$inlines.push( col );
         col.kind = '$inline';
-        col.name = { id: `.${ q.$inlines.length }`, $inferred: '$internal' };
+        col.name = { __proto__: XsnName.prototype, id: `.${ q.$inlines.length }`, $inferred: '$internal' };
         // TODO: use a name already set in define.js
         // TODO: really use $inferred: '$internal', not '$inline' ? Re-check.
         // a name for this internal symtab entry (e.g. '.2' to avoid clashes
@@ -1088,7 +1095,7 @@ function populate( model ) {
     if (!exposed.length) {
       const origTarget = target;
       // TODO: probably calculate effectiveType of target earlier
-      if (effectiveType( target ) && isAutoExposed( target ))
+      if (effectiveType( target ) && isAutoExposed( target, service ))
         target = createAutoExposed( origTarget, service, elemScope );
       const desc = origTarget._descendants ||
             setLink( origTarget, '_descendants', Object.create( null ) );
@@ -1207,7 +1214,10 @@ function populate( model ) {
       return autoScope;
     const { location } = service.name;
     const nullScope = {
-      kind: 'namespace', name: { id: autoScopeName, location }, location,
+      __proto__: XsnArtifact.prototype,
+      kind: 'namespace',
+      name: { __proto__: XsnName.prototype, id: autoScopeName, location },
+      location,
     };
     model.definitions[autoScopeName] = nullScope;
     initMainArtifact( nullScope );
@@ -1252,46 +1262,60 @@ function populate( model ) {
 
   // Auto-exposure -----------------------------------------------------------
 
+  // @cds.autoexpose on entity is propagated along query source (not via assoc)
+  //
+  // - not provided or null: auto-expose if it "is composition target"
+  //   (is also propagated, but has lower priority)
+  // - false (or 0, ''): don't auto-expose
+  // - truthy: auto-expose if there is no falsy @cds.autoexpose on service,
+  //   counts as not provided otherwise → check "is composition target"
+
   // Remark: With includes, the compiler propagates @cds.autoexpose early.
-  function isAutoExposed( target ) {
+  function isAutoExposed( target, service ) {
     // remark: effectiveType( target ) has been called → we can use links directly
-    if (target.$autoexpose !== undefined)
-      return target.$autoexpose;
+    const viaAnno = inheritAutoExpose( target, autoExposeViaAnno ) &&
+      (!annotationIsFalse( service['@cds.autoexpose'] ) || null);
+    return viaAnno ?? inheritAutoExpose( target, autoExposeViaComposition );
+  }
 
-    const origTarget = target;
-    const chain = [];
-    while (target.$autoexpose === undefined && setAutoExposed( target )) {
-      // stop at first ancestor with annotation or at non-query entity
-      let source = target._origin; // first table alias of leading query
-      // no propagation along `Source:assoc` → cannot traverse source._origin
-      // until we find main artifact
-      while (source?._origin?._main) // sub query in from
-        source = source._origin._origin; // its first table alias
-      source = source?._artifact; // different to source._origin if `Source:assoc`
-      if (!source || source._main) // ref error of `Source:assoc`
+  function inheritAutoExpose( art, callback ) {
+    let val = callback( art );
+    if (val !== undefined)
+      return val;
+
+    const chain = [ art ];
+    while (val === undefined && art.query && art._effectiveType) { // no answer yet
+      let alias = art._origin;
+      while (alias?._origin?._main)    // sub query in from
+        alias = alias._origin._origin; // its first table alias
+      art = alias?._artifact;          // not alias?._origin(!)
+      if (!art || art._main)           // ref error or `Source:assoc`
         break;
-      chain.push( target );
-      target = source;
-    }
-    const autoexpose = target.$autoexpose;
-    if (typeof autoexpose === 'boolean') {
-      for (const a of chain)
-        a.$autoexpose = autoexpose;
+      val = callback( art );
+      chain.push( art );
     }
-    return origTarget.$autoexpose;
+    val ??= null;
+    chain.forEach( a => callback( a, val ) );
+    return val;
   }
 
-  // TODO: less auto-exposed for compositions (see lengthy discussions)
-  function setAutoExposed( art ) {
-    const anno = art['@cds.autoexpose'];
-    if (anno && anno.val !== null) { // XSN TODO: set val, but no location for anno short form
-      // @cds.autoexpose:true or @cds.autoexpose:false
-      art.$autoexpose = anno.val === undefined || !!anno.val;
-      return false;             // stop with @cds.autoexpose
+  function autoExposeViaAnno( art, val = undefined ) {
+    if (val !== undefined) {
+      art.$autoexpose = val;
     }
-    // no @cds.autoexpose or @cds.autoexpose:null
-    art.$autoexpose = model.$compositionTargets[art.name.id] ? true : null;
-    return art.query; // still check for inherited @cds.autoexpose if query entity
+    else if (art.$autoexpose === undefined) {
+      const anno = art['@cds.autoexpose'];
+      if (anno && anno.val !== null)
+        return anno.val === undefined || !!anno.val;
+    }
+    return art.$autoexpose;
+  }
+
+  function autoExposeViaComposition( art, val = undefined ) {
+    const { id } = art.name;
+    if (val !== undefined)
+      model.$compositionTargets[id] = val;
+    return model.$compositionTargets[id];
   }
 
   function autoExposedName( target, service, elemScope ) {
@@ -1357,14 +1381,19 @@ function populate( model ) {
     const location = weakRefLocation( target.name );
     const from = { path: [ { id: target.name.id, location } ], location };
     const art = registerGeneratedEntity( {
+      __proto__: XsnArtifact.prototype,
       kind: 'entity',
-      name: { location, id: absolute },
+      name: { __proto__: XsnName.prototype, location, id: absolute },
       location,
       query: { location, op: { val: 'SELECT', location }, from },
       $syntax: 'projection',
       $inferred: 'autoexposed',
       '@cds.autoexposed': {
-        name: { path: [ { id: 'cds.autoexposed', location } ], location },
+        name: {
+          __proto__: XsnName.prototype,
+          path: [ { id: 'cds.autoexposed', location } ],
+          location,
+        },
         $inferred: '$generated',
       },
     } );
@@ -1376,7 +1405,7 @@ function populate( model ) {
       forEachGeneric( target, 'params', (p, pn) => {
         art.params[pn] = linkToOrigin( p, pn, art, 'params' );
         from.path[0].args[pn] = {
-          name: { id: p.name.id, location },
+          name: { __proto__: XsnName.prototype, id: p.name.id, location },
           location,
           scope: 'param',
           path: [ { id: pn, location } ],

package/node_modules/@sap/cds-compiler/lib/compiler/propagator.js

@@ -347,6 +347,7 @@ function propagate( model ) {
   /**
    * Propagate `localized`, but not for a texts entity
    * (as `null` in an Universal CSN).
+   * TODO: extra handling of #14363 for .texts still necessary? we have `localized: null`
    */
   function localized( prop, target, source ) {
     const main = target._main;

package/node_modules/@sap/cds-compiler/lib/compiler/resolve.js

@@ -69,6 +69,7 @@ const {
 
 const detectCycles = require('./cycle-detector');
 const { CompilerAssertion } = require('../base/error');
+const { XsnName, XsnArtifact } = require('./xsn-model');
 
 const $location = Symbol.for( 'cds.$location' );
 
@@ -148,9 +149,6 @@ function resolve( model ) {
     //       foreign keys in populate.js (foreign key access w/o JOINs).
 
     // Phase 2+3: calculate keys along simple queries in collected views:
-    model._entities = Object.values( model.definitions )
-      .filter( art => art.$effectiveSeqNo )
-      .sort( (x, y) => x.$effectiveSeqNo - y.$effectiveSeqNo );
     model._entities.forEach( setNavigationProjections );
     model._entities.forEach( propagateKeyProps );
     // While most dependencies leading have been added at this point, new
@@ -637,6 +635,7 @@ function resolve( model ) {
          art.value.scope === 'param' )) {
       art['@Core.Computed'] = {
         name: {
+          __proto__: XsnName.prototype,
           path: [ { id: 'Core.Computed', location: art.location } ],
           location: art.location,
         },
@@ -1457,7 +1456,10 @@ function resolve( model ) {
       if (elem.key?.val) {
         const location = weakLocation( obj.target.location );
         const key = {
-          name: { location, id: elem.name.id, $inferred: 'keys' },
+          __proto__: XsnArtifact.prototype,
+          name: {
+            __proto__: XsnName.prototype, location, id: elem.name.id, $inferred: 'keys',
+          },
           kind: 'key',
           targetElement: { path: [ { id: elem.name.id, location } ], location },
           location,

package/node_modules/@sap/cds-compiler/lib/compiler/shared.js

@@ -41,6 +41,8 @@ function fns( model ) {
   const Functions = model.$functions;
 
   // Map `exprCtx` (is a param of traversal functions) to reference semantics
+  //
+  // accept: function w
   const referenceSemantics = {
     // global: ------------------------------------------------------------------
     using: {                    // only used to produce warnings
@@ -939,12 +941,11 @@ function fns( model ) {
         }
         else if (art.$inferred === 'autoexposed' && !user.$inferred &&
                  isMainRef !== 'no-leaf-gap') {
-          // Depending on the processing sequence, the following could be a
-          // simple 'ref-undefined-def' - TODO: which we
-          // could "change" to this message at the end of compile():
-          // HINT: this does not appear anymore
-          error( 'ref-unexpected-autoexposed', [ item.location, user ], { art },
-                 'An auto-exposed entity can\'t be referred to - expose entity $(ART) explicitly' );
+          semantics.notFound( user, item, [ removeGapArtifact( env, true ) ],
+                              null, prev, path, semantics );
+          // TODO: with delayed messaging, we could have an extra text variant for
+          // 'An auto-exposed entity can\'t be referred to', see code in v6.  Not now,
+          // since the creation of auto-exposed entities depends on the processing seq
           return null;            // continuation semantics: like “not found”
         }
       }
@@ -1691,52 +1692,30 @@ function fns( model ) {
     return false;
   }
 
-  function acceptStructOrBare( art, user, ref ) { // for includes[]
-    // eslint-disable-next-line @stylistic/object-curly-newline
-    if (user.kind in { context: 1, service: 1, action: 1, function: 1 })
-      return false;
-    // It had been checked before that `includes` is already forbidden for
-    // non-entity/aspect/type/event.
-    //
-    // We currently disallow as include:
-    // - non-structured types or derived type of structured:
-    //   would have to follow type in extend/include;
-    // - entities with params: clarify inheritance, use of param in ON/DEFAULT;
-    // - query entities/events: difficult sequence of resolve steps
-    // - aspect with one ore more elements on query entities / events
-    // - aspect with `elements` property on non-structured types
-
-    // TODO: adapt `user` if it is an `extend`?  NOTE: we cannot call
-    // effectiveType() on user - it might be in the process of being computed!
-    // Also, it is not clear whether `art.elements` has been completed → testing
-    // its length might be processing-sequence dependent, see #11346.  We must
-    // ensure that an include does not add the `elements` property!
+  function acceptStructOrBare( art, user, ref ) { // for includes
+    // Also consider reportInvalidIncludes() in extend.js
     const base = (user.kind === 'extend' ? user.name._artifact : user);
-    if (!base)
+    if (!base)                  // TODO: test CSN input
+      return art;
+
+    if (![ 'entity', 'aspect', 'type', 'event' ].includes( base.kind )) {
+      // TODO: allow bare aspects for all others - soon
+      error( 'extend-unexpected-include', [ ref.location, user ], { '#': base.kind } );
+    }
+    else if (![ 'entity', 'aspect', 'type', 'event' ].includes( art.kind )) {
+      // Remark: with delayed message text, we could choose the bare text variant
+      // where appropriate (scalar types, …); can do that here only for aspects,
+      // because the effective type of `base` has not necessarily been calculated
+      error( 'ref-invalid-include', [ ref.location, user ],
+             { '#': (art.kind !== 'aspect' || art.elements ? 'std' : 'bare') } );
+    }
+    else if (!art.params) {
       return art;
-    if (base.query || base.type || !base.elements) {
-      // Remark: it is not necessary to test for user.elements[$inferred], because
-      // the type could only have inferred elements if it has a type expression.
-      // Including aspects with elements is forbidden for aspects without the
-      // `elements` property.  Testing for the length of `art.elements` requires
-      // that we have applied potential `includes` of `art` before!
-      // We might allow includes with elements in the future, they'd probably
-      // count as specified elements with lower priority, i.e. annos, types, key
-      // etc on columns beat those inherited from the include.
-      // TODO v7 forbid `extend Proj with ZeroElemAspect` even if ZeroElemAspect has
-      // 0 elements.  Making the element-length check work requires that effectiveType()
-      // has been called on the include already before.
-      if (art.kind === 'aspect' &&
-          (!art.elements || base.query && !Object.keys( art.elements ).length))
-        return art;
-      signalNotFound( 'ref-invalid-include', [ ref.location, user ], null,
-                      { '#': 'bare' } );
     }
     else {
-      if (!art.query && !art.type && !art.params && (art.elements || art.kind === 'aspect'))
-        return art;
-      const variant = art.params && 'param' || 'std';
-      signalNotFound( 'ref-invalid-include', [ ref.location, user ], null, { '#': variant } );
+      // art.params could not come via inferrence or be added via extend
+      signalNotFound( 'ref-invalid-include', [ ref.location, user ], null,
+                      { '#': 'param' } );
     }
     return false;
   }
@@ -2220,7 +2199,7 @@ function fns( model ) {
         names.length = 20;
         names[20] = '…';
       }
-      info( null, [ loc, null ],
+      info( null, [ loc, null ], // Ok to have no message-id here (just --test-mode)
             { '#': !names.length ? 'zero' : 'std' },
             { std: `Valid: ${ names.join( ', ' ) }`, zero: 'No valid names' } );
     }
@@ -2255,6 +2234,8 @@ function removeDollarNames( dict ) {
 }
 
 function removeGapArtifact( dict, alsoRemoveInferred ) {
+  // With `alsoRemoveInferred`, do not list compiler-generated entities
+  // TODO: limit to auto-exposed entities, don't use !definedViaCdl() as arg
   const r = Object.create( null );
   for (const name in dict) {
     const art = dict[name];