@sap/cds-compiler 2.12.0 → 2.15.2

package/lib/model/csnRefs.js

@@ -181,6 +181,7 @@
 
 const BUILTIN_TYPE = {};
 const { locationString } = require('../base/location');
+const { ModelError, CompilerAssertion } = require("../base/error");
 
 // Properties in which artifact or members are defined - next property in the
 // "csnPath" is the name or index of that property; 'args' (its value can be a
@@ -191,12 +192,16 @@ const artifactProperties = [ 'elements', 'columns', 'keys', 'mixin', 'enum',
 // Mapping the “reference context string” to the reference semantics
 // - lexical: false | Function - determines where to look first for “lexical names”
 // - dynamic: String - describes the dynamic environment (if in query)
+// - assoc: String, with dynamic: 'global' - what to do with assoc steps
+//   * 'static': visit elements of anonymous aspect if not last ref item
+//   * 'target': always follow target, including last ref item
+//   * other (& not provided) = follow target if not last ref item
 const referenceSemantics = {
-  type: { lexical: false, dynamic: 'global' },
-  includes: { lexical: false, dynamic: 'global' },
-  target: { lexical: false, dynamic: 'global' },
-  targetAspect: { lexical: false, dynamic: 'global' },
-  from: { lexical: false, dynamic: 'global' },
+  type: { lexical: false, dynamic: 'global' }, // TODO: assoc: 'static', see Issue #8458
+  includes: { lexical: false, dynamic: 'global', assoc: 'static' }, // no elem ref anyway
+  target: { lexical: false, dynamic: 'global', assoc: 'static' },   // no elem ref anyway
+  targetAspect: { lexical: false, dynamic: 'global', assoc: 'static' },
+  from: { lexical: false, dynamic: 'global', assoc: 'target' },
   keys: { lexical: false, dynamic: 'target' },
   keys_origin: { lexical: false, dynamic: 'target' },
   excluding: { lexical: false, dynamic: 'source' },
@@ -216,10 +221,15 @@ function justDollar() {
 
 /**
  * @param {CSN.Model} csn
+ * @param {boolean|string} [universalReady]
  */
-function csnRefs( csn ) {
+function csnRefs( csn, universalReady ) {
   const cache = new WeakMap();
-
+  setCache( BUILTIN_TYPE, '_origin', null );
+  if (universalReady === 'init-all') {
+    for (const art of Object.values( csn.definitions || {}))
+      initDefinition( art );
+  }
   // Functions which set the new `baseEnv`:
   resolveRef.expandInline = function resolve_expandInline( ref, ...args ) {
     return cached( ref, '_env', () => navigationEnv( resolveRef( ref, ...args ).art ) );
@@ -231,7 +241,15 @@ function csnRefs( csn ) {
     } );
   }
   return {
-    effectiveType, artifactRef, getOrigin, inspectRef, queryOrMain,
+    effectiveType,
+    artifactRef,
+    getOrigin,
+    inspectRef,
+    queryOrMain,
+    getColumn: ( elem ) => getCache( elem, '_column' ),
+    getElement: ( col ) => getCache( col, '_element' ),
+    initDefinition,
+    targetAspect,
     __getCache_forEnrichCsnDebugging: obj => cache.get( obj ),
   };
 
@@ -260,7 +278,7 @@ function csnRefs( csn ) {
       return setCache( art, '_effectiveType', art );
 
     if (getCache( art, '_effectiveType' ) === 0)
-      throw new Error( 'Circular type reference');
+      throw new ModelError( 'Circular type reference');
     const type = getCache( art, '_effectiveType' ) || art;
     chain.forEach( a => setCache( a, '_effectiveType', type ) );
     return type;
@@ -269,19 +287,19 @@ function csnRefs( csn ) {
   /**
    * @param {CSN.Artifact} art
    */
-  function navigationEnv( art ) {
+  function navigationEnv( art, staticAssoc ) {
     let env = effectiveType( art );
-    getOrigin( env );          // also set implicit origins
     // here, we do not care whether it is semantically ok to navigate into sub
     // elements of array items (that is the task of the core compiler /
     // semantic check)
     while (env.items)
       env = effectiveType( env.items );
-    if (!env.target)
-      return env;
-    const target = csn.definitions[env.target];
-    getOrigin( target );
-    return target;
+    const target = (staticAssoc ? targetAspect( env ) : env.target);
+    if (typeof target !== 'string')
+      return target || env;
+    const def = csn.definitions[target];
+    initDefinition( def );
+    return def;
   }
 
   /**
@@ -293,26 +311,47 @@ function csnRefs( csn ) {
    *                         could not be found.
    */
   function artifactRef( ref, notFound ) {
-    const art = (typeof ref === 'string')
-      ? csn.definitions[ref]
-      : cached( ref, '_ref', artifactPathRef );
-    if (art)
-      return art;
+    // TODO: what about type ref?
+    if (typeof ref === 'string') {
+      const main = csn.definitions[ref];
+      if (main)
+        return initDefinition( main );
+    }
+    else {
+      const art = cached( ref, '_ref', artifactPathRef );
+      if (art)
+        return art;
+    }
+    if (notFound !== undefined && typeof ref === 'string')
+      return notFound;          // is only meant for builtins
+    // Backend bug workaround, TODO: delete next 2 lines
     if (notFound !== undefined)
       return notFound;
-    throw new Error( 'Undefined reference' );
+    throw new ModelError( 'Undefined reference' );
   }
 
   function artifactPathRef( ref ) {
     const [ head, ...tail ] = ref.ref;
     let art = csn.definitions[pathId( head )];
+    initDefinition( art );
     for (const elem of tail) {
-      const env = navigationEnv( art );
+      const env = navigationEnv( art ); // TODO: second argument true, see Issue #8458
       art = env.elements[pathId( elem )];
     }
     return art;
   }
 
+  function artifactFromRef( ref ) {
+    const [ head, ...tail ] = ref.ref;
+    let art = csn.definitions[pathId( head )];
+    initDefinition( art );
+    for (const elem of tail) {
+      const env = navigationEnv( art );
+      art = env.elements[pathId( elem )];
+    }
+    return navigationEnv( art );
+  }
+
   // Return target when resolving references in 'keys'
   function assocTarget( art, refCtx ) {
     // Call contexts:
@@ -326,119 +365,114 @@ function csnRefs( csn ) {
                     || art.$origin && art.$origin.target
                     || art.cast.target;
     const target = csn.definitions[targetName];
-    getOrigin( target );        // induce implicit $origin on target
+    initDefinition( target );
     return target;
   }
 
   function getOrigin( art ) {
-    const origin = cached( art, '_origin', getOriginRaw );
-    if (origin && origin !== BUILTIN_TYPE)
-      cached( art, '$origin', _a => setImplicitOrigin( art, origin ) );
-    return origin;
+    return cached( art, '_origin', getOriginRaw );
   }
 
   function getOriginRaw( art ) {
     if (art.type)               // TODO: make robust against "linked" = only direct
       return artifactRef( art.type, BUILTIN_TYPE );
-    if (!art.$origin)           // implicit $origin should have been set
-      return null;
-    // art.$origin must not be a string here - shortened refs should already
-    // have been used to set the _origin cache
-    // If $origin object, return $origin of that:
-    if (!Array.isArray( art.$origin )) // anonymous prototype in $origin
-      return cached( art.$origin, '_origin', getOriginRaw );
-    const [ head, ...tail ] = art.$origin;
-    let origin = csn.definitions[head];
-    // allow shorter $origin ref for actions/functions, just using a string:
-    let isAction = art.kind === 'action' || art.kind === 'function';
-    for (const elem of tail) {
-      origin = originNavigation( origin, elem, isAction );
-      isAction = false;
+    if (typeof art.$origin === 'object') // null, […], {…}
+      return getOriginExplicit( art.$origin );
+
+    const parent = getCache( art, '_parent' );
+    if (parent === undefined && universalReady) {
+      const { $location } = art;
+      const location = $location &&
+            (typeof $location === 'string' ? $location : locationString( $location ));
+      const def = Object.keys( art ).join('+') + (location ? ':' + location : '');
+      throw new Error( `Inspecting non-initialized CSN node {${def}}` );
     }
-    return origin;
+    const step = getCache( art, '$origin$step' );
+    if (!step)
+      return null;
+    const origin = cached( parent, '_origin', getOriginRaw );
+    return originNavigation( origin, step );
   }
 
-  function originNavigation( art, elem, isAction ) {
-    if (typeof elem !== 'string') {
-      if (elem.action)
-        return art.actions[elem.action];
-      if (elem.param)
-        return art.params[elem.param];
-      if (elem.returns)
-        return art.returns;
-    }
-    if (isAction)
-      return art.actions[elem];
-    // TODO: if we use effectiveType(), we might have more implicit prototypes
-    // we might then need a function like effectiveArtifact,
-    // which cares about actions/params
-    // let origin = cached( art, '_origin', getOriginRaw );
-    // while (art.items) {
-    //   cached( art, '$origin', _a => setImplicitOrigin( art, origin ) );
-    //   art = art.items;
-    //   origin = cached( art, '_origin', getOriginRaw );
-    // }
-    // if (origin)
-    //   cached( art, '$origin', _a => setImplicitOrigin( art, origin ) );
-    // console.log(art)
-    if (art.returns)            // for ["main", {action: "act"}, "elem"]
-      art = art.returns;
-    return (art.elements || art.enum || targetAspect( art ).elements)[elem];
+  function getOriginExplicit( $origin ) { // null, […], {…}
+    if (!$origin)
+      return null;
+    if (!Array.isArray( $origin )) // anonymous prototype in $origin
+      return getOriginExplicit( $origin.$origin );
+    const [ head, ...tail ] = $origin;
+    const main = csn.definitions[head];
+    initDefinition( main );
+    return tail.reduce( originNavigation, main );
   }
 
-  function targetAspect( art ) {
-    const { $origin } = art;
-    return art.targetAspect ||
-      $origin && typeof $origin === 'object' && !Array.isArray( $origin ) && $origin.target ||
-      art.target;
-  }
-
-  // From the current CSN object, set implicit origin for the next navigation step
-  function setImplicitOrigin( art, origin ) {
-    setMembersImplicit( art.actions, origin.actions );
-    setMembersImplicit( art.params, origin.params );
-    if (art.returns) {
-      art = art.returns;
-      if (art.type || typeof art.$origin === 'object') // null, […], {…}
-        return true;            // not implicit or shortened
-      origin = effectiveType( origin.returns );
-      setCache( art, '_origin', origin );
-      return true;
-    }
-    while (art.items) {
-      art = art.items;
-      if (art.type || typeof art.$origin === 'object') // null, […], {…}
-        return true;            // not implicit or shortened
-      origin = effectiveType( origin.items );
-      setCache( art, '_origin', origin );
-    }
-    setMembersImplicit( art.elements, origin.elements );
-    // The enum base type is _not_ where we find the origins of the enum symbols.
-    // A derived type of an enum type with individual annotations on a symbol
-    // has both 'type' and '$origin'.
-    if (!art.type || art.$origin)
-      setMembersImplicit( art.enum, origin.enum );
-    return true;
+  function originNavigation( art, step ) {
+    if (!step)
+      return null;
+    if (!effectiveType( art ))
+      throw new TypeError( 'Cyclic type definition' );
+    if (typeof step === 'string')
+      return navigationEnv( art, true ).elements[step];
+
+    if (step.action)
+      return effectiveArtFor( art, 'actions' )[step.action];
+    if (step.param)
+      return effectiveArtFor( art, 'params' )[step.param];
+    if (step.returns)
+      return effectiveArtFor( art, 'returns' );
+    if (step.enum)
+      return navigationEnv( art, true ).enum[step.enum];
+    if (step.items)
+      return effectiveType( art ).items;
+    if (step.target)
+      return targetAspect( effectiveType( art ) );
+    throw Error( `Illegal navigation step ${ Object.keys(step)[0]}` );
   }
 
-  function setMembersImplicit( members, originMembers ) {
-    if (!members)
-      return;
-    for (const name in members) {
-      const elem = members[name];
-      if (!elem.type && typeof elem.$origin !== 'object') // undefined or string
-        setCache( elem, '_origin', originMembers[elem.$origin || name] || false );
+  function effectiveArtFor( art, property ) {
+    while (!art[property])
+      art = getOrigin( art );
+    return art[property];
+  }
+
+  function initDefinition( main ) {
+    // TODO: some --test-mode check that the argument is in ‹csn›.definitions ?
+    if (getCache( main, '$queries' ) !== undefined) // already computed
+      return main;
+    traverseDef( main, null, null, null, initNode );
+    const queries = cached( main, '$queries', allQueries );
+    for (const qcache of queries || []) {
+      const { _select } = qcache;
+      const { elements } = _select;
+      if (elements) {
+        for (const n of Object.keys( elements ))
+          traverseDef( elements[n], _select, 'element', n, initNode );
+      }
+      if (_select.mixin) {
+        for (const n of Object.keys( _select.mixin ))
+          setCache( _select.mixin[n], '_parent', _select ); // relevant initNode() part
+      }
     }
+    return main;
   }
 
-  /**
-   * Return the entity we select from
-   *
-   * @param {CSN.ArtifactReferencePath} ref
-   * @returns {CSN.Definition}
-   */
-  function fromRef( ref ) {
-    return navigationEnv( artifactRef( ref ));
+  function initNode( art, parent, kind, name ) {
+    setCache( art, '_parent', parent );
+    if (kind === 'target') {
+      // Prevent re-initialization of anonymous aspect with initDefinition():
+      // (that would be with parent: null which would be wrong)
+      setCache( art, '$queries', null );
+      return;
+    }
+    if (art.type || !kind)      // with type, top-level, query or mixin
+      return;
+    const { $origin } = art;
+    if (typeof $origin === 'object') // null, […], {…}
+      return;
+    const step = $origin || name;
+    if (parent.$origin ||
+        parent.type && kind !== 'enum' && parent.$origin !== null ||
+        getCache( parent, '$origin$step' ))
+      setCache( art, '$origin$step', (kind === 'element' ? step : { [kind]: step }) );
   }
 
   /**
@@ -479,41 +513,35 @@ function csnRefs( csn ) {
   function resolveRef( ref, refCtx, main, query, parent, baseEnv ) {
     const path = (typeof ref === 'string') ? [ ref ] : ref.ref;
     if (!Array.isArray( path ))
-      throw new Error( 'References must look like {ref:[...]}' );
+      throw new ModelError( 'References must look like {ref:[...]}' );
 
     const head = pathId( path[0] );
+    if (main)                   // TODO: improve, for csnpath starting with art
+      initDefinition( main );
     if (ref.param)
       return resolvePath( path, main.params[head], main, 'param' );
 
     const semantics = referenceSemantics[refCtx] || {};
     if (semantics.dynamic === 'global' || ref.global)
-      return resolvePath( path, csn.definitions[head], null, 'global', refCtx === 'from' );
+      return resolvePath( path, csn.definitions[head], null, 'global', semantics.assoc );
+
 
-    if (main) {
-      getOrigin( main );
-      cached( main, '$queries', allQueries );
-    }
     let qcache = query && cache.get( query.projection || query );
-    // BACKEND ISSUE: you cannot call csnRefs(), inspect some refs, change the
-    // CSN and again inspect some refs without calling csnRefs() before!
-    // WORKAROUND: if no cached query, a backend has changed the CSN - re-eval cache
-    if (query && !qcache) {
-      setCache( main, '$queries', allQueries( main ) );
-      qcache = cache.get( query.projection || query );
-    }
     // first the lexical scopes (due to query hierarchy) and $magic: ---------
     if (semantics.lexical !== false) {
       const tryAlias = path.length > 1 || ref.expand || ref.inline;
-      let cache = qcache && (semantics.lexical ? semantics.lexical( qcache ) : qcache);
-      while (cache) {
-        const alias = tryAlias && cache.$aliases[head];
+      let ncache = qcache && (semantics.lexical ? semantics.lexical( qcache ) : qcache);
+      while (ncache) {
+        const alias = tryAlias && ncache.$aliases[head];
         if (alias)
           return resolvePath( path, alias._select || alias._ref, null,
-                              'alias', cache.$queryNumber );
-        const mixin = cache._select.mixin && cache._select.mixin[head];
-        if (mixin && {}.hasOwnProperty.call( cache._select.mixin, head ))
-          return resolvePath( path, mixin, null, 'mixin', cache.$queryNumber );
-        cache = cache.$next;
+                              'alias', ncache.$queryNumber );
+        const mixin = ncache._select.mixin && ncache._select.mixin[head];
+        if (mixin && {}.hasOwnProperty.call( ncache._select.mixin, head )) {
+          setCache( mixin, '_parent', qcache._select );
+          return resolvePath( path, mixin, null, 'mixin', ncache.$queryNumber );
+        }
+        ncache = ncache.$next;
       }
       if (head.charAt(0) === '$') {
         if (head !== '$self' && head !== '$projection')
@@ -529,8 +557,19 @@ function csnRefs( csn ) {
     }
     if (baseEnv)                // ref-target (filter condition), expand, inline
       return resolvePath( path, baseEnv.elements[head], baseEnv, semantics.dynamic );
-    if (!query)                 // outside queries - TODO: items?
-      return resolvePath( path, parent.elements[head], parent, 'parent' );
+    if (!query) {                // outside queries - TODO: items?
+      let art = parent.elements[head];
+      // Ref to up_ in anonymous aspect
+      if (!art && head === 'up_') {
+        const up = getCache( parent, '_parent' );
+        const target = up && typeof up.target === 'string' && csn.definitions[up.target];
+        if (target && target.elements) {
+          initDefinition( target );
+          art = target.elements.up_;
+        }
+      }
+      return resolvePath( path, art, parent, 'parent' );
+    }
 
     if (semantics.dynamic === 'query')
       // TODO: for ON condition in expand, would need to use cached _element
@@ -542,7 +581,7 @@ function csnRefs( csn ) {
         return resolvePath( path, found, alias._ref, 'source', name )
     }
     // console.log(query.SELECT,qcache,qcache.$next,main)
-    throw new Error ( `Path item ${ 0 }=${ head } refers to nothing, refCtx: ${ refCtx }` );
+    throw new ModelError ( `Path item ${ 0 }=${ head } refers to nothing, refCtx: ${ refCtx }` );
   }
 
   /**
@@ -552,14 +591,15 @@ function csnRefs( csn ) {
    * @param [extraInfo]
    */
   function resolvePath( path, art, parent, scope, extraInfo ) {
+    const staticAssoc = extraInfo === 'static' && scope === 'global';
     /** @type {{idx, art?, env?}[]} */
     const links = path.map( (_v, idx) => ({ idx }) );
     // TODO: backends should be changed to enable uncommenting:
     // if (!art)    // does not work with test3/Associations/KeylessManagedAssociation/
-    //   throw new Error ( `Path item ${ 0 }=${ pathId( path[0] ) } refers to nothing, scope: ${ scope }`);
+    //   throw new ModelError ( `Path item ${ 0 }=${ pathId( path[0] ) } refers to nothing, scope: ${ scope }`);
     links[0].art = art;
     for (let i = 1; i < links.length; ++i) { // yes, starting at 1, links[0] is set above
-      parent = navigationEnv( art );
+      parent = navigationEnv( art, staticAssoc );
       links[i - 1].env = parent;
       if (typeof path[i - 1] !== 'string')
         setCache( path[i - 1], '_env', parent );
@@ -567,12 +607,12 @@ function csnRefs( csn ) {
       if (!art) {
         const env = links[i - 1].env;
         const loc = env.name && env.name.$location || env.$location;
-        throw new Error ( `Path item ${ i }=${ pathId( path[i] ) } on ${ locationString( loc ) } refers to nothing` );
+        throw new ModelError ( `Path item ${ i }=${ pathId( path[i] ) } on ${ locationString( loc ) } refers to nothing` );
       }
       links[i].art = art;
     }
     const last = path[path.length - 1];
-    const fromRef = scope === 'global' && extraInfo;
+    const fromRef = scope === 'global' && extraInfo === 'target';
     if (fromRef || typeof last !== 'string') {
       const env = navigationEnv( art );
       links[links.length - 1].env = env;
@@ -583,7 +623,7 @@ function csnRefs( csn ) {
       if (typeof last !== 'string')
         setCache( last, '_env', env )
     }
-    return (extraInfo && !fromRef)
+    return (extraInfo && scope !== 'global')
       ? { links, art, parent, scope, $env: extraInfo }
       : { links, art, parent, scope };
   }
@@ -604,8 +644,8 @@ function csnRefs( csn ) {
       if (query.ref) {          // ref in from
         // console.log('SQ:',query,cache.get(query))
         const as = query.as || implicitAs( query.ref );
-        const _ref = fromRef( query );
-        getCache( fromSelect, '$aliases' )[as] = { _ref, elements: _ref.elements };
+        const _ref = cached( query, '_from', artifactFromRef )
+        getCache( fromSelect, '$aliases' )[as] = { _ref, elements: _ref.elements, _parent: query };
       }
       else {
         const qcache = getQueryCache( parentQuery );
@@ -618,15 +658,18 @@ function csnRefs( csn ) {
         if (select) {
           cache.set( select, qcache ); // query and query.SELECT have the same cache qcache
           qcache._select = select;
+          qcache._parent = main;
           all.push( qcache );
         }
       }
     } );
     all.forEach( function initElements( qcache, index ) {
+      qcache._parent = main;
       qcache.$queryNumber = index + 1;
-      qcache.elements = (index ? qcache._select : main).elements;
-      const columns = qcache._select.columns;
-      if (qcache.elements && columns)
+      const { elements } = (index ? qcache._select : main);
+      qcache.elements = elements;
+      const { columns } = qcache._select;
+      if (elements && columns)
         columns.map( c => initColumnElement( c, qcache ) );
     } );
     return all;
@@ -665,7 +708,8 @@ function csnRefs( csn ) {
     while (type.items)
       type = type.items;
     const elem = setCache( col, '_element', type.elements[as] );
-    // if requested, we could set a _column link in element
+    if (elem)                   // TODO to.sql: something is strange if this is not set
+      setCache( elem, '_column', col );
     if (col.expand)
       col.expand.map( c => initColumnElement( c, elem ) );
   }
@@ -680,6 +724,11 @@ function csnRefs( csn ) {
       hidden = {};
       cache.set( obj, hidden );
     }
+    // TODO: we might keep the following with --test-mode
+    // if (hidden[prop] !== undefined) {
+    //   console.log('RS:',prop,hidden[prop],val,obj)
+    //   throw Error('RESET')
+    // }
     hidden[prop] = val;
     return val;
   }
@@ -723,7 +772,7 @@ function queryOrMain( query, main ) {
   // 'projection'), but `leading` can be its `query` property:
   if ((leading === query || leading === query.query) && main.elements)
     return main;
-  throw new Error( `Query elements not available: ${ Object.keys( query ).join('+') }`);
+  throw new ModelError( `Query elements not available: ${ Object.keys( query ).join('+') }`);
 }
 
 /**
@@ -787,6 +836,53 @@ function traverseExpr( expr, parentQuery, callback ) {
   }
 }
 
+function traverseDef( node, parent, kind, name, callback ) {
+  callback ( node, parent, kind, name );
+  if (node.params) {
+    for (const n of Object.keys( node.params ))
+      traverseType( node.params[n], node, 'param', n, callback );
+  }
+  if (node.returns)
+    traverseType( node.returns, node, 'returns', true, callback );
+  traverseType( node, true, kind, name, callback );
+  if (node.actions) {
+    for (const n of Object.keys( node.actions ))
+      traverseDef( node.actions[n], node, 'action', n, callback )
+  }
+}
+
+function traverseType( node, parent, kind, name, callback ) {
+  if (parent !== true)
+    callback ( node, parent, kind, name );
+  const target = targetAspect( node );
+  if (target && typeof target === 'object' && target.elements) {
+    callback ( target, node, 'target', true );
+    node = target;
+  }
+  else if (node.items) {
+    let items = 0;
+    while (node.items) {
+      callback ( node.items, node, 'items', ++items );
+      node = node.items;
+    }
+  }
+  if (node.elements) {
+    for (const n of Object.keys( node.elements ))
+      traverseDef( node.elements[n], node, 'element', n, callback )
+  }
+  if (node.enum) {
+    for (const n of Object.keys( node.enum ))
+      traverseDef( node.enum[n], node, 'enum', n, callback )
+  }
+}
+
+function targetAspect( art ) {
+  const { $origin } = art;
+  return art.targetAspect ||
+    $origin && typeof $origin === 'object' && !Array.isArray( $origin ) && $origin.target ||
+    art.target;
+}
+
 function pathId( item ) {
   return (typeof item === 'string') ? item : item.id;
 }
@@ -803,7 +899,7 @@ function startCsnPath( csnPath, csn ) {
     return { index: 1, main, parent, art };
   }
   if (csnPath.length < 2 || csnPath[0] !== 'definitions')
-    throw new Error( 'References outside definitions not supported yet');
+    throw new CompilerAssertion( 'References outside definitions not supported yet');
   const art = csn.definitions[csnPath[1]];
   return { index: 2, main: art, parent: null, art };
 }
@@ -830,9 +926,9 @@ function analyseCsnPath( csnPath, csn, resolve ) {
 
     const prop = csnPath[index];
     // array item, name/index of artifact/member, (named) argument
-    if (isName || Array.isArray( obj )) {
+    if (isName || Array.isArray( obj ) || prop === 'returns') {
       // TODO: call some kind of resolve.setOrigin()
-      if (typeof isName === 'string') {
+      if (typeof isName === 'string' || prop === 'returns') {
         parent = art;
         art = obj[prop];
       }