@sap/cds-compiler 4.2.2 → 4.3.0

package/lib/compiler/populate.js

@@ -26,7 +26,7 @@ const {
 const {
   dictAdd, dictAddArray, dictFirst, dictForEach,
 } = require('../base/dictionaries');
-const { weakLocation } = require('../base/messages');
+const { weakLocation } = require('../base/location');
 const { CompilerAssertion } = require('../base/error');
 
 const { kindProperties } = require('./base');
@@ -37,7 +37,6 @@ const {
   annotationIsFalse,
   annotationLocation,
   augmentPath,
-  splitIntoPath,
   linkToOrigin,
   setMemberParent,
   proxyCopyMembers,
@@ -104,7 +103,7 @@ function populate( model ) {
 
   forEachDefinition( model, traverseElementEnvironments );
   while (newAutoExposed.length) {
-    // console.log( newAutoExposed.map( a => a.name.absolute ) )
+    // console.log( newAutoExposed.map( a => a.name.id ) )
     const all = newAutoExposed;
     newAutoExposed = [];
     all.forEach( traverseElementEnvironments );
@@ -251,7 +250,7 @@ function populate( model ) {
       if (leading._effectiveType !== undefined) {
         // You cannot refer to a query of another artifact:
         throw new CompilerAssertion(
-          `Unexpected _effectiveType on leading query of ${ art.name.absolute }`
+          `Unexpected _effectiveType on leading query of ${ art.name.id }`
         );
       }
       // TODO: try just return (effectiveType( leading )) === 0 ? 0 : art;
@@ -443,7 +442,7 @@ function populate( model ) {
       // TODO: make linkToOrigin() work for returns, kind/name?
       const location = weakLocation( origin.returns.location );
       art.returns = {
-        name: Object.assign( {}, art.name, { id: '', param: '', location } ),
+        name: Object.assign( {}, art.name, { id: '', location } ),
         kind: 'param',
         location,
         $inferred: 'expanded',
@@ -685,15 +684,18 @@ function populate( model ) {
       if (!col.value && !col.expand && !(col.target && col.type))
         continue;             // error should have been reported by parser
       if (col.inline) {
+        const q = userQuery( query );
+        q.$inlines.push( col );
         col.kind = '$inline';
-        col.name = {};
+        col.name = { id: `.${ q.$inlines.length }`, $inferred: '$internal' };
+        // TODO: really use $inferred: '$internal', not '$inline' ? Re-check.
         // a name for this internal symtab entry (e.g. '.2' to avoid clashes
         // with real elements) is only relevant for `cdsc -R`/debugging
-        const q = userQuery( query );
-        q.$inlines.push( col );
+        // TODO: use number = column position if "top-level", negative numbers otherwise
+        // (is also relevant for the semantic location - only use positive)
         dependsOnSilent( q, col );
         // or use userQuery( query ) in the following, too?
-        setMemberParent( col, `.${ q.$inlines.length }`, query );
+        setMemberParent( col, null, query );
         initFromColumns( query, col.inline, col );
       }
       else if (!col.$replacement) {
@@ -835,7 +837,7 @@ function populate( model ) {
       }
       else if (Array.isArray( navElem )) {
         const names = navElem.filter( e => !e.$duplicates )
-          .map( e => `${ e.name.alias }.${ e.name.element }` );
+          .map( e => `${ e._parent.name.id }.${ e.name.id }` );
         if (names.length) {
           error( 'wildcard-ambiguous', [ location, query ], { id: name, names },
                  'Ambiguous wildcard, select $(ID) explicitly with $(NAMES)' );
@@ -982,7 +984,7 @@ function populate( model ) {
     if (target !== assocTarget)
       setExpandStatus( elem, 'target' ); // (might) also set in rewriteCondition
     elem.target = {
-      path: [ { id: target.name.absolute, location } ],
+      path: [ { id: target.name.id, location } ],
       scope: 'global',
       location,
       $inferred: (target !== assocTarget ? 'IMPLICIT' : 'rewrite' ),
@@ -1000,7 +1002,7 @@ function populate( model ) {
   }
 
   function redirectImplicitlyDo( elem, assoc, target, service ) {
-    // console.log('ES:',elem.name.absolute,elem.name.element);
+    // console.log('ES:',elem.name.id,elem.name.element);
     if (assoc._main === target && elem._main?.kind === 'entity' &&
         elem._main?._ancestors?.includes( target )) {
       // source and target of the model association are the same entity, and
@@ -1017,10 +1019,10 @@ function populate( model ) {
         target = createAutoExposed( origTarget, service, elemScope );
       const desc = origTarget._descendants ||
             setLink( origTarget, '_descendants', Object.create( null ) );
-      if (!desc[service.name.absolute]) // could be the target itself (no repeated msgs)!
-        desc[service.name.absolute] = [ target ];
+      if (!desc[service.name.id]) // could be the target itself (no repeated msgs)!
+        desc[service.name.id] = [ target ];
       else
-        desc[service.name.absolute].push( target );
+        desc[service.name.id].push( target );
     }
     else if (exposed.length === 1) {
       return exposed[0];
@@ -1079,7 +1081,7 @@ function populate( model ) {
   // auto-exposed entity when successful, or `target` otherwise (no/failed autoexposure)
   function minimalExposure( target, service, elemScope ) {
     const descendants = scopedExposure( target._descendants &&
-                                        target._descendants[service.name.absolute] ||
+                                        target._descendants[service.name.id] ||
                                         [],
                                         elemScope, target );
     const preferred = descendants.filter( d => annotationVal( d['@cds.redirection.target'] ) );
@@ -1121,7 +1123,7 @@ function populate( model ) {
       return false;              // all (there could be no scoped autoexposed)
     // scoped target in model:
     const exposed = minimalExposure( targetScope, service, false );
-    // console.log('PES:',elem.name.absolute,elem.name.element,exposed.map(e=>e.name.absolute))
+    // console.log('PES:',elem.name.id,elem.name.element,exposed.map(e=>e.name.id))
     if (exposed.length === 1)   // unique redirection for target scope: use that
       return exposed[0];
     // TODO: warning if exposed.length >= 2?  Probably not
@@ -1134,7 +1136,7 @@ function populate( model ) {
       return autoScope;
     const { location } = service.name;
     const nullScope = {
-      kind: 'namespace', name: { absolute: autoScopeName, location }, location,
+      kind: 'namespace', name: { id: autoScopeName, location }, location,
     };
     model.definitions[autoScopeName] = nullScope;
     initArtifact( nullScope );
@@ -1216,33 +1218,33 @@ function populate( model ) {
     }
     // no @cds.autoexpose or @cds.autoexpose:null
     // TODO: introduce deprecated._noInheritedAutoexposeViaComposition
-    art.$autoexpose = model.$compositionTargets[art.name.absolute]
+    art.$autoexpose = model.$compositionTargets[art.name.id]
       ? autoexposeViaComposition
       : null;
     return true;                // still check for inherited @cds.autoexpose
   }
 
   function autoExposedName( target, service, elemScope ) {
-    const { absolute } = target.name;
+    const absolute = target.name.id;
     if (isDeprecatedEnabled( options, '_shortAutoexposed' )) {
       const parent = definitionScope( target )._parent;
-      const name = (parent) ? absolute.substring( parent.name.absolute.length + 1 ) : absolute;
+      const name = (parent) ? absolute.substring( parent.name.id.length + 1 ) : absolute;
       // no need for dedot here (as opposed to deprecated._longAutoexposed), as
       // the name for dependent entities have already been created using `_` then
-      return `${ service.name.absolute }.${ name }`;
+      return `${ service.name.id }.${ name }`;
     }
     if (isDeprecatedEnabled( options, '_longAutoexposed' ))
-      return `${ service.name.absolute }.${ absolute }`;
+      return `${ service.name.id }.${ absolute }`;
     const base = definitionScope( target );
     if (base === target)
-      return `${ service.name.absolute }.${ absolute.substring( absolute.lastIndexOf( '.' ) + 1 ) }`;
+      return `${ service.name.id }.${ absolute.substring( absolute.lastIndexOf( '.' ) + 1 ) }`;
     // for scoped (e.g. calculated) entities, use exposed name of base:
     const exposed = minimalExposure( base, service, elemScope );
-    // console.log(exposed.map( a => a.name.absolute ));
+    // console.log(exposed.map( a => a.name.id ));
     const sbasename = (exposed.length === 1 && exposed[0] !== base) // same with no/failed expose
-      ? exposed[0].name.absolute
+      ? exposed[0].name.id
       : autoExposedName( base, service, elemScope );
-    return sbasename + absolute.slice( base.name.absolute.length );
+    return sbasename + absolute.slice( base.name.id.length );
   }
 
 
@@ -1268,7 +1270,7 @@ function populate( model ) {
                  !annotationVal( autoexposed['@cds.autoexposed'] )) {
           // existing def not auto-exposed, or un-scoped auto-exposed: should not happen
           if (options.testMode)
-            throw new CompilerAssertion( `Tried to auto-expose ${ target.name.absolute } twice`);
+            throw new CompilerAssertion( `Tried to auto-expose ${ target.name.id } twice`);
         }
         return autoexposed;
       }
@@ -1292,10 +1294,10 @@ function populate( model ) {
     }
     // console.log(absolute)
     const { location } = target.name;
-    const from = augmentPath( location, target.name.absolute );
+    const from = augmentPath( location, target.name.id );
     let art = {
       kind: 'entity',
-      name: { location, path: splitIntoPath( location, absolute ), absolute },
+      name: { location, id: absolute },
       location: target.location,
       query: { location, op: { val: 'SELECT', location }, from },
       $syntax: 'projection',

package/lib/compiler/propagator.js

@@ -238,6 +238,8 @@ function propagate( model ) {
       return;
     if (prop === 'params' && target.$inferred !== 'proxy' && target.$inferred !== 'include')
       return;
+    if (prop === 'foreignKeys' && target.on)
+      return; // e.g. published associations with filters
     const location = target.type && !target.type.$inferred && target.type.location ||
                 target.location ||
                 target._outer && target._outer.location;

package/lib/compiler/resolve.js

@@ -46,8 +46,7 @@ const {
   isDeprecatedEnabled,
 } = require('../base/model');
 const { dictAdd } = require('../base/dictionaries');
-const { dictLocation } = require('../base/location');
-const { weakLocation } = require('../base/messages');
+const { dictLocation, weakLocation } = require('../base/location');
 const { combinedLocation } = require('../base/location');
 const { typeParameters } = require('./builtins');
 
@@ -414,7 +413,7 @@ function resolve( model ) {
       obj.items = items;
       obj.$expand = 'origin';
     }
-    if (obj.items) {            // TODO: make this a while in v2 (also items proxy)
+    if (obj.items) {            // TODO: make this a while in v5 (also items proxy)
       obj = obj.items || obj; // the object which has type properties
       effectiveType( obj );
     }
@@ -440,11 +439,11 @@ function resolve( model ) {
         }
 
         // Check if relational type is missing its target or if it's used directly.
-        if (elemtype.category === 'relation' && obj.type.path.length > 0 &&
+        if (elemtype.category === 'relation' &&
           !obj.target && !obj.targetAspect) {
           const isCsn = (obj._block && obj._block.$frontend === 'json');
           error( 'type-missing-target', [ obj.type.location, obj ],
-                 { '#': isCsn ? 'csn' : 'std', type: elemtype.name.absolute }, {
+                 { '#': isCsn ? 'csn' : 'std', type: elemtype }, {
                    // We don't say "use 'association to <target>" because the type could be used
                    // in action parameters, etc. as well.
                    std: 'The type $(TYPE) can\'t be used directly because it\'s compiler internal',
@@ -589,20 +588,23 @@ function resolve( model ) {
         if (specifiedElement.foreignKeys) {
           const sKeys = Object.keys( specifiedElement.foreignKeys );
           /** @type {any} */
-          let iKeys = inferredElement;
+          let iAssoc = inferredElement;
           if (inferredElement._effectiveType !== 0) {
-            while (iKeys._origin && !iKeys.foreignKeys)
-              iKeys = iKeys._origin;
+            while (iAssoc._origin && !iAssoc.foreignKeys && !iAssoc.on)
+              iAssoc = iAssoc._origin;
           }
-          iKeys = Object.keys( iKeys.foreignKeys || {} );
-          if (sKeys.length !== iKeys.length || sKeys.some( fkey => !iKeys.includes( fkey ) )) {
-            error( 'query-mismatched-element', [
-              specifiedElement.foreignKeys.location || specifiedElement.location, user,
-            ], {
-              '#': 'foreignKeys',
-              name: user.name.id,
-              target: specifiedElement.target,
-              art: inferredElement.target,
+          const iKeys = Object.keys( iAssoc.foreignKeys || {} );
+          const loc = [
+            specifiedElement.foreignKeys[$location] || specifiedElement.location, user,
+          ];
+          if (iAssoc.on) {
+            error( 'query-mismatched-element', loc, {
+              '#': 'unmanagedToManaged', name: user.name.id,
+            } );
+          }
+          else if (sKeys.length !== iKeys.length || sKeys.some( fkey => !iKeys.includes( fkey ) )) {
+            error( 'query-mismatched-element', loc, {
+              '#': 'foreignKeys', name: user.name.id,
             } );
           }
         }
@@ -960,7 +962,7 @@ function resolve( model ) {
                  } );
         // TODO: also warning if inside structure
       }
-      else {
+      else {                    // if (obj.target._artifact)
         // TODO: extra with $inferred (to avoid messages)?
         resolveExpr( obj.on, art.kind === 'mixin' ? 'mixin-on' : 'on', art );
       }
@@ -1187,9 +1189,7 @@ function resolve( model ) {
     const nav = elem._main && elem._main.query && elem.value && pathNavigation( elem.value );
     if (nav && nav.item !== elem.value.path[elem.value.path.length - 1]) {
       if (!elem.on && origType.on) {
-        error( 'rewrite-not-supported', [ elem.target.location, elem ], {},
-               // TODO: Better text ?
-               'The ON-condition is not rewritten here - provide an explicit ON-condition' );
+        error( 'rewrite-not-supported', [ elem.target.location, elem ] );
         return;
       }
     }
@@ -1285,10 +1285,10 @@ function resolve( model ) {
 
     // eslint-disable-next-line no-shadow
     function findOrig( chain, alias, art ) {
-      if (!art || dict[art.name.absolute])
+      if (!art || dict[art.name.id])
         // some include ref or query source cannot be found, or cyclic ref
         return true;
-      dict[art.name.absolute] = true;
+      dict[art.name.id] = true;
 
       if (art.includes) {
         news.push( {
@@ -1378,14 +1378,18 @@ function resolve( model ) {
           art;
     if (step.args)
       resolveParams( step.args, art, entity, expected, user, step.location );
-    if (entity) {
+
+    // Publishing an association with filters is ok in column
+    const publishAssoc = art.kind === 'entity' && expected === 'column';
+
+    if (entity || publishAssoc) {
       if (step.where) {
         setLink( step, '_user', user._user || user );
         const inCalc = (expected === 'calc' || expected === 'calc-filter');
         resolveExpr( step.where, (inCalc ? 'calc-filter' : 'filter'), step );
       }
     }
-    else if (step.where || step.cardinality ) {
+    else if (step.where || step.cardinality) {
       const location = combinedLocation( step.where, step.cardinality );
       let variant = alias ? 'tableAlias' : 'std';
       if (expected === 'from')

package/lib/compiler/shared.js

@@ -227,7 +227,9 @@ function fns( model ) {
         dynamic: parentElements,
         navigation: assocOnNavigation,
         notFound: undefinedParentElement,
+        rewriteProjectionToSelf: true,
       }),
+      rewriteProjectionToSelf: true,
     },
     'mixin-on': {
       lexical: tableAliasesAndSelf,
@@ -313,10 +315,9 @@ function fns( model ) {
 
   // Return absolute name for unchecked path `ref`.  We first try searching for
   // the path root starting from `env`.  If it exists, return its absolute name
-  // appended with the name of the rest of the path and set `ref.absolute` to
-  // the return value.  Otherwise, complain if `unchecked` is false, and set
-  // `ref.absolute` to the path name of `ref`.
-  // Used for collecting artifact extension, and annotation assignments.
+  // appended with the name of the rest of the path.  Otherwise, complain if
+  // `unchecked` is false, and set `ref.absolute` to the path name of `ref`.
+  // Used for collecting artifact extension.
   //
   // Return '' if the ref is good, but points to an element.
   function resolveUncheckedPath( ref, refCtx, user ) {
@@ -325,6 +326,11 @@ function fns( model ) {
       return undefined;
 
     const semantics = referenceSemantics[refCtx];
+    if (!semantics.isMainRef)
+      throw new CompilerAssertion( `resolveUncheckedPath() called for reference ctx '${ refCtx }'` );
+    if (!definedViaCdl( user ))
+      return (path.length === 1) ? path[0].id : '';
+
     let art = getPathRoot( ref, semantics, user );
     if (ref.scope && ref.scope !== 'global')
       return '';                // TYPE OF, Main:elem
@@ -333,9 +339,9 @@ function fns( model ) {
       art = art[0];
     if (!art)
       return (semantics.dynamic !== modelDefinitions) ? art : pathName( path );
-    if (path.length === 1)
-      return art.name.absolute; // TODO: name.id
-    return `${ art.name.absolute }.${ pathName( ref.path.slice(1) ) }`;
+
+    const first = (art.kind === 'using' ? art.extern : art.name).id;
+    return (path.length === 1) ? first : `${ first }.${ pathName( ref.path.slice(1) ) }`;
   }
 
   /**
@@ -502,12 +508,12 @@ function fns( model ) {
       }
     }
 
-    // Search in $special (ex $self/$projection) and dynamic environment:
+    // Search in $special (excluding $self/$projection) and dynamic environment:
     const dynamicDict = semantics.dynamic( ruser, user._user && user._artifact );
     if (!dynamicDict)                // avoid consequential errors
       return setArtifactLink( head, null );
     const isVar = (semantics.dollar && head.id.charAt( 0 ) === '$');
-    const dict = (isVar) ? model.$magicVariables.artifacts : dynamicDict;
+    const dict = (isVar) ? model.$magicVariables.elements : dynamicDict;
     const r = dict[head.id];
     if (r)
       return setArtifactLink( head, r );
@@ -515,7 +521,7 @@ function fns( model ) {
     if (!semantics.dollar)
       valid.push( dynamicDict );
     else
-      valid.push( model.$magicVariables.artifacts, removeDollarNames( dynamicDict ) );
+      valid.push( model.$magicVariables.elements, removeDollarNames( dynamicDict ) );
     // TODO: streamline function arguments (probably: user, path, semantics )
     const undef = semantics.notFound( ruser, head, valid, dynamicDict,
                                       !isMainRef && user._user && user._artifact, path );
@@ -590,11 +596,16 @@ function fns( model ) {
   function acceptLexical( art, path, semantics, user ) {
     if (semantics.isMainRef || !art)
       return !!art;
+
     // Non-global lexical are table aliases, mixins and $self, $projection, $parameters,
     // Do not accept a lonely table alias and `$projection`
     // TODO: test table alias and mixin named `$projection`
-    if (path.length !== 1 || user.expand || user.inline)
+    if (path.length !== 1 || user.expand || user.inline) {
+      // Rewrite $projection to $self
+      if (semantics.rewriteProjectionToSelf && art.kind === '$self' && path[0].id === '$projection')
+        path[0].id = '$self';
       return art.name?.$inferred !== '$internal'; // not a compiler-generated internal alias
+    }
 
     // allow mixins, $self, and `up_` in anonymous target aspect (is $navElement):
     return art.kind === 'mixin' ||
@@ -612,7 +623,7 @@ function fns( model ) {
 
     switch (art.kind) {
       case 'using': {
-        const def = model.definitions[art.name.absolute];
+        const def = model.definitions[art.extern.id];
         if (!def)
           return def;
         if (def.$duplicates)
@@ -663,7 +674,7 @@ function fns( model ) {
     const uniqueNames = arr.filter( e => !e.$duplicates );
     if (uniqueNames.length) {
       const names = uniqueNames.filter( e => e._parent.$inferred !== '$internal' )
-        .map( e => `${ e.name.alias }.${ e.name.element }` );
+        .map( e => `${ e._parent.name.id }.${ e.name.id }` );
       let variant = names.length === uniqueNames.length ? 'std' : 'few';
       if (names.length === 0)
         variant = 'none';
@@ -929,7 +940,7 @@ function fns( model ) {
     if (id.charAt( 0 ) === '$') {
       const tableAlias = dynamicDict[id]?._parent;
       // TODO: probably better to pass param `semantics` and calculate dynamic dict explicitly
-      const alias = tableAlias?.kind === '$tableAlias' ? tableAlias.name?.alias : null;
+      const alias = tableAlias?.kind === '$tableAlias' ? tableAlias.name?.id : null;
       // TODO: mention $self without query
       signalNotFound( 'ref-undefined-var', [ head.location, user ], valid,
                       { '#': (alias ? 'alias' : 'std'), alias, id } );
@@ -966,10 +977,10 @@ function fns( model ) {
     const { id } = head;
     const src = id.charAt( 0 ) !== '$' && user._combined?.[id];
     if (src && !Array.isArray( src )) {
-      path.$prefix = src.name.alias; // pushing it to path directly could be problematic
+      path.$prefix = src._parent.name.id; // pushing it to path directly could be problematic
       // configurable error:
       signalNotFound( 'ref-deprecated-orderby', [ head.location, user ], valid,
-                      { id: head.id, newcode: `${ src.name.alias }.${ head.id }` } );
+                      { id: head.id, newcode: `${ path.$prefix }.${ head.id }` } );
       return src;
     }
     undefinedParentElement( user, head, valid, dynamicDict );
@@ -984,7 +995,8 @@ function fns( model ) {
   }
 
   function undefinedItemElement( user, item, valid, _dict, art, path ) {
-    if (art.name && art.name.select && art.name.select > 1) {
+    const query = userQuery( art );
+    if (query?.name?.id > 1) {
       // TODO: 'The current query has no element $(MEMBER)' with $self.MEMBER
       // and 'The sub query for alias $(ALIAS) has no element $(MEMBER)'
       // both as text variants to ref-undefined-element
@@ -996,21 +1008,35 @@ function fns( model ) {
                       valid, { art: art._main, id: item.id } );
     }
     else if (art.kind === 'builtin') { // magic variable / replacement variable
-      const id = (item === path[path.length - 1])
-        ? item.id
-        : pathName( path.slice( path.indexOf( item ) ) );
+      // $magic.{ var } is a configurable error,
+      // TODO: if it becomes non-configurable, we can omit this warning
+      let id = pathName( path );
+      let head = path[0]._artifact || { _parent: art };
+      // eslint-disable-next-line no-cond-assign
+      while ((head = head?._parent) && head.kind === 'builtin')
+        id = `${ head.name.id }.${ id }`;
       signalNotFound( ( art.$uncheckedElements ? 'ref-unknown-var' : 'ref-undefined-var'),
-                      [ item.location, user ], valid,
-                      { id: `${ art.name.element }.${ id }` } );
+                      [ item.location, user ], valid, { id } );
     }
-    else {
-      const variant = art.kind === 'aspect' && !art.name && 'aspect';
+    else if (art.kind === 'aspect' && !art.name) { // anonymous target aspect
       signalNotFound( 'ref-undefined-element', [ item.location, user ],
-                      valid, {
-                        '#': variant,
-                        art: (variant ? '' : searchName( art, item.id, 'element' )),
-                        id: item.id,
-                      } );
+                      valid, { '#': 'aspect', id: item.id } );
+    }
+    else {
+      const target = art._effectiveType?.target;
+      if (target?._artifact) {
+        signalNotFound( 'ref-undefined-element', [ item.location, user ], valid,
+                        { '#': 'target', art: target, id: item.id } );
+      }
+      else if (!target) {
+        const variant = art.kind === 'aspect' && !art.name && 'aspect';
+        signalNotFound( 'ref-undefined-element', [ item.location, user ],
+                        valid, {
+                          '#': variant,
+                          art: (variant ? '' : searchName( art, item.id, 'element' )),
+                          id: item.id,
+                        } );
+      }
     }
     return null;
   }
@@ -1364,7 +1390,7 @@ function fns( model ) {
       return false; // param ref `:$self` is not $self
     // $self in entity (TODO: mixin? new assoc in col? in aspect?)
     const kind = right._artifact?.kind;
-    if (kind !== 'entity' && kind !== 'aspect' && kind !== 'select')
+    if (kind !== 'entity' && kind !== 'aspect' && kind !== 'select' && kind !== 'event')
       return false;           // (ok, this would also return `false` for `:$self`)
     const { path } = left;
     // TODO: we might return true and issue an extra error here
@@ -1436,7 +1462,7 @@ function fns( model ) {
 
     for (let set = query._main.query; set.op; set = set.args[0]) {
       const right = set.args[1];
-      if (query.name.select >= (right._leadingQuery || right).name.select)
+      if (query.name.id >= (right._leadingQuery || right).name.id)
         return { txt: 'setQuery', op: set.op.val };
     }
     throw new CompilerAssertion( 'Did we pass the leading query as argument?' );