@sap/cds-compiler 2.10.4 → 2.11.0

package/lib/compiler/definer.js

@@ -88,7 +88,7 @@
 // Sub Phase 2 (initXYZ)
 //  - set _parent, _main (later: _service?) links, and _block links of members
 //  - add _subArtifacts dictionary and "namespace artifacts" for name resolution
-//  - duplicate checks (TODO - currently via preProcessArtifact in definer)
+//  - duplicate checks
 //  - structure checks ?
 //  - annotation assignments
 //  - POST: resolvePath() can be called for artifact references (if complete model)
@@ -101,9 +101,11 @@
 //    to avoid consequential or repeated errors.
 //  - But: The same artifact is added to multiple dictionaries.
 //  - Solution part 1: $duplicates as property of the artifact or member
-//    for 'definitions', '_artifacts' and member dictionaries.
-//  - Solution part 2: array value in dictionary for duplicates in CDL 'artifacts'
-//    dictionary, also used for `_combined` in query search dictionary.
+//    for `definitions`, `_artifacts`, member dictionaries, `vocabulary`
+//    dictionary of the whole model, `$tableAliases` dictionary of queries.
+//  - Solution part 2: array value in dictionary for duplicates in CDL `artifacts`
+//    dictionary, `_combined` dictionary for query search, `$tableAliases`
+//    of JOIN restrictions, `vocabulary` dictionary of a CDL input source.
 
 'use strict';
 
@@ -111,7 +113,7 @@ const { searchName, weakLocation } = require('../base/messages');
 const {
   isDeprecatedEnabled, isBetaEnabled,
   setProp, forEachGeneric, forEachInOrder,
-  forEachMember, forEachDefinition,
+  forEachDefinition,
   forEachMemberRecursivelyWithQuery,
 } = require('../base/model');
 const {
@@ -120,20 +122,20 @@ const {
 const {
   dictLocation,
 } = require('../base/location');
+const { kindProperties, dictKinds } = require('./base');
 const {
-  annotationVal, annotationIsFalse, annotateWith,
-} = require('./utils');
-const {
-  dictKinds,
-  kindProperties,
-  fns,
+  annotationVal,
+  annotationIsFalse,
+  annotateWith,
   linkToOrigin,
   setMemberParent,
   storeExtension,
   dependsOnSilent,
-} = require('./shared');
+  augmentPath,
+  splitIntoPath,
+} = require('./utils');
 const { compareLayer, layer } = require('./moduleLayers');
-const { initBuiltins } = require('./builtins');
+const { initBuiltins, isInReservedNamespace } = require('./builtins');
 const setLink = setProp;
 
 /**
@@ -148,7 +150,7 @@ const setLink = setProp;
  *
  * @param {XSN.Model} model Model with `sources` property that contain AST-like CSNs.
  */
-function getDefinerFunctions( model ) {
+function define( model ) {
   const { options } = model;
   // Get simplified "resolve" functionality and the message function:
   const {
@@ -160,24 +162,29 @@ function getDefinerFunctions( model ) {
     resolveTypeArguments,
     defineAnnotations,
     attachAndEmitValidNames,
-  } = fns( model );
-  const extensionsDict = Object.create(null);
-  let addTextsLanguageAssoc = false;
-
-  return {
-    define,
+  } = model.$functions;
+  Object.assign( model.$functions, {
     initArtifact,
     lateExtensions,
     projectionAncestor,
     hasTruthyProp,
+  } );
+  // During the definer, we can only resolve artifact references, i.e,
+  // after a `.`, we only search in the `_subArtifacts` dictionary:
+  model.$volatileFunctions.environment = function artifactsEnv( art ) {
+    return art._subArtifacts || Object.create(null);
   };
 
+  const extensionsDict = Object.create(null);
+  let addTextsLanguageAssoc = false;
+  return doDefine();
+
   /**
    * Main function of the definer.
    *
    * @returns {XSN.Model}
    */
-  function define() {
+  function doDefine() {
     if (options.deprecated &&
         messages.every( m => m.messageId !== 'api-deprecated-option' )) {
       warning( 'api-deprecated-option', {},
@@ -206,8 +213,6 @@ function getDefinerFunctions( model ) {
 
     if (options.parseCdl) {
       initExtensionsWithoutApplying();
-      // Check for redefinitions
-      Object.keys( model.definitions ).forEach( preProcessArtifact );
       // If no extensions shall be applied then we can skip further
       // artifact processing and return the model with an `extensions` property.
       return model;
@@ -215,7 +220,6 @@ function getDefinerFunctions( model ) {
 
     applyExtensions();
 
-    Object.keys( model.definitions ).forEach( preProcessArtifact );
     const commonLanguagesEntity // TODO: remove beta after a grace period
         = (options.addTextsLanguageAssoc || isBetaEnabled( options, 'addTextsLanguageAssoc' )) &&
           model.definitions['sap.common.Languages'];
@@ -238,13 +242,13 @@ function getDefinerFunctions( model ) {
    * @param {XSN.AST} src
    */
   function addSource( src ) {
-    // handle sub model from CSN parser
+    // handle sub model from parser
     if (!src.kind)
       src.kind = 'source';
 
     let namespace = src.namespace && src.namespace.path;
     let prefix = namespace ? `${ pathName( namespace ) }.` : '';
-    if (prefix.startsWith( 'cds.') && !prefix.match(/^cds\.foundation(\.|$)/)) {
+    if (isInReservedNamespace(prefix)) {
       error( 'reserved-namespace-cds', [ src.namespace.location, src.namespace ], {},
              // TODO: use $(NAME)
              'The namespace "cds" is reserved for CDS builtins' );
@@ -280,8 +284,7 @@ function getDefinerFunctions( model ) {
   function addDefinition( art, block ) {
     const { absolute } = art.name;
     // TODO: check reserved, see checkName()/checkLocalizedObjects() of checks.js
-    if (absolute === 'cds' ||
-        absolute.startsWith( 'cds.') && !absolute.match(/^cds\.foundation(\.|$)/)) {
+    if (absolute === 'cds' || isInReservedNamespace(absolute)) {
       error( 'reserved-namespace-cds', [ art.name.location, art ], {},
              // TODO: use $(NAME)
              'The namespace "cds" is reserved for CDS builtins' );
@@ -305,7 +308,7 @@ function getDefinerFunctions( model ) {
     }
     else {
       setLink( art, '_block', block );
-      // dictAdd might set $duplicates to true if def in other source
+      // dictAdd might set $duplicates to true
       dictAdd( model.definitions, absolute, art );
       return true;
     }
@@ -444,6 +447,23 @@ function getDefinerFunctions( model ) {
 
   // Phase 2 ("init") --------------------------------------------------------
 
+  function checkRedefinition( art ) {
+    if (!art.$duplicates)
+      return;
+    if (art._main) {
+      error( 'duplicate-definition', [ art.name.location, art ], {
+        name: art.name.id,
+        '#': kindProperties[art.kind].normalized || art.kind,
+      } );
+    }
+    else {
+      error( 'duplicate-definition', [ art.name.location, art ], {
+        name: art.name.absolute,
+        '#': (art.kind === 'annotation' ? 'annotation' : 'absolute' ),
+      } );
+    }
+  }
+
   function initNamespaceAndUsing( src ) {
     if (src.namespace) {
       const decl = src.namespace;
@@ -488,6 +508,7 @@ function getDefinerFunctions( model ) {
     if (!reInit)
       initParentLink( art, model.definitions );
     const block = art._block;
+    checkRedefinition( art );
     defineAnnotations( art, art, block );
     initMembers( art, art, block );
     initDollarSelf( art );      // $self
@@ -513,6 +534,7 @@ function getDefinerFunctions( model ) {
 
   function initVocabulary( art ) {
     initParentLink( art, model.vocabularies );
+    checkRedefinition( art );
     const block = art._block;
     defineAnnotations( art, art, block );
     initMembers( art, art, block );
@@ -554,20 +576,6 @@ function getDefinerFunctions( model ) {
 
   // From here til EOF, reexamine code ---------------------------------------
 
-  // currently called from preProcessArtifact(), do be called in "init"
-  function checkRedefinitions( obj, name, prop ) {
-    forEachMember( obj, checkRedefinitions, obj.targetAspect );
-    if (!obj.$duplicates)
-      return;
-    if (obj.name.location.file === '<built-in>') {
-      // builtin types like namespace 'cds' or namespace 'localized' shouldn't be printed.
-      // The error shall only be printed for the user-defined conflicting artifact.
-      return;
-    }
-    error( 'duplicate-definition', [ obj.name.location, obj ],
-           { name, '#': (obj.kind === 'namespace') ? 'namespace' : dictKinds[prop] } );
-  }
-
   function initDollarSelf( art ) {
     const selfname = '$self';
     // TODO: use setMemberParent() ?
@@ -774,12 +782,13 @@ function getDefinerFunctions( model ) {
       setMemberParent( table, table.name.id, query );
       setProp( table, '_block', query._block );
       dictAdd( query.$tableAliases, table.name.id, table, ( name, loc ) => {
-        error( 'duplicate-definition', [ loc, table ], { name, '#': '$tableAlias' } );
+        error( 'duplicate-definition', [ loc, table ], { name, '#': 'alias' } );
       } );
       // also add to JOIN nodes for name restrictions:
       for (const p of joinParents) {
-        // console.log('ADD:', query.name.id, parents.length, p)
-        dictAdd( p.$tableAliases, table.name.id, table );
+        // for JOIN alias restriction, we cannot use $duplicates, as it is
+        // already used for duplicate aliases of queries:
+        dictAddArray( p.$tableAliases, table.name.id, table );
       }
       if (table.name.id[0] === '$') {
         warning( 'syntax-dollar-ident', [ table.name.location, table ], {
@@ -866,7 +875,7 @@ function getDefinerFunctions( model ) {
           // assignments on the mixin... (also for future mixin definitions
           // with generated values)
           dictAdd( query.$tableAliases, name, query.mixin[name], ( dupName, loc ) => {
-            error( 'duplicate-definition', [ loc, query ], { name: dupName, '#': '$tableAlias' } );
+            error( 'duplicate-definition', [ loc, query ], { name: dupName, '#': 'alias' } );
           } );
           if (mixin.name.id[0] === '$') {
             warning( 'syntax-dollar-ident', [ mixin.name.location, mixin ],
@@ -993,6 +1002,7 @@ function getDefinerFunctions( model ) {
       setProp( elem, '_block', bl );
       setMemberParent( elem, name, parent, construct !== parent && prop );
       // console.log(message( null, elem.location, elem, {}, 'Info', 'INIT').toString())
+      checkRedefinition( elem );
       defineAnnotations( elem, elem, bl );
       initMembers( elem, elem, bl, initExtensions );
 
@@ -1958,24 +1968,6 @@ function getDefinerFunctions( model ) {
     }
   }
 
-  // TODO: move to "init" phase
-  /**
-   * Check whether redefinitions of the given artifact name exist and
-   * adapt to `targetAspect`.
-   *
-   * @param {string} name
-   */
-  function preProcessArtifact( name ) {
-    const art = model.definitions[name];
-    if (Array.isArray(art.$duplicates)) {
-      // A definition name containing a `.` is not invalid (TODO: starting or
-      // ending with a dot is invalid and could be checked here)
-      for (const a of art.$duplicates)
-        checkRedefinitions( a, name, 'definitions' );
-    }
-    checkRedefinitions( art, name, 'definitions' );
-  }
-
   /**
    * Process "composition of" artifacts.
    *
@@ -2326,26 +2318,6 @@ function pathName(path) {
   return path.map( id => id.id ).join('.');
 }
 
-/**
- * Generates an XSN path out of the given name. Path segments are delimited by a dot.
- * Each segment will have the given location assigned.
- *
- * @param {CSN.Location} location
- * @param {string} name
- * @returns {XSN.Path}
- */
-function splitIntoPath( location, name ) {
-  return name.split('.').map( id => ({ id, location }) );
-}
-
-/**
- * @param {CSN.Location} location
- * @param  {...any} args
- */
-function augmentPath( location, ...args ) {
-  return { path: args.map( id => ({ id, location }) ), location };
-}
-
 function augmentEqual( location, assocname, relations, prefix = '' ) {
   const args = relations.map( eq );
   return (args.length === 1)
@@ -2374,9 +2346,4 @@ function augmentEqual( location, assocname, relations, prefix = '' ) {
 // these function could be used to a future lib/compiler/utils.js, but DO NOT
 // SHARE with utility functions for CSN processors
 
-module.exports = {
-  define: model => getDefinerFunctions( model ).define(),
-  getDefinerFunctions,
-  augmentPath,
-  splitIntoPath,
-};
+module.exports = { define };

package/lib/compiler/index.js

@@ -1,5 +1,17 @@
 // Main XSN-based compiler functions
 
+// ...
+
+// How functions are shared across the Core Compiler sub modules:
+
+// - Shared XSN-related functions which do not use a context are in utils.js,
+//   they are `require`d as usual at the beginning of sub modules.
+// - The XSN is the only context which context-dependent functions can depend on.
+// - Sharing such a function is by adding it to `‹xsn›.$functions`,
+//   e.g. `resolvePath` and similar will be attached to the XSN.
+// - Functions which might be overwritten in a next sub module
+//   are added to `‹xsn›.$volatileFunctions`, currently just `environment`.
+
 'use strict';
 
 const { resolveModule, resolveModuleSync } = require('../utils/moduleResolve');
@@ -8,6 +20,7 @@ const parseCsn = require('../json/from-csn');
 
 const assertConsistency = require('./assert-consistency');
 const moduleLayers = require('./moduleLayers');
+const { fns } = require('./shared');
 const { define } = require('./definer');
 const resolve = require('./resolver');
 const propagator = require('./propagator');
@@ -110,7 +123,6 @@ function compileX( filenames, dir = '', options = {}, fileCache = Object.create(
   //   fileCache = Object.assign( Object.create(null), fileCache );
   dir = path.resolve(dir);
   const a = processFilenames( filenames, dir );
-  a.fileContentDict = Object.create(null);
 
   const model = { sources: a.sources, options };
   model.$messageFunctions = createMessageFunctions( options, 'compile', model );
@@ -149,7 +161,6 @@ function compileX( filenames, dir = '', options = {}, fileCache = Object.create(
         }
         else {
           try {
-            a.fileContentDict[filename] = source;
             const ast = parseX( source, rel, options, model.$messageFunctions );
             a.sources[filename] = ast;
             ast.location = { file: rel };
@@ -220,7 +231,6 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
   // absolute file names - they start with `/` or `\` or similar
   dir = path.resolve(dir);
   const a = processFilenames( filenames, dir );
-  a.fileContentDict = Object.create(null);
 
   const model = { sources: a.sources, options };
   model.$messageFunctions = createMessageFunctions( options, 'compile', model );
@@ -281,7 +291,6 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
       }
       else {
         try {
-          a.fileContentDict[filename] = source;
           const ast = parseX( source, rel, options, model.$messageFunctions );
           a.sources[filename] = ast;
           ast.location = { file: rel };
@@ -416,6 +425,9 @@ function compileDoX( model ) {
     throwWithError();
     return model;
   }
+  model.$functions = {};
+  model.$volatileFunctions = {};
+  fns( model );                 // attach (mostly) paths functions
   define( model );
   // do not run the resolver in parse-cdl mode or we get duplicate annotations, etc.
   // TODO: do not use this function for parseCdl anyway…

package/lib/compiler/propagator.js

@@ -8,7 +8,7 @@ const {
   setProp,
   isDeprecatedEnabled,
 } = require( '../base/model');
-const { linkToOrigin, withAssociation } = require('./shared');
+const { linkToOrigin, withAssociation } = require('./utils');
 // const { refString } = require( '../base/messages')
 
 function propagate( model ) {
@@ -179,6 +179,8 @@ function propagate( model ) {
   // accessed at their type being a main artifact
   function expensive( prop, target, source ) {
     // console.log(prop,source.name,'->',target.kind,target.name);
+    if (source.kind === 'builtin')
+      return;
     if (prop !== 'foreignKeys' && availableAtType( prop, target, source ))
       // foreignKeys must always be copied with target to avoid any confusion
       // whether we have to generated implicit keys
@@ -211,7 +213,8 @@ function propagate( model ) {
   }
 
   function onlyViaParent( prop, target, source ) {
-    if (target.$inferred === 'proxy') // assocs and enums do not have 'include'
+    if (target.$inferred === 'proxy' || target.$inferred === 'expand-element')
+      // assocs and enums do not have 'include'
       always( prop, target, source );
   }
 

package/lib/compiler/resolver.js

@@ -47,25 +47,28 @@ const {
 const { dictLocation } = require('../base/location');
 const { searchName, weakLocation } = require('../base/messages');
 const { combinedLocation } = require('../base/location');
-const { pushLink } = require('./utils');
+
+const { kindProperties } = require('./base');
 const {
-  getDefinerFunctions,
+  pushLink,
+  setLink,
   augmentPath,
   splitIntoPath,
-} = require('./definer');
+  linkToOrigin,
+  setMemberParent,
+  withAssociation,
+  storeExtension,
+  dependsOn,
+  dependsOnSilent,
+} = require('./utils');
 
 const detectCycles = require('./cycle-detector');
 const layers = require('./moduleLayers');
 
-const {
-  kindProperties, fns, setLink, linkToOrigin, setMemberParent, withAssociation, storeExtension,
-  dependsOn, dependsOnSilent,
-} = require('./shared');
-
 const annotationPriorities = {
   define: 1, extend: 2, annotate: 2, edmx: 3,
 };
-
+const $inferred = Symbol.for('cds.$inferred');
 
 // Export function of this file.  Resolve type references in augmented CSN
 // `model`.  If the model has a property argument `messages`, do not throw
@@ -73,21 +76,21 @@ const annotationPriorities = {
 // that property (should be a vector).
 function resolve( model ) {
   const { options } = model;
-  // Get shared "resolve" functionality and the message function:
+  // Get shared functionality and the message function:
+  const {
+    info, warning, error, message,
+  } = model.$messageFunctions;
   const {
     resolvePath,
     resolveTypeArguments,
     defineAnnotations,
     attachAndEmitValidNames,
-  } = fns( model, environment );
-  const {
-    info, warning, error, message,
-  } = model.$messageFunctions;
-  const {
     initArtifact,
     lateExtensions,
     projectionAncestor,
-  } = getDefinerFunctions(model);
+  } = model.$functions;
+  model.$volatileFunctions.environment = environment;
+
   /** @type {any} may also be a boolean */
   let newAutoExposed = [];
 
@@ -242,6 +245,7 @@ function resolve( model ) {
     const chain = [];
     while (art && !('_effectiveType' in art) &&
            (art.type || art._origin || art.value && art.value.path) &&
+           // TODO: really stop at art.enum?
            !art.target && !art.enum && !art.elements && !art.items) {
       chain.push( art );
       setProp( art, '_effectiveType', 0 ); // initial setting in case of cycles
@@ -273,13 +277,17 @@ function resolve( model ) {
       // collect the "latest" cardinality (calculate lazyly if necessary)
       let cardinality = art.cardinality ||
           art._effectiveType && (() => getCardinality( art._effectiveType ));
+      let prev = art;
       for (const a of chain) {
         if (a.cardinality)
           cardinality = a.cardinality;
         if (a.expand && expandFromColumns( a, art, cardinality ) ||
             art.target && redirectImplicitly( a, art ) ||
-            art.elements && expandElements( a, art, eType ))
+            art.elements && expandElements( a, art, eType ) ||
+            art.items && expandItems( a, art, eType ))
           art = a;
+        else if (art.enum && expandEnum( a, prev ))
+          prev = a;             // do not set art - effective type is base
         setProp( a, '_effectiveType', art );
       }
     }
@@ -405,7 +413,7 @@ function resolve( model ) {
     for (const view of resolveChain.reverse()) {
       if (view._status !== '_query' ) { // not already resolved
         setProp( view, '_status', '_query' );
-        traverseQueryPost( view.query, false, populateQuery );
+        traverseQueryPost( view.query, null, populateQuery );
         if (view.elements$)     // specified elements
           mergeSpecifiedElements( view );
         if (!view.$entity) {
@@ -494,7 +502,8 @@ function resolve( model ) {
         });
       }
       forEachGeneric( { elements: alias.elements }, 'elements', ( elem, name ) => {
-        dictAddArray( query._combined, name, elem, null ); // not dictAdd()
+        if (elem.$duplicates !== true)
+          dictAddArray( query._combined, name, elem, null ); // not dictAdd()
       });
     }
   }
@@ -535,6 +544,23 @@ function resolve( model ) {
     setMemberParent( key, name, elem ); // TODO: set _block here if not present?
   }
 
+  function expandItems( art, origin, eType ) {
+    if (!enableExpandElements || art.items)
+      return false;
+    if (isInParents( art, eType )) {
+      art.items = 0;            // circular
+      return true;
+    }
+    const ref = art.type || art.value || art.name;
+    const location = ref && ref.location || art.location;
+    art.items = { $inferred: 'expand-element', location };
+    setProp( art.items, '_outer', art );
+    setProp( art.items, '_origin', origin.items );
+    if (!art.$expand)
+      art.$expand = 'origin';   // if value stays, elements won't appear in CSN
+    return true;
+  }
+
   function expandElements( art, struct, eType ) {
     if (!enableExpandElements)
       return false;
@@ -566,7 +592,28 @@ function resolve( model ) {
     // member property):
     if (!art.$expand)
       art.$expand = 'origin';   // if value stays, elements won't appear in CSN
-    // TODO: have some art.elements[SYM.$inferred] = 'expand-elements';
+    // TODO: have some art.elements[SYM.$inferred] = 'expand-element';
+    return true;
+  }
+
+  function expandEnum( art, origin ) {
+    if (!enableExpandElements || art.enum)
+      return false;
+    const ref = art.type || art.value || art.name;
+    const location = weakLocation( ref && ref.location || art.location );
+    art.enum = Object.create(null);
+    for (const name in origin.enum) {
+      const orig = origin.enum[name];
+      linkToOrigin( orig, name, art, 'enum', location, true )
+        // or should we use orig.location? - TODO: try to find test to see message
+        .$inferred = 'expand-element';
+    }
+    // Set elements expansion status (the if condition is always true, as no
+    // elements expansion will take place on artifact with existing other
+    // member property):
+    if (!art.$expand)
+      art.$expand = 'origin';   // if value stays, elements won't appear in CSN
+    art.enum[$inferred] = 'expand-element';
     return true;
   }
 
@@ -604,7 +651,7 @@ function resolve( model ) {
   //               not counting propagated ones; set up to the definition (main artifact)
   //               (only set with anno on $inferred elem)
   // Usage according to CSN flavor:
-  // - gensrc: do not render enferred elements (including expanded elements),
+  // - gensrc: do not render inferred elements (including expanded elements),
   //           collect annotate statements with value 'annotate'
   // - client: do not render expanded sub elements if artifact/member is no type, has a type,
   //           has $expand = 'origin', and all its _origin also have $expand = 'origin'
@@ -1441,8 +1488,9 @@ function resolve( model ) {
     }
     // Resolve projections/views
     // if (art.query)console.log( info( null, [art.query.location,art.query], 'VQ:' ).toString() );
-    // TODO: here, any order should be ok, i.e. just loop over $queries
-    traverseQueryPost( art.query, false, resolveQuery );
+
+    if (art.$queries)
+      art.$queries.forEach( resolveQuery );
 
     if (obj.type || obj._origin || obj.value && obj.value.path || obj.elements) // typed artifacts
       effectiveType(obj);  // set _effectiveType if appropriate, (future?): copy elems if extended
@@ -1658,6 +1706,8 @@ function resolve( model ) {
           location,
           $inferred: 'expand-param',
         };
+        setProp( art.returns, '_parent', art );
+        setProp( art.returns, '_main', art._main || art );
         setProp( art.returns, '_origin', origin.returns );
       }
     }
@@ -1868,7 +1918,7 @@ function resolve( model ) {
   function resolveQuery( query ) {
     if (!query._main)           // parse error
       return;
-    populateQuery( query );
+    traverseQueryPost( query, null, populateQuery );
     forEachGeneric( query, '$tableAliases', ( alias ) => {
       // console.log( info( null, [alias.location,alias], 'SQA:' ).toString() );
       if (alias.kind === 'mixin')
@@ -2593,6 +2643,8 @@ function resolve( model ) {
   }
 
   function resolveExpr( expr, expected, user, extDict, expandOrInline) {
+    // TODO: when we have rewritten the resolvePath functions,
+    // define a traverseExpr() in ./utils.js
     // TODO: extra "expected" 'expand'/'inline' instead o param `expandOrInline`
     if (!expr || typeof expr === 'string') // parse error or keywords in {xpr:...}
       return;
@@ -2629,7 +2681,7 @@ function resolve( model ) {
     else if (expr.query) {
       const { query } = expr;
       if (query.kind || query._leadingQuery) { // UNION has _leadingQuery
-        traverseQueryPost( query, false, resolveQuery );
+        // traverseQueryPost( query, false, resolveQuery );
       }
       else {
         error( 'expr-no-subquery', [ expr.location, user ], {},
@@ -2640,9 +2692,10 @@ function resolve( model ) {
       const args = Array.isArray(expr.args) ? expr.args : Object.values( expr.args );
       args.forEach( e => e && resolveExpr( e, e.$expected || expected, user, extDict ) );
     }
-    if (expr.suffix && !isBetaEnabled( options, 'windowFunctions' )) {
+    if (expr.suffix && isDeprecatedEnabled( options )) {
       const { location } = expr.suffix[0] || expr;
-      error( null, [ location, user ], 'Window functions are not supported' );
+      error( null, [ location, user ], { prop: 'deprecated' },
+             'Window functions are not supported if $(PROP) options are set' );
     }
     if (expr.suffix)
       expr.suffix.forEach( s => s && resolveExpr( s, expected, user, extDict ) );
@@ -2830,8 +2883,6 @@ function navProjection( navigation, preferred ) {
 // Query tree post-order traversal - called for everything which makes a query
 // except "real ones": operands of UNION etc, JOIN with ON, and sub queries in FROM
 function traverseQueryPost( query, simpleOnly, callback ) {
-  while (Array.isArray(query)) // query in parentheses, TODO: remove
-    query = query[0];
   if (!query)                   // parser error
     return;
   if (!query.op) {              // in FROM (not JOIN)
@@ -2851,11 +2902,19 @@ function traverseQueryPost( query, simpleOnly, callback ) {
     // console.log('FE:')
   }
   else if (query.args) {             // JOIN, UNION, INTERSECT
-    for (const q of query.args)
-      traverseQueryPost( q, simpleOnly, callback );
-    // The ON condition has to be traversed extra, because it must be evaluated
-    // after the complete FROM has been traversed.  It is also not necessary to
-    // evaluate it in populateQuery().
+    if (!query.join && simpleOnly == null) {
+      // enough for elements: traverse only first args for UNION/INTERSECT
+      // TODO: we might use this also when we do not rewrite associations
+      // in non-referred sub queries
+      traverseQueryPost( query.args[0], simpleOnly, callback );
+    }
+    else {
+      for (const q of query.args)
+        traverseQueryPost( q, simpleOnly, callback );
+      // The ON condition has to be traversed extra, because it must be evaluated
+      // after the complete FROM has been traversed.  It is also not necessary to
+      // evaluate it in populateQuery().
+    }
   }
   // else: with parse error (`select from <EOF>`, `select distinct from;`)
 }