@sap/cds-compiler 6.7.3 → 6.9.0

package/lib/compiler/extend.js

@@ -4,14 +4,14 @@
 
 const { weakRefLocation } = require('../base/location');
 const { searchName } = require('../base/messages');
-const { isDeprecatedEnabled } = require('../base/model');
-const { dictAdd, pushToDict, dictForEach } = require('../base/dictionaries');
+const { isDeprecatedEnabled } = require('../base/specialOptions');
+const { dictAdd, pushToDict, dictForEach } = require('./dictionaries');
 const { kindProperties, dictKinds } = require('./base');
 const {
   setLink,
   setArtifactLink,
   copyExpr,
-  setExpandStatusAnnotate,
+  setExpandStatus,
   linkToOrigin,
   initItemsLinks,
   setMemberParent,
@@ -84,6 +84,8 @@ function extend( model ) {
   const includesNonShadowedFirst
     = isDeprecatedEnabled( model.options, '_includesNonShadowedFirst' );
 
+  const includeCollisions = [];
+
   forEachGeneric( model, 'definitions', tagCompositionTargets );
   dictForEach( model.$collectedExtensions, e => e._extensions.forEach( tagCompositionTargets ) );
   // remark: tagging on extensions works _before_ running extendArtifactBefore() on each artifact
@@ -174,7 +176,7 @@ function extend( model ) {
       // elements etc.  TODO: do that more specifically on the dicts (via symbol)
       // Probably better: we could use the _extensions dict prop directly in to-csn
       if (art.$inferred)
-        setExpandStatusAnnotate( art, 'annotate' );
+        setExpandStatus( art, 'annotate' );
       if (Array.isArray( art._extensions )) {
         checkExtensionsKind( art._extensions, art );
         transformArtifactExtensions( art );
@@ -258,7 +260,8 @@ function extend( model ) {
           checkReturnsExtension( ext, art );
       }
       // if (art.elements || art.enum || art.kind === 'annotate')
-      moveDictExtensions( art, extensionsMap, (art.enum ? 'enum' : 'elements'), 'elements' );
+      moveDictExtensions( art, extensionsMap,
+                          (art.enum ? 'enum' : 'elements'), false );
     }
   }
 
@@ -399,7 +402,9 @@ function extend( model ) {
           pushTo$add( dict, ext );
         }
         else if (prop.charAt(0) === '@' || prop === 'doc' || prop === 'columns' ||
-            prop === 'length' || prop === 'scale' || prop === 'precision' || prop === 'srid') {
+                 prop === 'groupBy' || prop === 'where' || prop === 'having' ||
+                 prop === 'orderBy' || prop === 'limit' || prop === 'length' ||
+                 prop === 'scale' || prop === 'precision' || prop === 'srid') {
           if (!isAutoItemsOrReturns)
             pushToDict( dict, prop, ext );
         }
@@ -577,7 +582,7 @@ function extend( model ) {
     else if (prop === 'columns') {
       const { query } = art;
       for (const col of ext.columns)
-        col.$extended = true;
+        col.$extended = 'columns';
 
       if (art.kind === 'annotate' && art.$inferred === '')
         return; // internal super-annotate for unknown artifacts
@@ -593,6 +598,10 @@ function extend( model ) {
         query.columns.push( ...ext.columns );
       ext.columns.forEach( col => changeParentLinks( col, query ) );
     }
+    else if (prop === 'groupBy' || prop === 'where' || prop === 'having' ||
+             prop === 'orderBy' || prop === 'limit') {
+      applyQueryClause( prop, ext, art );
+    }
     else if (typeParameters.list.includes( prop )) {
       const typeExts = art.$typeExts || (art.$typeExts = {});
       typeExts[prop] = ext;
@@ -603,6 +612,39 @@ function extend( model ) {
     }
   }
 
+  function applyQueryClause( prop, ext, art ) {
+    const { query } = art;
+    const clause = ext[prop];
+    const isArray = Array.isArray( clause );
+
+    if (prop !== 'limit') {
+      const items = isArray ? clause : [ clause ];
+      for (const item of items) {
+        item.$extended = prop;
+        setLink( item, '_block', ext._block );
+        setLink( item, '_outer', query );
+      }
+    }
+    if (!query?.from?.path) {
+      const variant = (query?.from || query)?.op?.val || 'std';
+      const loc = isArray ? clause[$location] : clause.location;
+      error( `extend-${ prop.toLowerCase() }`, [ loc, ext ], { '#': variant, art } );
+      return;
+    }
+    if (isArray) {
+      if (!query[prop])
+        query[prop] = [];
+      query[prop].push( ...clause );
+    }
+    else {
+      if (query[prop]) {
+        error( 'ext-unexpected-sql-clause', [ clause.location, ext ], { art, keyword: prop } );
+        return;
+      }
+      query[prop] = clause;
+    }
+  }
+
   function changeParentLinks( art, queryOrMain ) {
     // TODO: we might also change the implicit name (if name.id is a number,
     // adding the previous column lenght - 1) for better error messages
@@ -838,18 +880,18 @@ function extend( model ) {
   }
 
   function moveDictExtensions( art, extensionsMap, artProp, extProp = artProp ) {
-    // TODO: setExpandStatusAnnotate
-    const extensions = extensionsMap[extProp];
+    // TODO: setExpandStatus
+    const extensions = extensionsMap[extProp || 'elements'];
     if (!extensions)
       return;
 
     for (const ext of extensions) {
       let dictCheck = (art.kind !== 'annotate'); // no check in super annotate statement
-      forEachGeneric( ext, extProp, ( elemExt, name ) => {
+      forEachGeneric( ext, extProp || (ext.enum ? 'enum' : 'elements'), ( elemExt, name ) => {
         if (elemExt.kind !== 'annotate' && elemExt.kind !== 'extend') // TODO: specified elems
           return;             // definitions inside extend, already handled
         dictCheck = dictCheck && checkRemainingMemberExtensions( art, elemExt, artProp, name );
-        const elem = art[artProp]?.[name] || annotateFor( art, extProp, name );
+        const elem = art[artProp]?.[name] || annotateFor( art, extProp || 'elements', name );
         setLink( elemExt.name, '_artifact', (elem.kind !== 'annotate' ? elem : null ) );
         // TODO: why null for annotate?
         ensureArtifactNotProcessed( elem );
@@ -1055,11 +1097,23 @@ function extend( model ) {
 
   function checkRemainingMainExtensions( art, ext ) {
     const refCtx = extensionRefContext( ext );
-    if (!resolvePath( ext.name, refCtx, ext )) // error for extend, info for annotate
-      return;
-
-    if (art?.builtin) {                                       // TODO: do via accept
-      info( 'anno-builtin', [ ext.name.location, ext ], {} ); // TODO: better location?
+    if (resolvePath( ext.name, refCtx, ext ) && art?.builtin) {
+      if (ext.kind === 'extend') {
+        // extending built-ins with elements/enums already gives an error
+        warning( 'ext-unexpected-builtin', [ ext.name.location, ext ], {}, // error v8?
+                 'Built-in types should not be extended' ); // keep the text general
+        const typeProp = typeParameters.list.find( p => ext[p] );
+        if (typeProp) {
+          const location = ext.$typeArgs?.[$location] || ext[typeProp].location;
+          message( 'ext-unexpected-type-property', [ location, ext ], {}, // error v7
+                   'Built-in types can\'t be extended with type properties' );
+          // see also 'ext-invalid-type-property'
+        }
+      }
+      else {
+        info( 'anno-builtin', [ ext.name.location, ext ], {} ); // TODO: better location?
+      }
+      // TODO: remove built-ins as CC candidates via accept property of ./shared.js
     }
   }
 
@@ -1142,10 +1196,33 @@ function extend( model ) {
     // TODO: complain if $inferred
     // checkExtensionsKind( extensions, art );
     extendMembers( extensions, art );
+    reportIncludeCollisions( art );
     // TODO: complain about element extensions inside projection
     return true;
   }
 
+  function reportIncludeCollisions( art ) {
+    const grouped = Object.create( null );
+    for (const {
+      prop, name, existing, elem,
+    } of includeCollisions) {
+      const key = `${ prop }:${ name }`;
+      if (!grouped[key])
+        grouped[key] = { prop, name, collisions: new Set( [ existing ] ) };
+      grouped[key].collisions.add( elem );
+    }
+    for (const key in grouped) {
+      const { prop, name, collisions } = grouped[key];
+      const member = art[prop]?.[name];
+      if (member?.$inferred === 'include') {
+        const arts = [ ...collisions ].map( m => m._origin._main );
+        message( 'ext-duplicate-include', [ art.name.location, member ],
+                 { '#': prop, name, sorted_arts: arts } );
+      }
+    }
+    includeCollisions.length = 0;
+  }
+
   function extendMembers( extensions, art ) {
     // TODO: do the whole extension stuff lazily if the elements are requested
     const elemExtensions = [];
@@ -1154,7 +1231,11 @@ function extend( model ) {
     // TODO: use same sequence as in chooseAssignment() - better: use common code with that fn
     // console.log('EM:',art.name,extensions,art._extensions)
     for (const ext of extensions) { // those in extMap.includes
-      if (art.$inferred) {
+      if (art.$inferred === 'include') {
+        error( 'ref-expected-direct-structure', [ ext.name.location, ext ],
+               { '#': 'elements', art } );
+      }
+      else if (art.$inferred) {
         error( 'extend-for-generated', [ ext.name.location, ext ], { art, keyword: 'extend' },
                'You can\'t use $(KEYWORD) on the generated $(ART)' ); // or with inferred elements
       }
@@ -1298,6 +1379,8 @@ function extend( model ) {
 
     if (obj !== parent && obj.elements && parent.enum) { // applying the extension
       initElementsAsEnum();
+      if (parent.enum[$inferred])
+        setExpandStatus( parent, 'extend' );
     }
     else {
       if (checkDefinitions( construct, parent, 'elements', obj.elements || false ))
@@ -1341,7 +1424,11 @@ function extend( model ) {
         e.kind = 'enum';
         hasElement = true;    // warning with CDL input or `name: {}` in CSN input
       }
-      if (hasElement) {
+      if (!parent.type || parent.type.$inferred || (parent._main || parent).query) {
+        error( 'extend-type', [ obj.elements[$location], construct ], {},
+               'Only structures or enum types can be extended with elements/enums' );
+      }
+      else if (hasElement) {
         warning( 'ext-expecting-enum', [ obj.elements[$location], construct ],
                  { code: 'extend … with enum' }, 'Use $(CODE) when extending enums' );
       }
@@ -1404,13 +1491,18 @@ function extend( model ) {
 
       if (isQueryExtension && elem.kind === 'element') {
         error( 'extend-query', [ elem.location, construct ], // TODO: searchName ?
-               { code: 'extend projection' },
+               { code: 'extend … with columns' },
                'Use $(CODE) to add select items to the query entity' );
         return;
       }
 
       const existing = parent[prop]?.[name];
       const add = construct !== parent && (!existing || elem.$inferred !== 'include');
+      if (!add && existing?.$inferred === 'include' && elem.$inferred === 'include') {
+        includeCollisions.push( {
+          prop, name, existing, elem,
+        } );
+      }
       // don't dump with `entity T {}; extend T with { extend e {}; e {}; e {} };`:
       const { $duplicates } = elem;
       if ($duplicates === true && add)
@@ -1424,6 +1516,9 @@ function extend( model ) {
 
       // for a correct home path, setMemberParent needed to be called
 
+      if (parent[prop]?.[$inferred])
+        setExpandStatus( parent, 'extend' );
+
       if (!elem.value || elem.kind !== 'element')
         return;
       // remark: potential enum elements have already been turned into enums
@@ -1502,10 +1597,14 @@ function extend( model ) {
         error( 'ref-expected-direct-structure', [ location, construct ],
                { '#': variant, art: parent } );
       }
-      else {
+      else if (prop !== 'enum' || !parent.enum ||
+               !parent.type || parent.type.$inferred || (parent._main || parent).query) {
         error( 'extend-type', [ location, construct ], {},
                'Only structures or enum types can be extended with elements/enums' );
       }
+      else {
+        return true;
+      }
     }
     else if (prop === 'elements') {
       error( 'def-unexpected-elements', [ location, construct ], {},
@@ -1585,6 +1684,7 @@ function extend( model ) {
     // TODO two kind of messages:
     // Error 'More than one include defines element "A"' (at include ref)
     // Warning 'Overwrites definition from include "I" (at elem def)
+    const propagateKeys = art.kind !== 'type' || !model.options.v7KeyPropagation;
     const parent = ext === art && art;
     const members = ext[prop];
     // if (members)console.log( 'EXT:', prop, art.kind, art.name.id, ...Object.keys(members));
@@ -1624,7 +1724,7 @@ function extend( model ) {
           elem.$inferred = 'include';
           if (origin.masked)    // TODO(v6): remove 'masked'
             elem.masked = Object.assign( { $inferred: 'include' }, origin.masked );
-          if (origin.key)
+          if (origin.key && propagateKeys)
             elem.key = Object.assign( { $inferred: 'include' }, origin.key );
           if (origin.value && origin.$syntax === 'calc') {
             // TODO: If paths become invalid in the new artifact, should we mark

package/lib/compiler/generate.js

@@ -4,8 +4,8 @@
 
 /* eslint-disable no-nested-ternary */
 
-const { isDeprecatedEnabled } = require('../base/model');
-const { dictAdd } = require('../base/dictionaries');
+const { isDeprecatedEnabled } = require('../base/specialOptions');
+const { dictAdd } = require('./dictionaries');
 const {
   setLink,
   setArtifactLink,

package/lib/compiler/index.js

@@ -32,8 +32,8 @@ const check = require('./checks');
 
 const { Location, emptyWeakLocation } = require('../base/location');
 const { createMessageFunctions, deduplicateMessages } = require('../base/messages');
-const { checkRemovedDeprecatedFlags } = require('../base/model');
-const { promiseAllDoNotRejectImmediately } = require('../base/node-helpers');
+const { checkRemovedDeprecatedFlags } = require('../base/specialOptions');
+const { promiseAllDoNotRejectImmediately } = require('../utils/node-helpers');
 const { cdsFs, fileExtension } = require('../utils/file');
 
 const fs = require('fs');
@@ -504,6 +504,8 @@ function compileDoXSync( model ) {
   // TODO: think about making this work
 
   resolve( model );
+  if (options.$cdsReplSupport)
+    return model;
   tweakAssocs( model );
   assertConsistency( model );
   check( model );
@@ -554,9 +556,15 @@ async function compileDoX( model ) {
 
   model.definitions = model.$functions.shuffleDict( model.definitions );
   // Shuffling extensions is more difficult due to intra-file extensions of same artifact
+  // TODO: shuffle _before_ populate()
   // TODO: think about making this work
 
-  for (const phase of [ resolve, tweakAssocs, assertConsistency, check ]) {
+  resolve( model );
+  if (options.$cdsReplSupport)
+    return model;
+  await checkAsyncAbortFlag( options.abortSignal );
+
+  for (const phase of [ tweakAssocs, assertConsistency, check ]) {
     phase( model );
     // eslint-disable-next-line no-await-in-loop
     await checkAsyncAbortFlag( options.abortSignal );

package/lib/compiler/kick-start.js

@@ -4,7 +4,7 @@
 
 'use strict';
 
-const { isBetaEnabled } = require('../base/model');
+const { isBetaEnabled } = require('../base/specialOptions');
 const {
   setLink,
   annotationVal,

package/lib/compiler/lsp-api.js

@@ -7,7 +7,7 @@
 //
 // This files includes an iterator over "semantic tokens" in an XSN model.
 // "Semantic tokens" are identifiers, but also the "return" parameter.
-// See <../../internalDoc/lsp/IdentifierCrawling.md> for details.
+// See <../../internalDoc/lsp/SemanticTokenCrawling.md> for details.
 
 const { CompilerAssertion } = require('../base/error');
 const $inferred = Symbol.for( 'cds.$inferred' );
@@ -190,7 +190,7 @@ function* artifactTokens( art ) {
  * @returns {Generator<LspSemanticTokenEvent>}
  */
 function* extensionTokens( ext ) {
-  if (ext.kind !== 'extend' && ext.kind !== 'annotate')
+  if (ext.kind !== 'extend' && ext.kind !== 'annotate' || !ext.name)
     return null;
 
   const wasApplied = ext.name._artifact && !ext.name._artifact.$inferred;
@@ -203,7 +203,7 @@ function* extensionTokens( ext ) {
 
   // We need to traverse all dictionaries that could themselves contain
   // extensions.  Enum extensions or columns don't need to be traversed,
-  // for example, because there can't be inner extensions.
+  // for example, because there can't be inner extensions.  TODO: still?
   yield* dictOf( extensionTokens )( ext.params );
   yield* dictOf( extensionTokens )( ext.actions );
   yield* dictOf( extensionTokens )( ext.elements );

package/lib/compiler/populate.js

@@ -17,10 +17,10 @@
 
 'use strict';
 
-const { isDeprecatedEnabled } = require('../base/model');
+const { isDeprecatedEnabled } = require('../base/specialOptions');
 const {
   dictAdd, dictAddArray, dictFirst, dictForEach,
-} = require('../base/dictionaries');
+} = require('./dictionaries');
 const { weakLocation, weakRefLocation } = require('../base/location');
 const { CompilerAssertion } = require('../base/error');
 
@@ -36,7 +36,6 @@ const {
   dependsOn,
   proxyCopyMembers,
   setExpandStatus,
-  setExpandStatusAnnotate,
   dependsOnSilent,
   columnRefStartsWithSelf,
   forEachDefinition,
@@ -218,8 +217,8 @@ function populate( model ) {
       populateGeneratedEntity( a );
       if (a.includes)
         a.includes.forEach( i => resolveInclude( i, a ) );
-      extendArtifactAdd( a );
       art = populateArtifact( a, art ) || a;
+      extendArtifactAdd( a );
       setLink( a, '_effectiveType', art );
       a.$effectiveSeqNo = ++effectiveSeqNo;
       // console.log('PE:',require('../model/revealInternalProperties').ref(a))
@@ -614,7 +613,7 @@ function populate( model ) {
     }
 
     if (wasAnnotated)
-      setExpandStatusAnnotate( art, 'annotate' );
+      setExpandStatus( art, 'annotate' );
 
     // TODO: We don't check enum$, yet! We first need to fix expansion for
     //       `cast(elem as EnumType)` (see #9421)
@@ -668,7 +667,7 @@ function populate( model ) {
       }
     }
     if (wasAnnotated)
-      setExpandStatusAnnotate( art, 'annotate' );
+      setExpandStatus( art, 'annotate' );
 
     for (const id in art.foreignKeys$) {
       const specifiedElement = art.foreignKeys$[id];
@@ -767,7 +766,7 @@ 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] };
+      elem.items = { location: elem.expand[$location], $inferred: 'query' };
       setLink( elem.items, '_outer', elem );
     }
     return initFromColumns( elem, elem.expand );

package/lib/compiler/resolve.js

@@ -38,8 +38,8 @@
 
 'use strict';
 
-const { isDeprecatedEnabled } = require('../base/model');
-const { dictAdd } = require('../base/dictionaries');
+const { isDeprecatedEnabled } = require('../base/specialOptions');
+const { dictAdd, pushToDict } = require('./dictionaries');
 const { weakLocation } = require('../base/location');
 const { combinedLocation } = require('../base/location');
 const { typeParameters } = require('./builtins');
@@ -285,9 +285,9 @@ function resolve( model ) {
       // we don't propagate keys to type projections, see #13575
       return;
     }
-    // Second argument true ensure that `key` is only propagated along simple
+    // Second argument controls whether `key` is only propagated along simple
     // view, i.e. ref or subquery in FROM, not UNION or JOIN.
-    traverseQueryPost( view.query, true, ( query ) => {
+    traverseQueryPost( view.query, !options.v7KeyPropagation, ( query ) => {
       if (!withExplicitKeys( query ) && inheritKeyProp( query ) &&
           withKeyPropagation( query )) // now the part with messages
         inheritKeyProp( query, true );
@@ -331,47 +331,47 @@ function resolve( model ) {
     return head?.kind === '$tableAlias' && item._artifact?.key;
   }
 
-  function primarySourceNavigation( aliases ) {
-    for (const name in aliases)
-      return aliases[name].elements;
-    return undefined;
-  }
-
   function withKeyPropagation( query ) {
-    const { from } = query;
+    const { from, $tableAliases } = query;
     if (!from)                  // parse error SELECT FROM <EOF>
       return false;
-
     let propagateKeys = true;   // used instead early RETURN to get more messages
-    const toMany = withAssociation( from, targetMaxNotOne, true );
-    if (toMany) {
-      propagateKeys = false;
-      info( 'query-from-many', [ toMany.location, query ], { art: toMany }, {
-        std: 'Key properties are not propagated because a to-many association $(ART) is selected',
-        // eslint-disable-next-line @stylistic/max-len
-        element: 'Key properties are not propagated because a to-many association $(MEMBER) of $(ART) is selected',
-      } );
-    }
+
     // Check that all keys from the source are projected:
-    const notProjected = [];    // we actually push to the array
-    const navElems = primarySourceNavigation( query.$tableAliases );
+    const notProjected = Object.create( null );
+    const navElems = query._combined;
     for (const name in navElems) {
       const nav = navElems[name];
-      if (nav.$duplicates)
-        continue;
-      const { key } = nav._origin;
-      if (key?.val && !nav._projections?.length)
-        notProjected.push( nav.name.id );
+      if (Array.isArray( nav ))
+        nav.forEach( pushNonProjected );
+      else
+        pushNonProjected( nav );
     }
-    if (notProjected.length) {
+    for (const [ alias, names ] of Object.entries( notProjected )) {
       propagateKeys = false;
-      info( 'query-missing-keys', [ from.location, query ], { names: notProjected },
+      // TODO: mention alias
+      const location = $tableAliases[alias].name?.location || from.location;
+      info( 'query-missing-keys', [ location, query ], { names },
             {
               std: 'Keys $(NAMES) have not been projected - key properties are not propagated',
               one: 'Key $(NAMES) has not been projected - key properties are not propagated',
             } );
     }
-    // Check that there is no to-many assoc used in select item:
+    if (options.v7KeyPropagation)
+      return propagateKeys;
+
+    // Check that there is no to-many assoc in the FROM reference or in the select
+    // item reference (references in expressions are not checked,
+    // withAssociation() will see no _artifact links anyway)
+    const toMany = withAssociation( from, targetMaxNotOne, true );
+    if (toMany) {
+      propagateKeys = false;
+      info( 'query-from-many', [ toMany.location, query ], { art: toMany }, {
+        std: 'Key properties are not propagated because a to-many association $(ART) is selected',
+        // eslint-disable-next-line @stylistic/max-len
+        element: 'Key properties are not propagated because a to-many association $(MEMBER) of $(ART) is selected',
+      } );
+    }
     for (const name in query.elements) {
       const elem = query.elements[name];
 
@@ -383,6 +383,14 @@ function resolve( model ) {
     }
     return propagateKeys;
 
+    function pushNonProjected( nav ) {
+      if (nav.$duplicates)
+        return;
+      const { key } = nav._origin;
+      if (key?.val && !nav._projections?.length)
+        pushToDict( notProjected, nav._parent.name.id, nav.name.id );
+    }
+
     function selectTest( expr, user ) {
       const art = withAssociation( expr, targetMaxNotOne );
       if (art) {
@@ -1004,11 +1012,16 @@ function resolve( model ) {
       forEachGeneric( query, 'elements', resolveRefs );
     if (query.from)
       resolveJoinOn( query.from );
-    if (query.where)
-      resolveExpr( query.where, 'where', query );
+    if (query.where) {
+      const user = query.where._block ? query.where : query;
+      resolveExpr( query.where, 'where', user );
+    }
     if (query.groupBy)
       resolveBy( query.groupBy, 'groupBy', 'groupBy' );
-    resolveExpr( query.having, 'having', query );
+    if (query.having) {
+      const user = query.having._block ? query.having : query;
+      resolveExpr( query.having, 'having', user );
+    }
     if (query.$orderBy)       // ORDER BY from UNION:
       // TODO clarify: can I access the tab alias of outer queries?  If not:
       // 4th arg query._main instead query._parent.
@@ -1051,8 +1064,10 @@ function resolve( model ) {
      */
     function resolveBy( array, refMode, exprMode ) {
       for (const value of array ) {
-        if (value)
-          resolveExpr( value, (value.path ? refMode : exprMode), query );
+        if (value) {
+          const user = value._block ? value : query;
+          resolveExpr( value, (value.path ? refMode : exprMode), user );
+        }
       }
     }
 
@@ -1566,6 +1581,8 @@ function resolve( model ) {
       // No traversal into query, art.$queries set in define.js
       // No subqueries for type projections, nor in annotation expressions.
       const { query } = expr;
+      if (!query.from && !query.args) // parser error
+        return type;                  // ...see also TODO in initQueryExpression()
       if (query._main?.kind === 'type' ||
          (!query.kind && !query._leadingQuery)) { // UNION has _leadingQuery
         error( 'expr-no-subquery', [ expr.location, user ], {