@sap/cds-compiler 4.0.2 → 4.2.2

package/lib/compiler/extend.js

@@ -23,10 +23,12 @@ const {
 } = require('./utils');
 const layers = require('./moduleLayers');
 const { CompilerAssertion } = require('../base/error');
+const { CsnLocation } = require('./classes');
 
-const $location = Symbol.for('cds.$location');
+const $location = Symbol.for( 'cds.$location' );
 
-const genLocation = { file: '' }; // attach stupid location - TODO: remove in v4
+// attach stupid location - TODO: remove in v5
+const genLocation = new CsnLocation( '' );
 
 // Array.prototype.spread = 42;   // prototype-polluted JS classes
 
@@ -41,6 +43,7 @@ function extend( model ) {
     resolveTypeArgumentsUnchecked,
     attachAndEmitValidNames,
     initMembers,
+    initSelectItems,
   } = model.$functions;
 
   Object.assign( model.$functions, {
@@ -50,10 +53,10 @@ function extend( model ) {
     applyIncludes,              // TODO: re-check
   } );
 
-  const includesNonShadowedFirst = isDeprecatedEnabled(model.options, 'includesNonShadowedFirst');
+  const includesNonShadowedFirst = isDeprecatedEnabled( model.options, 'includesNonShadowedFirst' );
 
   sortModelSources();
-  const extensionsDict = Object.create(null); // TODO TMP
+  const extensionsDict = Object.create( null ); // TODO TMP
   forEachDefinition( model, tagIncludes ); // TODO TMP
 
   forEachDefinition( model, extendArtifactBefore );
@@ -131,46 +134,32 @@ function extend( model ) {
       delete art.$typeExts;
     }
 
-    if (art.kind === 'annotate' && !art.returns && extensionsMap.returns)
+    if (art.kind === 'annotate' && !art.returns && extensionsMap.returns && !art._parent?.returns)
       annotateCreate( art, '', art, 'returns' );
 
+    moveDictExtensions( art, extensionsMap, 'actions' );
     moveDictExtensions( art, extensionsMap, 'params' );
     moveReturnsExtensions( art, extensionsMap );
-    const sub = art.returns || art.items || art.targetAspect?.elements && art.targetAspect;
-    if (sub) {
-      if (art.returns) {        // after having applied params!
+
+    if (art.returns) {
+      pushToDict( art.returns, '_extensions', ...extensionsMap.elements || [] );
+      pushToDict( art.returns, '_extensions', ...extensionsMap.enum || [] );
+      if (art.kind !== 'annotate') {
         extendHandleReturns( extensionsMap.elements, art );
         extendHandleReturns( extensionsMap.enum, art );
+        return;
       }
-      // care about 'ext-unexpected-returns' in a later change if we have XSN returns
-      pushToDict( sub, '_extensions', ...avoidRecursiveReturns(extensionsMap, 'elements'));
-      pushToDict( sub, '_extensions', ...avoidRecursiveReturns(extensionsMap, 'enum') );
+    }
+    const sub = art.items || art.targetAspect?.elements && art.targetAspect;
+    if (sub) {
+      pushToDict( sub, '_extensions', ...extensionsMap.elements || [] );
+      pushToDict( sub, '_extensions', ...extensionsMap.enum || [] );
     }
     else {
       moveDictExtensions( art, extensionsMap,
                           (art.enum && art.kind !== 'annotate' ? 'enum' : 'elements'), 'elements' );
       moveDictExtensions( art, extensionsMap, 'enum' );
     }
-    moveDictExtensions( art, extensionsMap, 'actions' );
-  }
-
-  /**
-   * FIXME: Remove this workaround. This workaround avoids endless recursion for annotate statements
-   *        that have both "returns" and "elements".  The endless recursion happens due to the
-   *        pushDict on `sub`.  The `elements` extensions will point to the same extension on which
-   *        `returns` exist.
-   *
-   * @param extensionsMap
-   * @param {string} prop
-   * @return {XSN.Extension[]}
-   */
-  function avoidRecursiveReturns( extensionsMap, prop ) {
-    if (!extensionsMap[prop])
-      return [];
-    const exts = [];
-    for (const ext of extensionsMap[prop])
-      exts.push({ ...ext, returns: undefined });
-    return exts;
   }
 
   /**
@@ -221,7 +210,7 @@ function extend( model ) {
             annotate: 'There is no artifact $(ART), use $(CODE) instead',
             // do not mention 'extend context', that is not in CAPire
             service: 'Artifact $(ART) is not of kind $(KIND), use $(CODE) or $(KEYWORD) instead',
-          });
+          } );
         }
         // TODO: Use similar checks for EXTEND ENTITY etc - 'ext-ignoring-kind'
       }
@@ -231,7 +220,7 @@ function extend( model ) {
   // TODO: if extensions has more than one of returns,items,elements,enum, delete all those props
   function transformArtifactExtensions( art ) {
     const hasOnlySubExtensions = art._outer; // items, anonymous aspects
-    const dict = Object.create(null);
+    const dict = Object.create( null );
     for (const ext of art._extensions) {
       for (const prop in ext) {
         if (ext[prop] === undefined) // deleted property
@@ -383,12 +372,16 @@ function extend( model ) {
       const { query } = art;
       for (const col of ext.columns)
         col.$extended = true;
-      if (!query?.from?.path)
+
+      if (!query?.from?.path) {
         error( 'extend-columns', [ ext.columns[$location], ext ], { art } );
-      else if (!query.columns)
+        return;
+      }
+      if (!query.columns)
         query.columns = [ { location: query.from.location, val: '*' }, ...ext.columns ];
       else
         query.columns.push( ...ext.columns );
+      initSelectItems( query, ext.columns, query, true );
     }
     else if ([ 'length', 'precision', 'scale', 'srid' ].includes( prop )) {
       const typeExts = art.$typeExts || (art.$typeExts = {});
@@ -428,7 +421,7 @@ function extend( model ) {
         while (prevPos < previousValue.length) {
           const prevItem = previousValue[prevPos++];
           result.push( prevItem );
-          if (upToSpec && prevItem && equalUpTo( prevItem, item.upTo)) {
+          if (upToSpec && prevItem && equalUpTo( prevItem, item.upTo )) {
             upToSpec = false;
             break;
           }
@@ -599,32 +592,41 @@ function extend( model ) {
           continue;             // definitions inside extend, already handled
         dictCheck = dictCheck && checkRemainingMemberExtensions( art, elemExt, artProp, name );
         const elem = artDict[name] || annotateFor( art, extProp, name );
-        setLink( elemExt.name, '_artifact', (elem.kind !== 'annotate' ? elem : null) );
+        setLink( elemExt.name, '_artifact', (elem.kind !== 'annotate' ? elem : null ) );
         pushToDict( elem, '_extensions', elemExt );
       }
     }
   }
 
   function moveReturnsExtensions( art, extensionsMap ) {
-    if (!extensionsMap.returns)
+    const extensions = extensionsMap.returns;
+    if (!extensions)
       return;
+    const artReturns = art.returns;
+    let extReturns = artReturns;
+    const isAction = art.kind === 'action' || art.kind === 'function';
 
-    for (const ext of extensionsMap.returns) {
-      if (!art.returns && art.kind !== 'annotate') { // no check in super annotate statement
-        const variant = art.kind === 'action' || art.kind === 'function' ? art.kind : 'std';
+    for (const ext of extensions) {
+      if (!artReturns && art.kind !== 'annotate') {
         warning( 'ext-unexpected-returns', [ ext.returns.location, ext ], {
-          '#': variant, keyword: 'returns',
+          '#': (isAction ? art.kind : 'std'), keyword: 'returns',
         }, {
           std: 'Unexpected $(KEYWORD); only actions and functions have return parameters',
           action: 'Unexpected $(KEYWORD) for action without return parameter',
           // function without `returns` can happen via CSN input!
           function: 'Unexpected $(KEYWORD) for function without return parameter',
-        });
+        } );
+        // Do not put completely wrong returns into a “super annotate” statement;
+        // this could induce consequential errors with [..., …]:
+        if (!isAction)
+          continue;             // do not put into 'extensions'
+        // add to 'extensions' for action/function without returns:
+        extReturns ??= annotateFor( art, 'params', '' );
+      }
+      if (extReturns) {
+        setLink( ext.name, '_artifact', (isAction ? artReturns : null ) );
+        pushToDict( extReturns, '_extensions', ext.returns );
       }
-      // If `!art.returns`, then it could be CSN from SQL, where actions are replaced by dummies.
-      const elem = art.returns || annotateFor( art, 'params', '' );
-      setLink( ext.name, '_artifact', (elem.kind !== 'annotate' ? elem : null) );
-      pushToDict(elem, '_extensions', ext.returns);
     }
   }
 
@@ -713,12 +715,17 @@ function extend( model ) {
                    { '#': (parent._effectiveType?.kind === 'entity') ? 'entity' : 'std' }, {
                      std: 'Elements only exist in entities, types or typed constructs',
                      entity: 'Elements of entity types can\'t be annotated',
-                   });
+                   } );
           break;
         case 'params':
           warning( 'anno-unexpected-params', [ location, ext._parent ], {},
                    'Parameters only exist for actions or functions' );
           break;
+        case 'actions':
+          // TODO: check if artifact can have actions, similar to `anno-unexpected-actions`
+          notFound( 'anno-undefined-action', ext.name.location, ext,
+                    { '#': 'action', art: parent, name } );
+          break;
         default:
           if (model.options.testMode)
             throw new CompilerAssertion(`Missing case for prop: ${ prop }`);
@@ -796,8 +803,6 @@ function extend( model ) {
       return;
     if (!resolvePath( ext.name, ext.kind, ext )) // error for extend, info for annotate
       return;
-    // else if (ext.kind === 'extend') { // TODO v4 - add error
-    // }
     if (art?.kind === 'namespace') {
       // TODO: not at all different to having no definition
       info( 'anno-namespace', [ ext.name.location, ext ], {}, // TODO: better location?
@@ -822,13 +827,13 @@ function extend( model ) {
       }
       else if (!construct.returns &&
           (art.kind === 'action' || art.kind === 'function') && construct.elements) {
-        warning('ext-expecting-returns', [ construct.name.location, construct ], {
+        warning( 'ext-expecting-returns', [ construct.name.location, construct ], {
           '#': art.kind, keyword: 'returns', code: 'annotate ‹name› with returns { … }',
         }, {
           std: 'Expected $(CODE)', // unused variant
           action: 'Expected $(KEYWORD) when annotating action return structure, i.e. $(CODE)',
           function: 'Expected $(KEYWORD) when annotating function return structure, i.e. $(CODE)',
-        });
+        } );
       }
     }
   }
@@ -871,7 +876,7 @@ function extend( model ) {
    */
   function extendArtifact( extensions, art, noIncludes = false ) {
     if (!noIncludes && !(canApplyIncludes( art, art ) &&
-        extensions.every( ext => canApplyIncludes(ext, art) )))
+        extensions.every( ext => canApplyIncludes( ext, art ) )))
       return false;
     if (Array.isArray( noIncludes )) {
       canApplyIncludes( art, art, noIncludes );
@@ -879,7 +884,7 @@ function extend( model ) {
     }
     else if (!noIncludes &&
              !(canApplyIncludes( art, art ) &&
-               extensions.every( ext => canApplyIncludes( ext, art) ))) {
+               extensions.every( ext => canApplyIncludes( ext, art ) ))) {
       // console.log( 'FALSE:',art.name, extensions.map( e => e.name ) )
       return false;
     }
@@ -887,8 +892,15 @@ function extend( model ) {
       model._entities.push( art ); // add structure with includes in dep order
       art.$entity = ++model.$entity;
     }
-    if (!noIncludes && art.includes)
-      applyIncludes( art, art );
+    if (art.includes) {
+      if (!noIncludes) {
+        applyIncludes( art, art );
+      }
+      else {
+        for (const ref of art.includes)
+          resolvePath( ref, 'include', art );
+      }
+    }
     // checkExtensionsKind( extensions, art );
     extendMembers( extensions, art, noIncludes === 'gen' );
     if (!noIncludes && art.includes) {
@@ -923,7 +935,7 @@ function extend( model ) {
           //    includes = ['Base1',3,'Base2']
           // where 3 means adding the next 3 elements before applying include 'Base2'
           if (art.includes)
-            art.includes.push(...ext.includes);
+            art.includes.push( ...ext.includes );
           else
             art.includes = [ ...ext.includes ];
           applyIncludes( ext, art );
@@ -932,7 +944,7 @@ function extend( model ) {
         checkAnnotate( ext, art );
         // TODO: do we allow to add elements with array of {...}?  If yes, adapt
         initMembers( ext, art, ext._block ); // might set _extend, _annotate
-        dependsOnSilent(art, ext); // art depends silently on ext (inverse to normal dep!)
+        dependsOnSilent( art, ext ); // art depends silently on ext (inverse to normal dep!)
       }
       for (const name in ext.elements) {
         const elem = ext.elements[name];
@@ -946,7 +958,7 @@ function extend( model ) {
       reportUnstableExtensions( elemExtensions );
 
     // This whole function will be removed with a next change - no need to have nice code here:
-    const dict = Object.create(null);
+    const dict = Object.create( null );
     // actions cannot be extended anyway. TODO: there should be a message
     // (possible with CSN input), but that was missing before this change, too.
     for (const e of extensions) {
@@ -988,7 +1000,8 @@ function extend( model ) {
     let lastExt = null;
     let open = [];              // the "highest" layers
     for (const ext of extensions) {
-      const extLayer = layers.layer( ext ) || { realname: '', _layerExtends: Object.create(null) };
+      const extLayer = layers.layer( ext ) ||
+          { realname: '', _layerExtends: Object.create( null ) };
       if (!open.length) {
         lastExt = ext;
         open = [ extLayer.realname ];
@@ -1036,7 +1049,7 @@ function extend( model ) {
                    element: 'Artifact $(ART) has no element or enum $(MEMBER) - nothing to extend',
                    action: 'Artifact $(ART) has no action $(MEMBER) - nothing to extend',
                  } );
-      attachAndEmitValidNames(msg, validDict);
+      attachAndEmitValidNames( msg, validDict );
     }
   }
 
@@ -1055,7 +1068,6 @@ function extend( model ) {
   function canApplyIncludes( art, target, justResolveCyclic ) {
     if (!art.includes)
       return true;
-    const isView = !!target.query;
     for (const ref of art.includes) {
       const name = resolveUncheckedPath( ref, 'include', art );
       // console.log('CAI:',justResolveCyclic, name, ref.path, Object.keys(extensionsDict))
@@ -1071,7 +1083,6 @@ function extend( model ) {
       else if (ref._artifact) {
         delete ref._artifact;
       }
-      resolvePath( ref, isView ? 'viewInclude' : 'include', art );
     }
     return true;
   }
@@ -1080,7 +1091,10 @@ function extend( model ) {
    * Apply all includes of `ext` on `ext`.  Checks that `art` allows includes.
    * If `ext === art`, then includes of the artifact itself are applied.
    * If `ext !== art`, applies includes on the extensions, not artifact.
-   * Sets `_ancestor` links on `art`.
+   * Sets `_ancestors` links on `art`.
+   *
+   * TODO: try to set `_ancestors` only to entities (but beware “intermediate”
+   * non-entities).
    *
    * Examples:
    *   ext === art:  `entity E : F {}`  => add elements of F to E
@@ -1096,22 +1110,31 @@ function extend( model ) {
       return;
     }
 
-    if (!art.query) {
-      if (!art._ancestors)
-        setLink( art, '_ancestors', [] ); // recursive array of includes
+    if (!art._ancestors && !art.query)
+      setLink( art, '_ancestors', [] ); // recursive array of includes
+    for (const ref of ext.includes) {
+      const template = resolvePath( ref, 'include', art );
+      // !template -> non-includable, e.g. scalar type, or cyclic
+      if (template && !art.query) {
+        if (template._ancestors)
+          art._ancestors.push( ...template._ancestors );
+        art._ancestors.push( template );
+      }
+    }
+    if (!art.query && art.elements) // do not set art.elements and art.enums with query entity!
+      includeMembers( ext, art, 'elements' );
+    if (art.kind !== 'type') {
+      includeMembers( ext, art, 'actions' );
+    }
+    else {
       for (const ref of ext.includes) {
-        const template = ref._artifact;
-        // !template -> non-includable, e.g. scalar type, or cyclic
-        if (template) {
-          if (template._ancestors)
-            art._ancestors.push( ...template._ancestors );
-          art._ancestors.push( template );
+        const template = ref._artifact; // already resolved
+        if (template?.actions && Object.keys( template.actions ).length) {
+          warning( 'ref-ignoring-actions', [ ref.location, ext ], { art: template },
+                   'The actions of $(ART) are not added to the type' );
         }
       }
     }
-    if (!art.query)    // do not set art.elements and art.enums with query entity!
-      includeMembers( ext, art, 'elements' );
-    includeMembers( ext, art, 'actions' );
   }
 
   /**
@@ -1128,12 +1151,15 @@ function extend( model ) {
     // Warning 'Overwrites definition from include "I" (at elem def)
     const parent = ext === art && art;
     const members = ext[prop];
-    ext[prop] = Object.create(null); // TODO: do not set actions property if there are none
+    if (members)
+      ext[prop] = Object.create( null );
     let hasNewElement = false;
 
     for (const ref of ext.includes) {
       const template = ref._artifact; // already resolved
       if (template) {           // be robust
+        if (template[prop] && !ext[prop])
+          ext[prop] = Object.create( null );
         // eslint-disable-next-line no-loop-func
         forEachInOrder( template, prop, ( origin, name ) => {
           if (members && members[name]) {
@@ -1147,7 +1173,7 @@ function extend( model ) {
           if (!parent) // not yet set for EXTEND foo WITH bar => linkToOrigin() did not add it
             dictAdd( ext[prop], name, elem );
           elem.$inferred = 'include';
-          if (origin.masked)
+          if (origin.masked)    // TODO(v5): remove 'masked'
             elem.masked = Object.assign( { $inferred: 'include' }, origin.masked );
           if (origin.key)
             elem.key = Object.assign( { $inferred: 'include' }, origin.key );
@@ -1160,7 +1186,7 @@ function extend( model ) {
             setLink( elem, '_calcOrigin', origin._calcOrigin || origin );
           }
           // TODO: also complain if elem is just defined in art
-        });
+        } );
       }
     }
 
@@ -1176,7 +1202,7 @@ function extend( model ) {
         // the element order.
         if (ext[prop][name] !== elem )
           dictAdd( ext[prop], name, elem );
-      });
+      } );
     }
   }
 
@@ -1189,13 +1215,13 @@ function extend( model ) {
   function checkRedefinitionThroughIncludes( parent, prop ) {
     if (!parent[prop])
       return;
-    forEachInOrder(parent, prop, ( member, name ) => {
-      if (member.$inferred === 'include' && Array.isArray(member.$duplicates)) {
-        const includes = [ member, ...member.$duplicates ].map(dup => dup._origin._main);
+    forEachInOrder( parent, prop, ( member, name ) => {
+      if (member.$inferred === 'include' && Array.isArray( member.$duplicates )) {
+        const includes = [ member, ...member.$duplicates ].map( dup => dup._origin._main );
         error( 'duplicate-definition', [ parent.name.location, member ],
                { '#': `include-${ prop }`, name, sorted_arts: includes } );
       }
-    });
+    } );
   }
 }
 
@@ -1207,7 +1233,7 @@ function extend( model ) {
  * @returns {Record<string, object>} key: layer name, value: {name, layer, extensions[]}`
  */
 function layeredExtensions( extensions ) {
-  const layered = Object.create(null);
+  const layered = Object.create( null );
   for (const ext of extensions) {
     const layer = (ext.kind === 'annotate' || ext.kind === 'extend' || ext.kind === 'source') &&
                   layers.layer( ext );
@@ -1239,12 +1265,13 @@ function extensionsOfHighestLayers( layered ) {
   if (layerNames.length <= 1) {
     const name = layerNames[0];
     const highest = layered[name]?.extensions || [];
+    highest.sort( compareExtensions );
     delete layered[name];
     return { highest, issue: inMoreThanOneFile( highest ) };
   }
 
   // collect all layers which are lower than another layer
-  const allExtends = Object.create(null);
+  const allExtends = Object.create( null );
   allExtends[''] = {};        // the "Define" layer
   for (const name of layerNames) {
     if (name)                 // not the "Define" layer
@@ -1262,7 +1289,7 @@ function extensionsOfHighestLayers( layered ) {
     }
   }
   highest.sort( compareExtensions );
-  const good = highestLayers.every( layer => !inMoreThanOneFile( layer.extensions ));
+  const good = highestLayers.every( layer => !inMoreThanOneFile( layer.extensions ) );
   // TODO: use layer.file instead
   const issue = !good || highestLayers.length > 1 && 'unrelated';
   // console.log('HI:',highest.map(l=>l.name),issue,issue&&extensions)
@@ -1273,7 +1300,7 @@ function inMoreThanOneFile( extensions ) {
   if (extensions.length <= 1)
     return false;
   const file = extensions[0].location?.file;
-  return !file || extensions.slice(1).some( e => e.location?.file !== file );
+  return !file || extensions.some( e => e.location?.file !== file );
 }
 
 /**

package/lib/compiler/finalize-parse-cdl.js

@@ -47,14 +47,14 @@ function finalizeParseCdl( model ) {
       }
     }
 
-    forEachGeneric(model, 'definitions', art => resolveTypesForParseCdl(art, art));
-    forEachGeneric(model, 'vocabularies', art => resolveTypesForParseCdl(art, art));
+    forEachGeneric( model, 'definitions', art => resolveTypesForParseCdl( art, art ) );
+    forEachGeneric( model, 'vocabularies', art => resolveTypesForParseCdl( art, art ) );
 
     if (extensions.length > 0) {
       // TODO: do a sort based on the location in case there were two extensions
       // on the same definition?  Yes: anno first outside, then inside service def
       model.extensions = extensions;
-      model.extensions.forEach(ext => resolveTypesForParseCdl(ext, ext));
+      model.extensions.forEach( ext => resolveTypesForParseCdl( ext, ext ) );
     }
   }
 
@@ -69,9 +69,9 @@ function finalizeParseCdl( model ) {
     if (!artifact || typeof artifact !== 'object')
       return;
 
-    if (Array.isArray(artifact)) {
+    if (Array.isArray( artifact )) {
       // e.g. `args` array
-      artifact.forEach(art => resolveTypesForParseCdl(art, main));
+      artifact.forEach( art => resolveTypesForParseCdl( art, main ) );
       return;
     }
 
@@ -80,65 +80,66 @@ function finalizeParseCdl( model ) {
       return;
 
     if (artifact.type)
-      resolveTypeUnchecked(artifact, main);
+      resolveTypeUnchecked( artifact, main );
 
     for (const include of artifact.includes || [])
-      resolveUncheckedPath(include, 'include', main);
+      resolveUncheckedPath( include, 'include', main );
 
     // define.js takes care that `target` is a ref and
     // `targetAspect` is a structure.
     if (artifact.target)
-      resolveUncheckedPath(artifact.target, 'target', main);
+      resolveUncheckedPath( artifact.target, 'target', main );
     if (artifact.targetAspect)
-      resolveTypesForParseCdl(artifact.targetAspect, main);
+      resolveTypesForParseCdl( artifact.targetAspect, main );
 
     if (artifact.from) {
       const { from } = artifact;
-      resolveUncheckedPath(from, 'from', main);
-      resolveTypesForParseCdl(from, main);
+      resolveUncheckedPath( from, 'from', main );
+      resolveTypesForParseCdl( from, main );
     }
 
     // Recursively go through all XSN properties.  There are a few that need to be
     // handled specifically.  Refer to the code below this loop for details.
     for (const prop in artifact) {
-      if (parseCdlSpeciallyHandledXsnProps.includes(prop) || parseCdlIgnoredXsnProps.includes(prop))
+      if (artifact[prop] === undefined || parseCdlSpeciallyHandledXsnProps.includes( prop ) ||
+        parseCdlIgnoredXsnProps.includes( prop ))
         continue;
 
-      if (artifact[prop] && Object.getPrototypeOf(artifact[prop]) === null)
+      if (artifact[prop] && Object.getPrototypeOf( artifact[prop] ) === null)
         // Dictionary in XSN
-        forEachGeneric(artifact, prop, art => resolveTypesForParseCdl(art, art));
+        forEachGeneric( artifact, prop, art => resolveTypesForParseCdl( art, art ) );
       else
-        resolveTypesForParseCdl(artifact[prop], main);
+        resolveTypesForParseCdl( artifact[prop], main );
     }
 
     // `$queries` has a flat structure that we can use instead of going through all `query`.
     // For these query-related properties, we need to keep the reference to the artifact
     // containing it.  Otherwise some type's aren't properly resolved.
     // TODO: If resolveTypeUnchecked is reworked, we may be able to simplify this coding.
-    (artifact.$queries || []).forEach( art => resolveTypesForParseCdl(art, artifact) );
-    (artifact.columns || []).forEach( art => resolveTypesForParseCdl(art, artifact) );
-    forEachGeneric( artifact, 'mixin', art => resolveTypesForParseCdl(art, artifact) );
+    (artifact.$queries || []).forEach( art => resolveTypesForParseCdl( art, artifact ) );
+    (artifact.columns || []).forEach( art => resolveTypesForParseCdl( art, artifact ) );
+    forEachGeneric( artifact, 'mixin', art => resolveTypesForParseCdl( art, artifact ) );
 
     // For better error messages for `type of`s in `returns`, we pass the object as the new main.
-    resolveTypesForParseCdl(artifact.returns, artifact.returns);
+    resolveTypesForParseCdl( artifact.returns, artifact.returns );
 
     // Because `args` can be used in different contexts with different semantics,
     // it needs to be handled specifically.
     if (artifact.args && typeof artifact.args === 'object') {
-      if (Array.isArray(artifact.args)) {
+      if (Array.isArray( artifact.args )) {
         // `args` may either be an array (e.g. query 'from' args) ...
-        artifact.args.forEach((from) => {
+        artifact.args.forEach( (from) => {
           // ... and could be either inside a `from` ...
           if (from && from.kind === '$tableAlias')
-            resolveUncheckedPath(from, 'from', from._main);
+            resolveUncheckedPath( from, 'from', from._main );
 
           // ... or only params ...
-          resolveTypesForParseCdl(from, main);
-        });
+          resolveTypesForParseCdl( from, main );
+        } );
       }
       else {
         // ... or dictionary (e.g. params)
-        forEachGeneric(artifact, 'args', obj => resolveTypesForParseCdl(obj, obj));
+        forEachGeneric( artifact, 'args', obj => resolveTypesForParseCdl( obj, obj ) );
       }
     }
   }