@sap/cds-compiler 6.8.0 → 6.9.1

package/CHANGELOG.md

@@ -13,6 +13,61 @@ we might not list every change in its behavior here.
 Productive code should never require a `beta` flag to be set, and
 might use a deprecated flag only for a limited period of time.
 
+## Version 6.9.1 - 2026-05-05
+
+### Bug Fixes
+
+- **compiler:**
+  + make an element added via `extend` correctly shadow an element from an include
+  + do not issue a warning for a correct use of `$projection`
+- **odata:**
+  + do not generate wrong ReferentialConstraints for unmanaged Composition without a partner
+  + render Partner attribute on forward association correctly
+
+
+
+## Version 6.9.0 - 2026-04-21
+
+### Features
+
+- **compiler:**
+  + add support for extending views/projections with several SQL clauses:
+    `where`, `group by`, `having`, `order by`, `limit`
+  + allow extending derived enum types/elements by adding enum symbols
+  + inside `extend … with enum {…}`, it is now possible to use `extend existingEnumSymbol with @Anno`,
+    like it is already possible inside `extend … with {…}`
+  + when the new options `v7KeyPropagation` is set, the propagation of the `key` property in queries is simplified,
+    and the `key` property is not propagated when including structures into types
+- **odata:** set `meta.compilerCsnFlavor` in the OData transformed CSN
+- **seal**: set `meta.compilerCsnFlavor` in the SEAL transformed CSN
+- **effective:** set `meta.compilerCsnFlavor` in the effective CSN
+- **sql:**
+  + set `meta.compilerCsnFlavor` in SQL transformed CSN
+  + allow single-leafed structures within a `list` on the left-hand side of the `IN` operator.
+    For example `(author, struct) in (...)` becomes `(author_ID, struct_leaf) in (...)`.
+  + support `cds.Vector` on Postgres and H2
+
+### Bug Fixes
+
+- **compiler:**
+  + don't introduce a strange `cast` property in the CSN for a column with an expand on a to-many association
+  + while crawling tokens for LSP, allow extensions without name
+- **effective:** don't absolutify paths in filters in annotations
+- **sql:** properly resolve references in annotation values and `on` conditions for a column inside an expand without base reference
+
+### Improvements
+
+- **compiler:**
+  + add `compilerVersion` to CSN meta
+  + issue a warning if a structure in an annotation value would have the same CSN representation as an expression
+  + issue warnings for extends on built-in types
+  + warn on duplicate members from includes via extend
+- **odata:**
+  + update OData vocabularies: Common, Core, UI
+  + using `@readonly` with an expression value on entities or aspects is no longer silently accepted and now produces an error
+
+
+
 ## Version 6.8.0 - 2026-03-05
 
 ### Features

package/README.md

@@ -1,6 +1,7 @@
 # Getting started
 
 
+
 ## Installation and Usage
 
 Install with npm:
@@ -20,16 +21,19 @@ Or maintain your package.json dependencies as follows:
 If your project already has a dependency to `@sap/cds`, nothing has to be done.
 
 
+
 ## Documentation
 
 Please refer to the [official CDS documentation](https://cap.cloud.sap/docs/cds/).
 
 
+
 ## How to Obtain Support
 
 In case you find a bug, please report an [incident](https://cap.cloud.sap/docs/resources/#reporting-incidents) on SAP Support Portal.
 
 
+
 ## History and License
 
 The cds-compiler uses [Semantic Versioning](./doc/Versioning.md) for its version numbers.

package/bin/cdshi.js

@@ -32,6 +32,7 @@ const categoryChars = {         // default: first char of category name
   ExtService: 'S',          // highlight like service definition
   ExtContext: 'C',          // highlight like context definition
   // ExtElement: 'E',       // using the first letter is the default
+  ExtEnum: 'H',             // highlight like enum symbol definition
   ExtBoundAction: 'B',      // highlight like bound action definition
   ExtParam: 'P',            // highlight like entity/action parameter definition
   FromImplicit: 'W',

package/lib/api/main.js

@@ -307,7 +307,14 @@ function forEffectiveInternal( csn, options, internalOptions, messageFunctions )
 function forSeal( csn, options, messageFunctions ) {
   const internalOptions = prepareOptions.for.seal(options);
   internalOptions.transformation = 'effective';
-  return forEffectiveInternal(csn, options, internalOptions, messageFunctions);
+  const result = forEffectiveInternal(csn, options, internalOptions, messageFunctions);
+
+  if (!options.testMode) {
+    result.meta ??= {};
+    result.meta.compilerCsnFlavor = 'seal';
+  }
+
+  return result;
 }
 
 /**

package/lib/api/options.js

@@ -2,7 +2,8 @@
 
 // The options are specified in ../base/optionProcessor.js (and some other files).
 // Some backends feel the need to "translate" option, which require to list
-// all options also here (as “public" or "private" option).
+// all options also here (as "public" or "private" option).
+// Parser and core compiler options might not have been listed here.
 
 const { validate, generateStringValidator } = require('./validate');
 const { makeMessageFunction } = require('../base/messages');
@@ -25,6 +26,7 @@ const publicOptionsNewAPI = [
   'defaultStringLength',
   'csnFlavor',
   'noDollarCalc',
+  'v7KeyPropagation',
   // DB
   'sqlDialect',
   'sqlMapping',

package/lib/base/builtins.js

@@ -89,29 +89,33 @@ function isMagicVariable( name ) {
 }
 
 /**
- * Properties that are required next to `=` to make an annotation value an actual expression
- * and not some foreign structure.
+ * Properties (without those from CSN v0.1.0) that make an annotation object value
+ * an actual expression and not some foreign structure.
  *
  * @type {string[]}
  */
-const xprInAnnoProperties = [
-  'ref', 'xpr', 'list', 'literal', 'val',
-  '#', 'func', 'args', 'SELECT', 'SET',
-  'cast',
+const primaryExprProperties = [
+  'ref', 'xpr', 'list', 'val', '#', 'func', 'SELECT', 'SET',
+];
+// only with 'ref'/'val'/'func'/misc:
+const exprProperties = [
+  ...primaryExprProperties,
+  'param', 'literal', 'args', 'cast',
 ];
-
 
 /**
  * Return whether JSON object `val` is a representation for an annotation expression
  */
 function isAnnotationExpression( val ) {
-  return val?.['='] !== undefined && xprInAnnoProperties.some( prop => val[prop] !== undefined );
+  return val?.['='] !== undefined && // TODO: truthy
+    primaryExprProperties.some( prop => val[prop] !== undefined );
 }
 
 module.exports = {
   propagationRules,
   acceptsExprValues,
-  xprInAnnoProperties,
+  primaryExprProperties,
+  exprProperties,
   isInReservedNamespace,
   isBuiltinType,
   isMagicVariable,

package/lib/base/csnRefs.js

@@ -784,14 +784,15 @@ function csnRefs( csn, universalReady ) {
         const target = assocTarget( parent, refCtx );
         return resolvePath( path, target.elements[head], target, 'target' );
       }
-      if (baseEnv) {               // ref-target (filter condition), expand, inline
-        if (semantics.dynamic !== 'query')
-          return resolvePath( path, baseEnv.elements[head], baseEnv, semantics.dynamic );
-        // in an ON condition of an association inside inner expand/inline:
+      if (semantics.dynamic === 'query') {
+        // in an anno, or an ON condition of an association inside inner expand/inline:
         const elemParent = getCache( parent, '_element' );
-        if (elemParent)         // expand in expand
+        if (elemParent?.elements) // expand in expand
           return resolvePath( path, elemParent.elements[head], null, 'query' );
       }
+      else if (baseEnv) {       // ref-target (filter condition), expand, inline
+        return resolvePath( path, baseEnv.elements[head], baseEnv, semantics.dynamic );
+      }
       if (!query) {                // outside queries - TODO: items?
         // refs in annos on foreign keys use fk name, not fk ref name:
         const dict = parent.elements ?? getCache( parent, '_keys' );
@@ -810,11 +811,9 @@ function csnRefs( csn, universalReady ) {
       if (!qcache)
         throw new CompilerAssertion( `For semantics '${ refCtx }', query not in cache at: ${ locationString(query.$location) }` );
 
-      if (semantics.dynamic === 'query') {
-        // TODO: for ON condition in expand, would need to use cached _element
-        // TODO: test and implement - Issue #11792!
+      if (semantics.dynamic === 'query')
         return resolvePath( path, qcache.elements[head], null, 'query' );
-      }
+
       for (const name in qcache.$aliases) {
         const alias = qcache.$aliases[name];
         const found = alias.elements[head];
@@ -1144,7 +1143,6 @@ function analyseCsnPath( csnPath, csn, resolve ) {
           baseEnv = resolve.expandInline( obj, baseCtx, main, query, parent, baseEnv );
         refCtx = prop;
       }
-      // TODO: for on condition in expand, also set an environment
       isName = prop;
     }
     else if (prop === 'on') {

package/lib/base/message-registry.js

@@ -89,6 +89,7 @@ const centralMessages = {
   'anno-invalid-sql-kind': { severity: 'Error', configurableFor: true  },  // @sql.prepend/append - configurable for "I know what I'm doing"
   'anno-invalid-sql-view': { severity: 'Error', configurableFor: true  },  // @sql.prepend/append - configurable for "I know what I'm doing"
   'anno-invalid-sql-view-element': { severity: 'Error', configurableFor: true },  // @sql.prepend/append - configurable for "I know what I'm doing"
+  'ext-duplicate-include': { severity: 'Warning', errorFor: [ 'v7' ] },
   'ext-undefined-action':  { severity: 'Warning' },
   'ext-undefined-art':     { severity: 'Warning' }, // for annotate statement (for CDL path root)
   'ext-undefined-def':     { severity: 'Warning' }, // for annotate statement (for CSN or CDL path cont)
@@ -100,6 +101,7 @@ const centralMessages = {
   'ext-undefined-element-sec': { severity: 'Error', configurableFor: true }, // for security-relevant…
   'ext-undefined-action-sec': { severity: 'Error', configurableFor: true }, // for security-relevant…
   'ext-undefined-param-sec': { severity: 'Error', configurableFor: true }, // … annotate statement
+  'ext-unexpected-type-property': { severity: 'Warning', errorFor: [ 'v7' ] },
   'ext-unexpected-returns': { severity: 'Warning' },
   'ext-unexpected-returns-sec': { severity: 'Error', configurableFor: true }, // … annotate statement
   'anno-unexpected-ellipsis': { severity: 'Error', configurableFor: 'deprecated' },
@@ -125,8 +127,11 @@ const centralMessages = {
   'empty-type':   { severity: 'Info' }, // only still an error in old transformers
 
   'ref-deprecated-orderby': { severity: 'Error', configurableFor: true },
-  'ref-deprecated-self-element': { severity: 'Error', configurableFor: true },
+  'ref-deprecated-self-element': { severity: 'Error', configurableFor: 'v7' },
   'ref-deprecated-variable': { severity: 'Warning' },
+  'ref-deprecated-in-extend': { severity: 'Warning' },
+  'ref-special-in-extend': { severity: 'Warning' },
+  'ref-unexpected-in-extend': { severity: 'Error' },
   'ref-invalid-type': { severity: 'Error' },
   'ref-unexpected-self': { severity: 'Error' },
   'ref-invalid-include': { severity: 'Error' },
@@ -204,6 +209,8 @@ const centralMessages = {
   // remark: a hard syntax error in new parser for `null` together with `not null`
   'syntax-duplicate-equal-clause': { severity: 'Warning' },
   'syntax-invalid-name': { severity: 'Error' },
+  'syntax-invalid-anno-struct': { severity: 'Warning', errorFor: [ 'v7' ] },
+  'syntax-invalid-nested-proj': { severity: 'Warning', errorFor: [ 'v7' ] },
   'syntax-missing-as': { severity: 'Error', configurableFor: true },
   'syntax-missing-proj-semicolon': { severity: 'Warning' },
   'syntax-unexpected-after': { severity: 'Error' },
@@ -248,6 +255,7 @@ const centralMessages = {
   'odata-unexpected-nullable-key': { severity: 'Error', configurableFor: true },
   'odata-invalid-key-type': { severity: 'Warning' },
   'odata-invalid-property-name': { severity: 'Warning' },
+  'odata-unexpected-xpr-anno': { severity: 'Error', configurableFor: true },
   'odata-anno-preproc': { severity: 'Warning' },
   'odata-anno-dict': { severity: 'Warning' },
   'odata-anno-vocref': { severity: 'Warning' },
@@ -535,6 +543,10 @@ const centralMessageTexts = {
     dot: 'Use a $(NEWCODE), not a $(CODE) after the arguments or filter on an entity',
     colon: 'Use a $(NEWCODE), not a $(CODE) between the element names in a reference',
   },
+  'syntax-invalid-anno-struct': {
+    std: 'Most CSN processors interpret a structure with property $(PROP) as expression',
+    ref: 'Most CSN processors interpret a structure with property $(PROP) as reference',
+  },
   // 'syntax-ignoring-doc-comment' (Info)
   'syntax-unexpected-reserved-word': '$(CODE) is a reserved word - write $(DELIMITED) instead if you want to use it as name',
   'syntax-invalid-text-block': 'Missing newline in text block',
@@ -710,6 +722,14 @@ const centralMessageTexts = {
     type: 'Illegal recursive type definition to $(TYPE)',
   },
   'ref-deprecated-orderby': 'Replace source element reference $(ID) by $(NEWCODE); auto-corrected',
+  'ref-deprecated-in-extend': {
+    std: 'In an extension, do not use the table alias $(ID) to refer to source elements',
+    columns: 'In an added column, do not use the table alias $(ID) to refer to source elements',
+    where: 'In an added WHERE, do not use the table alias $(ID) to refer to source elements',
+    groupBy: 'In an added GROUP BY, do not use the table alias $(ID) to refer to source elements',
+    having: 'In an added HAVING, do not use the table alias $(ID) to refer to source elements',
+    orderBy: 'In an added ORDER BY, do not use the table alias $(ID) to refer to source elements',
+  },
   'ref-missing-self-counterpart' : {
     std: 'Expected to find a matching element in $self-comparison for foreign key $(PROP) of association $(NAME)',
     unmanaged: 'Expected to find a matching element in $self-comparison for $(PROP) of association $(NAME)',
@@ -1080,6 +1100,12 @@ const centralMessageTexts = {
 
   'def-expected-structured': 'Events must either be structured or be projections',
 
+  'ext-duplicate-include': {
+    std: 'Duplicate $(NAME) through multiple includes $(SORTED_ARTS)',
+    elements: 'Duplicate element $(NAME) through multiple includes $(SORTED_ARTS)',
+    actions: 'Duplicate action or function $(NAME) through multiple includes $(SORTED_ARTS)',
+  },
+
   'duplicate-definition': {
     std: 'Duplicate definition of $(NAME)',
     absolute: 'Duplicate definition of artifact $(NAME)',
@@ -1112,7 +1138,6 @@ const centralMessageTexts = {
     'old-not-target': 'Expected element $(NAME) not to be an association, because it overrides the included element from $(ART)',
   },
 
-  'ref-expecting-$self': 'Use $(NEWCODE) instead of $(CODE) here or remove $(CODE) altogether if possible; the compiler has rewritten it to $(NEWCODE) in CSN',
   'ref-expecting-assoc': {
     std: 'Expecting path $(ELEMREF) following “EXISTS” predicate to end with association/composition',
     'with-type': 'Expecting path $(ELEMREF) following “EXISTS” predicate to end with association/composition, found $(TYPE)',
@@ -1157,6 +1182,32 @@ const centralMessageTexts = {
     join: 'Artifact $(ART) can\'t be extended with columns, because it contains a JOIN',
     union: 'Artifact $(ART) can\'t be extended with columns, because it contains a UNION',
   },
+  'extend-where': {
+    std: 'Artifact $(ART) can\'t be extended with WHERE, only simple views/projections without JOINs and UNIONs can',
+    join: 'Artifact $(ART) can\'t be extended with WHERE, because it contains a JOIN',
+    union: 'Artifact $(ART) can\'t be extended with WHERE, because it contains a UNION',
+  },
+  'extend-groupby': {
+    std: 'Artifact $(ART) can\'t be extended with GROUP BY, only simple views/projections without JOINs and UNIONs can',
+    join: 'Artifact $(ART) can\'t be extended with GROUP BY, because it contains a JOIN',
+    union: 'Artifact $(ART) can\'t be extended with GROUP BY, because it contains a UNION',
+  },
+  'extend-having': {
+    std: 'Artifact $(ART) can\'t be extended with HAVING, only simple views/projections without JOINs and UNIONs can',
+    join: 'Artifact $(ART) can\'t be extended with HAVING, because it contains a JOIN',
+    union: 'Artifact $(ART) can\'t be extended with HAVING, because it contains a UNION',
+  },
+  'extend-orderby': {
+    std: 'Artifact $(ART) can\'t be extended with ORDER BY, only simple views/projections without JOINs and UNIONs can',
+    join: 'Artifact $(ART) can\'t be extended with ORDER BY, because it contains a JOIN',
+    union: 'Artifact $(ART) can\'t be extended with ORDER BY, because it contains a UNION',
+  },
+  'extend-limit': {
+    std: 'Artifact $(ART) can\'t be extended with LIMIT, only simple views/projections without JOINs and UNIONs can',
+    join: 'Artifact $(ART) can\'t be extended with LIMIT, because it contains a JOIN',
+    union: 'Artifact $(ART) can\'t be extended with LIMIT, because it contains a UNION',
+  },
+  'ext-unexpected-sql-clause': 'Artifact $(ART) can\'t be extended with a $(KEYWORD) clause, because it already exists',
   'extend-repeated-intralayer': 'Unstable element order due to repeated extensions in same layer',
   'extend-unexpected-include': 'Can\'t extend $(META) with includes',
 
@@ -1257,11 +1308,17 @@ const centralMessageTexts = {
   },
 
   'ref-special-in-extend': {
-    std: 'In an added column, $(ID) refers to the element of the projection source $(ART), not the table alias or mixin',
+    std: 'In an extension, $(ID) refers to the element of the projection source $(ART), not the table alias or mixin',
     alias: 'In an added column, $(ID) refers to the element of the projection source $(ART), not the table alias',
     mixin: 'In an added column, $(ID) refers to the element of the projection source $(ART), not the mixin',
   },
 
+  'ref-unexpected-in-extend': {
+    std: 'Unexpected $(ID) in an extension; it matches both a source element of $(ART) and the table alias or mixin',
+    alias: 'Unexpected $(ID) in an added $(KEYWORD); it matches both a source element of $(ART) and the table alias',
+    mixin: 'Unexpected $(ID) in an added $(KEYWORD); it matches both a source element of $(ART) and the mixin',
+  },
+
   'type-managed-composition': {
     std: 'Managed compositions can\'t be used in types', // yet
     sub: 'Managed compositions can\'t be used in sub elements',
@@ -1401,6 +1458,7 @@ const centralMessageTexts = {
     xpr: 'Ignoring unexpected expression as default value',
     colitem: 'Ignoring unexpected default value for a structured or collection like parameter',
   },
+  'odata-unexpected-xpr-anno': 'Annotation $(ANNO) with expression value is not allowed for kind $(KIND)',
   // -----------------------------------------------------------------------------------
   // All odata-anno MUST have a '$(ANNO)' parameter to indicate error location
   // -----------------------------------------------------------------------------------

package/lib/base/messages.js

@@ -854,6 +854,8 @@ function value( val ) {
 const keywordRepresentations = {
   association: 'Association',
   composition: 'Composition',
+  groupby: 'group by',
+  orderby: 'order by',
 };
 function keyword( val ) {
   const v = val.toLowerCase();

package/lib/base/optionProcessor.js

@@ -53,6 +53,7 @@ optionProcessor
   .option('    --test-sort-csn')
   .option('    --doc-comment')
   .option('    --propagate-doc-comments')
+  .option('    --v7-key-propagation')
   .option('    --add-texts-language-assoc')
   .option('    --localized-without-coalesce')
   .option('    --tenant-discriminator')
@@ -156,6 +157,7 @@ optionProcessor
                             option is implicitly enabled as well.
        --doc-comment        Preserve /** */ comments at annotation positions as doc property in CSN
        --propagate-doc-comments     Propagate doc comments ('--doc-comment')
+       --v7-key-propagation         Use simplified propagation of 'key' in query entities
        --add-texts-language-assoc   In generated texts entities, add association "language"
                                     to "sap.common.Languages" if it exists
        --localized-without-coalesce Omit coalesce in localized convenience views

package/lib/base/specialOptions.js

@@ -1,6 +1,6 @@
 // Definitions for beta and deprecated options
 
-// Normal options are in ../model/optionProcessor.js (and some other files),
+// Normal options are in ../base/optionProcessor.js (and some other files),
 // unfortunately partly non-grep-able (option `fooBar` is defined via `--foo-bar`)
 
 'use strict';

package/lib/compiler/assert-consistency.js

@@ -283,7 +283,7 @@ function assertConsistency( model, stage ) {
           'quantifier', 'orderBy', 'limit', 'name', '$parens', 'kind',
           '_origin', '$contains', // TODO tmp, see TODO in getOriginRaw()
           '_parent', '_main', '_leadingQuery', '_effectiveType', '$effectiveSeqNo', // in FROM
-          '_$next', // parsing error: tableTerm with UNION on rhs.
+          '$expand', '_$next', // parsing error: tableTerm with UNION on rhs.
         ],
       },
       select: {                   // sub query
@@ -309,7 +309,7 @@ function assertConsistency( model, stage ) {
           'on', '$parens', 'cardinality',
           'kind', 'name', '_block', '_parent', '_main', '_user',
           '$tableAliases', '_combined', '_joinParent', '$joinArgsIndex',
-          '_leadingQuery', '_$next', '_deps',
+          '_leadingQuery', '_$next', '_deps', '$expand',
         ],
       },
       ref: {
@@ -329,7 +329,7 @@ function assertConsistency( model, stage ) {
           '$parens',
           'kind', 'name', '_block', '_parent', '_main', 'elements',
           '_effectiveType', '$effectiveSeqNo', '_origin', '_joinParent', '$joinArgsIndex',
-          '$duplicates', // duplicate query in FROM clause
+          '$expand', '$duplicates', // duplicate query in FROM clause
         ],
       },
       none: { optional: () => true }, // parse error
@@ -352,13 +352,13 @@ function assertConsistency( model, stage ) {
       requires: [ 'location', 'name' ],
       optional: [ '$duplicates' ],
     },
-    orderBy: { inherits: 'value', test: isArray( expression ) },
+    orderBy: { kind: [ 'extend' ], inherits: 'value', test: isArray( expression ) },
     sort: { test: locationVal( isString ), enum: [ 'asc', 'desc' ] },
     nulls: { test: locationVal( isString ), enum: [ 'first', 'last' ] },
     $orderBy: { inherits: 'orderBy' },
-    groupBy: { inherits: 'value', test: isArray( expression ) },
+    groupBy: { kind: [ 'extend' ], inherits: 'value', test: isArray( expression ) },
     $limit: { test: TODO },
-    limit: { requires: [ 'rows' ], optional: [ 'offset', 'location' ] },
+    limit: { kind: [ 'extend' ], requires: [ 'rows' ], optional: [ 'offset', 'location' ] },
     rows: { inherits: 'value' },
     offset: { inherits: 'value' },
     _combined: { test: TODO },
@@ -438,6 +438,8 @@ function assertConsistency( model, stage ) {
         'location', '$inferred', 'sort', 'nulls',
         'param', 'scope', // for dynamic parameter '?'
         'args', 'op', 'func', 'suffix',
+        // needed for groupBy extensions - TODO: outside `value`:
+        '$extended', '_block', '_outer',
         // calculated elements on-write - TODO: outside `value`
         'stored',
       ],
@@ -512,8 +514,8 @@ function assertConsistency( model, stage ) {
       test: args,
     },
     on: { kind: true, inherits: 'value', test: expression },
-    where: { inherits: 'value' },
-    having: { inherits: 'value' },
+    where: { kind: [ 'extend' ], inherits: 'value' },
+    having: { kind: [ 'extend' ], inherits: 'value' },
     op: { test: locationVal( isString ) },
     join: { test: locationVal( isString ) },
     quantifier: { test: locationVal( isString ) },
@@ -736,7 +738,7 @@ function assertConsistency( model, stage ) {
     $expand: {
       kind: true,
       // See description of `setExpandStatus()` of in `lib/compiler/utils.js`.
-      test: isOneOf( [ 'origin', 'annotate', 'target' ] ),
+      test: isOneOf( [ 'origin', 'target', 'annotate', 'extend' ] ),
     },
     $inCycle: { kind: true, test: isBoolean },
 

package/lib/compiler/base.js

@@ -3,6 +3,7 @@
 'use strict';
 
 const { CompilerAssertion } = require( '../base/error' );
+const $inferred = Symbol.for( 'cds.$inferred' );
 
 const dictKinds = {
   definitions: 'absolute',
@@ -67,7 +68,8 @@ const kindProperties = {
 
 function propExists( prop, parent ) {
   const obj = parent.returns || parent;
-  return (obj.items || obj.targetAspect || obj)[prop];
+  const members = (obj.items || obj.targetAspect || obj)[prop];
+  return members && !members[$inferred];
 }
 
 /**
@@ -90,6 +92,8 @@ function getArtifactName( art ) {
   const namePath = [];
   let parent = art._outer || art;
   while (parent._main || parent.kind === 'builtin') { // until we hit the main artifact
+    if (!parent.name)
+      return '<error>';
     if (parent.name.$inferred !== '$internal' || parent.kind === '$inline')
       namePath.push( parent );
     if (parent.kind === 'select')

package/lib/compiler/define.js

@@ -1007,7 +1007,7 @@ function define( model ) {
     }
     else if ((col.expand || col.value) &&
              !path &&           // no parse error (path without last item)
-             (insideExpand || query._parent.kind !== 'select')) { // not sub-selects
+             (insideExpand || query._parent?.kind !== 'select')) { // not sub-selects
       error( 'query-req-name',
              // TODO: message function: `query` should work directly
              [ (col.value || col).location, (query.name ? query : query._parent ) ],

package/lib/compiler/dictionaries.js

@@ -86,9 +86,8 @@ function dictAddArray( dict, name, entry, messageCallback ) {
 function dictFirst( dict ) {
   if (!dict)
     return dict;
-  for (const name in dict)
-    return dict[name];
-  return undefined;
+  const names = Object.keys( dict );
+  return names.length ? dict[names[0]] : null;
 }
 
 // Push `entry` to the array value with key `name` in the dictionary `dict`.