@sap/cds-compiler 3.3.2 → 3.4.2

package/lib/compiler/extend.js

@@ -35,7 +35,8 @@ function extend( model ) {
     resolvePath,
     resolveUncheckedPath,
     checkAnnotate,
-    defineAnnotations,
+    initAnnotations,
+    copyAnnotationsForExtensions,
     attachAndEmitValidNames,
     checkDefinitions,
     initArtifact,
@@ -163,6 +164,7 @@ function extend( model ) {
   }
 
   function extendContext( name, art ) {
+    // TODO: remove this function - add remains to define.js
     // (ext.expectedKind == art.kind) already checked by parser except for context/service
     if (!kindProperties[art.kind].artifacts) {
       // no context or service => warn about context extensions
@@ -189,9 +191,8 @@ function extend( model ) {
       checkDefinitions( ext, art, 'columns');
       if (ext.includes)
         applyIncludes( ext, art ); // emits error if `includes` is set
-      if (ext.kind === 'annotate' || ext.kind === 'extend')
-        checkAnnotate( ext, art );
-      defineAnnotations( ext, art, ext._block, ext.kind );
+      checkAnnotate( ext, art );
+      copyAnnotationsForExtensions( ext, art );
     }
     return true;
   }
@@ -207,7 +208,8 @@ function extend( model ) {
    * @param {boolean|'gen'} [noIncludes=false]
    */
   function extendArtifact( extensions, art, noIncludes = false) {
-    if (!noIncludes && !(canApplyIncludes( art ) && extensions.every( canApplyIncludes )))
+    if (!noIncludes && !(canApplyIncludes( art, art ) &&
+        extensions.every( ext => canApplyIncludes(ext, art) )))
       return false;
     if (!art.query) {
       model._entities.push( art ); // add structure with includes in dep order
@@ -251,9 +253,9 @@ function extend( model ) {
             art.includes = [ ...ext.includes ];
           applyIncludes( ext, art );
         }
-        if (ext.kind === 'annotate' || ext.kind === 'extend')
-          checkAnnotate( ext, art );
-        defineAnnotations( ext, art, ext._block, ext.kind );
+        checkAnnotate( ext, art );
+        initAnnotations( ext, ext._block, ext.kind ); // TODO: do in define.js
+        copyAnnotationsForExtensions( ext, art );
         // TODO: do we allow to add elements with array of {...}?  If yes, adapt
         initMembers( ext, art, ext._block ); // might set _extend, _annotate
         storeTypeExtension( ext, art );
@@ -302,9 +304,6 @@ function extend( model ) {
   function extendColumns( ext, art ) {
     // TODO: consider reportUnstableExtensions
 
-    for (const col of ext.columns)
-      defineAnnotations( col, col, ext._block, ext.kind );
-
     const { location } = ext.name;
     const { query } = art;
     if (!query) {
@@ -392,7 +391,7 @@ function extend( model ) {
           // TODO: Future: Sub-message that points to previous extension?
           error( 'ext-invalid-type-property', [ ext[prop].location, ext ], {
             prop,
-            literal: ext[prop].val,
+            value: ext[prop].val,
             number: art[prop].val,
             '#': previousSuccess[prop] ? 'ext-smaller' : 'smaller',
           } );
@@ -580,16 +579,20 @@ function extend( model ) {
   // includes ----------------------------------------------------------------
 
   /**
-   * Returns true, if `includes` can be applied.  They can't be applied if
-   * any of the artifacts referenced in `includes` are yet to be extended.
+   * Returns true, if `art.includes` can be applied on `target`.
+   * They can't be applied if any of the artifacts referenced in
+   * `art.includes` are yet to be extended.
+   * `art !== target` if `art` is an extension.
    *
    * @param {XSN.Definition} art
+   * @param {XSN.Artifact} target
    * @returns {boolean}
    */
-  function canApplyIncludes( art ) {
+  function canApplyIncludes( art, target ) {
     if (art.includes) {
+      const isView = !!target.query;
       for (const ref of art.includes) {
-        const template = resolvePath( ref, 'include', art );
+        const template = resolvePath( ref, isView ? 'viewInclude' : 'include', art );
         if (template && template.name.absolute in extensionsDict)
           return false;
       }
@@ -612,20 +615,22 @@ function extend( model ) {
    */
   function applyIncludes( ext, art ) {
     if (kindProperties[art.kind].include !== true) {
-      error('extend-unexpected-include', [ ext.includes[0]?.location, ext ], { kind: art.kind },
-            'Can\'t extend $(KIND) with includes');
+      error('extend-unexpected-include', [ ext.includes[0]?.location, ext ],
+            { kind: art.kind });
       return;
     }
 
-    if (!art._ancestors)
-      setLink( art, '_ancestors', [] ); // recursive array of includes
-    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 );
+    if (!art.query) {
+      if (!art._ancestors)
+        setLink( art, '_ancestors', [] ); // recursive array of includes
+      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 );
+        }
       }
     }
     includeMembers( ext, art, 'elements' );
@@ -1272,7 +1277,7 @@ function copyPersistenceAnnotations(target, source, options) {
     copy( '@cds.persistence.exists' );
   copy( '@cds.persistence.skip' );
 
-  function copy(anno) {
+  function copy( anno ) {
     if ( source[anno] && !target[anno] )
       target[anno] = { ...source[anno], $inferred: 'parent-origin' };
   }

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

@@ -1,5 +1,16 @@
 // Things which needs to done for parse.cdl after define()
 
+// For transforming a single CDL file into CSN, parse.cdl resolves block-relative
+// _artifact_ references (in `type`, `includes`, `target`, `targetAspect`, `from`,
+// `extend`, `annotate`) to absolute names.  This is the task of the export
+// function of this file, which the compiler calls after the export function of
+// './define.js'.
+
+// There should be no need to do other things here – if you think there is,
+// consider adding it to './define.js'.  For “semantic locations” in error
+// messages, we set also “structural” links and names inside `extensions` (by
+// calling functions from './define.js').
+
 'use strict';
 
 const { dictAddArray } = require('../base/dictionaries');
@@ -18,7 +29,6 @@ function finalizeParseCdl( model ) {
   const {
     resolveUncheckedPath,
     resolveTypeArgumentsUnchecked,
-    defineAnnotations,
     initMembers,
     extensionsDict,
   } = model.$functions;
@@ -29,20 +39,13 @@ function finalizeParseCdl( model ) {
   function resolveTypesAndExtensionsForParseCdl() {
     const extensions = [];
 
-    // TODO: probably better to loop over extensions of all sources (there is just one)
     for (const name in extensionsDict) {
       for (const ext of extensionsDict[name]) {
         ext.name.absolute = resolveUncheckedPath( ext.name, 'extend', ext );
-        // Define annotations of this top-level extension
-        defineAnnotations( ext, ext, ext._block, 'extend' );
-        mergeAnnotatesForSameArtifact( ext );
+        mergeAnnotatesForSameArtifact( ext ); // TODO: should not be necessary anymore
         // Initialize members and define annotations in sub-elements.
         initMembers( ext, ext, ext._block, true );
         extensions.push( ext );
-        for (const col of ext.columns || []) {
-          // Note, no `priority` argument, since we don't apply the extension in the end.
-          defineAnnotations( col, col, ext._block );
-        }
       }
     }
 
@@ -50,6 +53,8 @@ function finalizeParseCdl( model ) {
     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?
       model.extensions = extensions;
       model.extensions.forEach(ext => resolveTypesForParseCdl(ext, ext));
     }

package/lib/compiler/populate.js

@@ -28,6 +28,7 @@ const {
 } = require('../base/dictionaries');
 const { dictLocation } = require('../base/location');
 const { weakLocation } = require('../base/messages');
+const { CompilerAssertion } = require('../base/error');
 
 const { kindProperties } = require('./base');
 const {
@@ -35,6 +36,8 @@ const {
   setLink,
   setArtifactLink,
   annotationVal,
+  annotationIsFalse,
+  annotationLocation,
   augmentPath,
   splitIntoPath,
   linkToOrigin,
@@ -623,10 +626,10 @@ function populate( model ) {
       return '';
     const path = col.value &&
         (col.value.path || !col.value.args && col.value.func && col.value.func.path);
-    if (path) {
+    if (path && path.length) {
       const last = !path.broken && path.length && path[path.length - 1];
       if (last) {
-        col.name = { id: last.id, location: last.location, $inferred: 'as' };
+        col.name = { id: last.id || '', location: last.location, $inferred: 'as' };
         return col.name.id;
       }
     }
@@ -678,8 +681,8 @@ function populate( model ) {
     else if (elem._pathHead?.kind === '$inline' && elem.value.path.length === 1) {
       const hpath = elem._pathHead.value?.path;
       const head = hpath?.length === 1 && hpath[0]._navigation;
-      // Alias .{ elem }
-      if (head?.kind === '$tableAlias')
+      // Alias .{ elem } - but not with Alias.{ $magic }: consider for ON-rewrite
+      if (head?.kind === '$tableAlias' && item.id.charAt(0) !== '$')
         pushLink( head.elements[item.id], '_projections', elem );
     }
   }
@@ -1022,10 +1025,12 @@ function populate( model ) {
     const targetScope = definitionScope( target );
     if (targetScope === assocScope) { // intra-scope in model
       const elemScope = definitionScope( elem._main || elem );
-      if (targetScope === target ||  // unscoped target in model
+      // without the if, compile.recompile.json versus expected csn.json in
+      // test3/Redirections/AutoExposeDeepScoped would fail
+      if (targetScope === target ||  // model target is scope root
           assocScope === assocMain || // unscoped assoc source in model
           elemScope !== (elem._main || elem)) // scoped assoc source in service
-        return elemScope;                     // own scope, then global
+        return elemScope;         // own scope, then global
     }
     if (targetScope === target)  // unscoped target in model / other service
       return false;              // all (there could be no scoped autoexposed)
@@ -1158,8 +1163,25 @@ function populate( model ) {
     const autoexposed = model.definitions[absolute];
     if (autoexposed && (autoexposed.kind !== 'namespace' || !scopedRedirections)) {
       if (isDirectProjection( autoexposed, target )) {
-        if (options.testMode)
-          throw new Error( `Tried to auto-expose ${ target.name.absolute } twice`);
+        const anno = autoexposed['@cds.redirection.target'];
+        if (annotationIsFalse( anno )) {
+          // It would probably be cleaner to ignore a dubious
+          // `@cds.redirection.target: false` earlier, but that is not easy to detect
+          // due to the name of the autoexposed entity with scoped redirections
+          if (!anno.$errorReported) {
+            info( 'anno-redirecting-anyway',
+                  [ annotationLocation( anno ), autoexposed ],
+                  { target, art: absolute, code: '@cds.redirection.target: false' },
+                  '$(TARGET) is auto-redirected to $(ART) even with $(CODE)' );
+            anno.$errorReported = 'anno-redirecting-anyway';
+          }
+        }
+        else if (autoexposed._parent === service ||
+                 !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`);
+        }
         return autoexposed;
       }
       error( 'duplicate-autoexposed', [ service.name.location, service ],

package/lib/compiler/propagator.js

@@ -33,6 +33,7 @@ function propagate( model ) {
     '@Analytics.visible': never,
     '@cds.autoexpose': onlyViaArtifact,
     '@cds.autoexposed': never,  // in case people set it themselves
+    '@cds.external': never,
     '@cds.redirection.target': never,
     '@fiori.draft.enabled': onlyViaArtifact,
     '@': annotation,            // always except in 'returns' and 'items'
@@ -84,40 +85,34 @@ function propagate( model ) {
       return;
     }
     // console.log('RUN:', art.name, art.elements ? Object.keys(art.elements) : 0)
+
     const chain = [];
-    let target = art;
-    let source = getOrigin( target );
-    while (source && checkAndSetStatus( source )) {
-      chain.push({ target, source });
-      target = source;
-      source = getOrigin( target );
-    }
-    if (source) {               // the source has fully propagated properties
-      step({ target, source });
-    }
-    else if (target._main) {    // source is element, which has not inherited props yet
-      run( target._main );       // run on main artifact first
-    }
-    else if (target.includes) {
-      let targets = [ target ];
-      while (targets.length) {
-        const news = [];
-        for (const t of targets) {
-          for (const ref of t.includes || []) {
-            const s = ref._artifact;
-            if (!s)          // ref error
-              continue;
-            chain.push( { target: t, source: s } );
-            if (checkAndSetStatus( s ))
-              news.push( s );
-          }
+    let targets = [ art ];
+    while (targets.length) {
+      const news = [];
+      for (const target of targets) {
+        const origin = getOrigin( target );
+        if (origin) {
+          chain.push( { target, source: origin } );
+          if (checkAndSetStatus( origin ))
+            news.push( origin );
+        }
+
+        for (const ref of target.includes || []) {
+          const include = ref._artifact;
+          if (!include)
+            continue;
+          chain.push( { target, source: include } );
+          if (checkAndSetStatus( include ))
+            news.push( include );
         }
-        targets = news;
       }
+      targets = news;
     }
+
     chain.reverse().forEach( step );
     runMembers( art );
-    // console.log('DONE:', art.name, art.elements ? Object.keys(art.elements) : 0)
+    // console.log('DONE:', art.name, art.elements ? Object.keys(art.elements) : 0);
   }
 
   function runMembers( art ) {

package/lib/compiler/resolve.js

@@ -87,7 +87,8 @@ function resolve( model ) {
   const {
     resolvePath,
     checkAnnotate,
-    defineAnnotations,
+    initAnnotations,
+    copyAnnotationsForExtensions,
     attachAndEmitValidNames,
     lateExtensions,
     applyTypeExtensions,
@@ -371,7 +372,7 @@ function resolve( model ) {
       }
     }
     if (obj.target) {
-      // console.log(obj.name,obj._origin.name)
+      // console.log(obj.name,obj._origin?.name,obj)
       if (obj._origin && obj._origin.$inferred === 'REDIRECTED')
         resolveTarget( art, obj._origin );
       // console.log(error( 'test-target', [ obj.location, obj ],
@@ -521,9 +522,9 @@ function resolve( model ) {
       setArtifactLink( ext.name, art );
 
       if (art) {
-        if (ext.kind === 'annotate' || ext.kind === 'extend')
-          checkAnnotate( ext, art );
-        defineAnnotations( ext, art, ext._block, ext.kind );
+        checkAnnotate( ext, art );
+        initAnnotations( ext, ext._block, ext.kind ); // TODO: do in define.js
+        copyAnnotationsForExtensions( ext, art );
         // eslint-disable-next-line no-shadow
         forEachMember( ext, ( elem, name, prop ) => {
           storeExtension( elem, name, prop, art, ext._block );
@@ -1079,6 +1080,11 @@ function resolve( model ) {
              'Only an association can be redirected' );
       return;
     }
+    else if ((elem.value || elem.expand) && elem.type && !elem.type.$inferred) {
+      error( 'ref-unexpected-assoc', [ elem.type.location, elem ], {},
+             'Casting to an association is not supported' );
+      return;
+    }
     // console.log(message( null, elem.location, elem, {target,art:assoc}, 'Info','RE')
     //             .toString(), elem.value)
     const nav = elem._main && elem._main.query && elem.value && pathNavigation( elem.value );

package/lib/compiler/shared.js

@@ -12,7 +12,6 @@ const {
   setArtifactLink,
   dependsOn,
   pathName,
-  annotationHasEllipsis,
 } = require('./utils');
 
 function artifactsEnv( art ) {
@@ -87,6 +86,11 @@ function fns( model ) {
       expectedMsgId: 'expected-struct',
       envFn: artifactsEnv,
     },
+    viewInclude: {
+      check: checkViewIncludesRef,
+      expectedMsgId: 'ref-expecting-bare-aspect',
+      envFn: artifactsEnv,
+    },
     target: {
       check: checkEntityRef,
       expectedMsgId: 'expected-entity',
@@ -135,15 +139,22 @@ function fns( model ) {
       dollar: true,
       rootEnv: 'elements',      // the final environment for the path root
       noDep: true,              // do not set dependency for circular-check
+      allowSelf: true,
     }, // TODO: special assoc for only on user
     'mixin-on': {
       escape: 'param',    // TODO: extra check that assocs containing param in ON is not published
       next: '_$next',           // TODO: lexical: ... how to find the (next) lexical environment
       dollar: true,
       noDep: true,              // do not set dependency for circular-check
+      allowSelf: true,
     }, // TODO: special assoc for only on user
     rewrite: {
-      next: '_$next', dollar: true, escape: 'param', noDep: true, rewrite: true,
+      next: '_$next',
+      dollar: true,
+      escape: 'param',
+      noDep: true,
+      allowSelf: true,
+      rewrite: true,
     }, // TODO: assertion that there is no next/escape used
     'order-by': {
       next: '_$next',
@@ -153,7 +164,11 @@ function fns( model ) {
       deprecatedSourceRefs: true,
     },
     'order-by-union': {
-      next: '_$next', dollar: true, escape: 'param', noDep: true, noExt: true,
+      next: '_$next',
+      dollar: true,
+      escape: 'param',
+      noDep: true,
+      noExt: true,
     },
     // expr TODO: better - on condition for assoc, other on
     // expr TODO: write dependency, but care for $self
@@ -169,7 +184,7 @@ function fns( model ) {
     resolveTypeArgumentsUnchecked,
     resolvePath,
     checkAnnotate,
-    defineAnnotations,
+    copyAnnotationsForExtensions,
     attachAndEmitValidNames,
   } );
   return;
@@ -183,7 +198,22 @@ function fns( model ) {
     // - derived structure types: would have to follow type in extend/include;
     // - entities with params: clarify inheritance, use of param in ON/DEFAULT;
     // - query entities/events: difficult sequence of resolve steps
-    return !(art.elements && !art.query && !art.type && !art.params);
+    // - aspect without elements (useful for actions/annotations)
+    return !(art.elements && !art.query && !art.type && !art.params) && art.kind !== 'aspect';
+  }
+
+  /**
+   * Returns true, if the given artifact can be included by a query entity / view.
+   *
+   * We currently allow:
+   * - aspects without elements (the aspect may have actions):
+   *   either no `elements` property or empty dictionary
+   *
+   * @param {XSN.Artifact} art
+   * @return {boolean}
+   */
+  function checkViewIncludesRef( art ) {
+    return !(art.kind === 'aspect' && (!art.elements || Object.keys(art.elements).length === 0));
   }
 
   /**
@@ -331,7 +361,8 @@ function fns( model ) {
       return setArtifactLink( ref, art );
     }
     else if (!spec.envFn && user._pathHead) {
-      // eslint-disable-next-line no-empty
+      if (art.kind === '$self')
+        rejectBareSelf( spec, path, user, extDict );
     }
     else if (art.kind === 'using') {
       const def = model.definitions[art.name.absolute];
@@ -374,7 +405,10 @@ function fns( model ) {
       // TODO: set art?
     }
     else if (art.kind === '$tableAlias' || art.kind === '$self') {
-      if (spec.noAliasOrMixin && art.kind !== '$self') { // TODO: extra kind $self?
+      if (art.kind === '$self') {
+        rejectBareSelf( spec, path, user, extDict );
+      }
+      else if (spec.noAliasOrMixin) {
         // TODO: good enough for now - change later to not search for table aliases at all
         signalNotFound( 'ref-rejected-on', [ head.location, user ], extDict && [ extDict ],
                         { '#': 'alias', id: head.id } );
@@ -447,6 +481,15 @@ function fns( model ) {
     return setArtifactLink( ref, art );
   }
 
+  function rejectBareSelf( spec, path, user, extDict ) {
+    if (path.length === 1 && !spec.allowSelf && !user.expand && !user.inline) {
+      const head = path[0];
+      // TODO: extra text variant for JOIN-ON (if we have an extra `expected`)
+      signalNotFound( 'ref-unexpected-self', [ head.location, user ], extDict && [ extDict ],
+                      { id: head.id } );
+    }
+  }
+
   // Issue errors for "smart" element-in-artifact references
   // without a colon; and errors for misplaced colons in references.
   // This function likely disappears again in cds-compiler v2.x.
@@ -670,8 +713,7 @@ function fns( model ) {
                         { art: searchName( msgArt, head.id, 'element' ) } );
       }
       else {
-        signalNotFound( 'ref-undefined-var', [ head.location, user ], valid, { id: head.id },
-                        'Element or variable $(ID) has not been found' );
+        signalNotFound( 'ref-undefined-var', [ head.location, user ], valid, { id: head.id } );
       }
     }
     else if (env.$frontend && env.$frontend !== 'cdl' || spec.global) {
@@ -804,13 +846,11 @@ function fns( model ) {
         // TODO: views elements are proxies to query-0 elements, not the same
         // TODO: better message text
         signalNotFound( 'query-undefined-element', [ item.location, user ],
-                        [ env ], { id: item.id },
-                        'Element $(ID) has not been found in the elements of the query' );
+                        [ env ], { id: item.id } );
       }
       else if (art.kind === '$parameters') {
         signalNotFound( 'ref-undefined-param', [ item.location, user ],
-                        [ env ], { art: searchName( art._main, item.id, 'param' ) },
-                        { param: 'Entity $(ART) has no parameter $(MEMBER)' } );
+                        [ env ], { art: art._main, id: item.id } );
       }
       else {
         const variant = art.kind === 'aspect' && !art.name && 'aspect';
@@ -832,14 +872,13 @@ function fns( model ) {
    * @param {any} location
    * @param {object[]} valid
    * @param  {object} [textParams]
-   * @param  {any} [texts]
    */
-  function signalNotFound(msgId, location, valid, textParams, texts ) {
+  function signalNotFound(msgId, location, valid, textParams ) {
     if (location.$notFound)
       return;
     location.$notFound = true;
     /** @type {object} */
-    const err = message( msgId, location, textParams, texts );
+    const err = message( msgId, location, textParams );
     if (valid)
       attachAndEmitValidNames(err, ...valid.reverse());
   }
@@ -924,44 +963,23 @@ function fns( model ) {
     }
   }
 
-  // Set _block links for annotations (necessary for layering).
-  // Also copy annotations from `construct` to `art` (TODO: separate that functionality).
-  function defineAnnotations( construct, art, block, priority = false ) {
-    if (construct.doc)
-      art.doc = construct.doc; // e.g. through `extensions` array in CSN
-
-    // set _block (for layering) and $priority, shallow-copy from extension
-    // TODO: think of removing $priority, then
-    // no _block: define, _block: annotate/extend/edmx
-    // would fit with extending defs with props like length
-    for (const annoProp in construct) {
+  // Copy annotations from `ext` to `art`, overwriting inferred ones.
+  // TODO: move to extend.js if not used anymore in define.js
+  function copyAnnotationsForExtensions( ext, art ) {
+    if (ext.doc)
+      art.doc = ext.doc; // e.g. through `extensions` array in CSN
+    for (const annoProp in ext) {
       if (annoProp.charAt(0) === '@') {
-        let annos = construct[annoProp];
-        if (!(Array.isArray(annos)))
-          annos = [ annos ];
-        for (const a of annos) {
-          setLink( a, '_block', block );
-          a.$priority = priority; // is now: undefined (auto-set) | false | 'annotate' | 'extend'
-          if (construct !== art)
-            addAnnotation( art, annoProp, a );
-          if (!priority && annotationHasEllipsis( a )) {
-            error( 'anno-unexpected-ellipsis',
-                   [ a.name.location, art ], { code: '...' } );
-          }
-        }
+        const extAnno = ext[annoProp];
+        if (art[annoProp]?.$inferred)
+          art[annoProp] = extAnno; // overwrite $inferred annos
+        else
+          dictAddArray( art, annoProp, extAnno );
       }
     }
   }
 }
 
-// Add annotation to definition - overwriting $inferred annos
-function addAnnotation( art, annoProp, anno ) {
-  const old = art[annoProp];
-  if (old && old.$inferred)
-    delete art[annoProp];
-  dictAddArray( art, annoProp, anno );
-}
-
 module.exports = {
   fns,
 };

package/lib/compiler/tweak-assocs.js

@@ -484,9 +484,8 @@ function tweakAssocs( model ) {
     if (elem && !Array.isArray(elem))
       return elem;
     // TODO: better (extra message), TODO: do it
-    error( 'query-undefined-element', [ item.location, assoc ], { id: name || item.id },
-           // eslint-disable-next-line max-len
-           'Element $(ID) has not been found in the elements of the query; please use REDIRECTED TO with an explicit ON-condition' );
+    error( 'query-undefined-element', [ item.location, assoc ],
+           { id: name || item.id, '#': 'redirected' } );
     return (elem) ? false : null;
   }
 }

package/lib/compiler/utils.js

@@ -35,6 +35,16 @@ function annotationHasEllipsis( anno ) {
   const { val } = anno || {};
   return Array.isArray( val ) && val.find( v => v.literal === 'token' && v.val === '...' );
 }
+function annotationLocation( anno ) {
+  const { name, location } = anno;
+  return {
+    file: name.location.file,
+    line: name.location.line,
+    col: name.location.col,
+    endLine: location.endLine,
+    endCol: location.endCol,
+  };
+}
 
 /**
  * Set compiler-calculated annotation value.
@@ -395,6 +405,7 @@ module.exports = {
   annotationVal,
   annotationIsFalse,
   annotationHasEllipsis,
+  annotationLocation,
   annotateWith,
   setLink,
   setArtifactLink,