@sap/cds-compiler 3.9.4 → 4.0.0

package/lib/compiler/extend.js

@@ -4,9 +4,10 @@
 
 const { searchName, weakLocation } = require('../base/messages');
 const {
-  forEachInOrder, forEachDefinition,
+  forEachInOrder,
+  forEachDefinition,
   forEachMember,
-  isBetaEnabled,
+  isDeprecatedEnabled,
 } = require('../base/model');
 const { dictAdd, pushToDict } = require('../base/dictionaries');
 const { kindProperties, dictKinds } = require('./base');
@@ -21,6 +22,7 @@ const {
   annotationHasEllipsis,
 } = require('./utils');
 const layers = require('./moduleLayers');
+const { CompilerAssertion } = require('../base/error');
 
 const $location = Symbol.for('cds.$location');
 
@@ -29,7 +31,6 @@ const genLocation = { file: '' }; // attach stupid location - TODO: remove in v4
 // Array.prototype.spread = 42;   // prototype-polluted JS classes
 
 function extend( model ) {
-  const { options } = model;
   // Get simplified "resolve" functionality and the message function:
   const {
     message, error, warning, info,
@@ -49,6 +50,8 @@ function extend( model ) {
     applyIncludes,              // TODO: re-check
   } );
 
+  const includesNonShadowedFirst = isDeprecatedEnabled(model.options, 'includesNonShadowedFirst');
+
   sortModelSources();
   const extensionsDict = Object.create(null); // TODO TMP
   forEachDefinition( model, tagIncludes ); // TODO TMP
@@ -78,8 +81,8 @@ function extend( model ) {
   function extendArtifactBefore( art ) {
     // for main artifacts, move extensions from `$collectedExtensions` model dictionary:
     if (!art._main && !art._outer && art._extensions === undefined &&
+        art.name && // TODO: probably just a workaround, check with TODO in getOriginRaw()
         art.kind !== 'namespace') {
-      // if (!art.name) console.log(art)
       const { absolute } = art.name;
       setLink( art, '_extensions', model.$collectedExtensions[absolute]?._extensions || null );
       if (art._extensions && !art.builtin) { // keep extensions for builtin in $collectedExtensions
@@ -123,16 +126,16 @@ function extend( model ) {
       const scaleDiff = applyTypeExtensions( art, exts.scale, 'scale' );
       applyTypeExtensions( art, exts.precision, 'precision', scaleDiff );
       applyTypeExtensions( art, exts.srid, 'srid' );
+      checkPrecisionScaleExtension( art, exts );
+
       delete art.$typeExts;
     }
-    // TODO tmp: no proper XSN representation yet for annotate … with returns:
-    if (art.kind === 'annotate' && !art.returns &&
-        (extensionsMap.elements?.some( e => e.$syntax === 'returns' ) ||
-         extensionsMap.enum?.some( e => e.$syntax === 'returns' )))
+
+    if (art.kind === 'annotate' && !art.returns && extensionsMap.returns)
       annotateCreate( art, '', art, 'returns' );
 
     moveDictExtensions( art, extensionsMap, 'params' );
-    // moveReturnsExtensions( art, extensionsMap );
+    moveReturnsExtensions( art, extensionsMap );
     const sub = art.returns || art.items || art.targetAspect?.elements && art.targetAspect;
     if (sub) {
       if (art.returns) {        // after having applied params!
@@ -140,8 +143,8 @@ function extend( model ) {
         extendHandleReturns( extensionsMap.enum, art );
       }
       // care about 'ext-unexpected-returns' in a later change if we have XSN returns
-      pushToDict( sub, '_extensions', ...extensionsMap.elements || [] );
-      pushToDict( sub, '_extensions', ...extensionsMap.enum || [] );
+      pushToDict( sub, '_extensions', ...avoidRecursiveReturns(extensionsMap, 'elements'));
+      pushToDict( sub, '_extensions', ...avoidRecursiveReturns(extensionsMap, 'enum') );
     }
     else {
       moveDictExtensions( art, extensionsMap,
@@ -151,6 +154,25 @@ function extend( model ) {
     moveDictExtensions( art, extensionsMap, 'actions' );
   }
 
+  /**
+   * FIXME: Remove this workaround. This workaround avoids endless recursion for annotate statements
+   *        that have both "returns" and "elements".  The endless recursion happens due to the
+   *        pushDict on `sub`.  The `elements` extensions will point to the same extension on which
+   *        `returns` exist.
+   *
+   * @param extensionsMap
+   * @param {string} prop
+   * @return {XSN.Extension[]}
+   */
+  function avoidRecursiveReturns( extensionsMap, prop ) {
+    if (!extensionsMap[prop])
+      return [];
+    const exts = [];
+    for (const ext of extensionsMap[prop])
+      exts.push({ ...ext, returns: undefined });
+    return exts;
+  }
+
   /**
    * Create super annotate statements for remaining extensions
    */
@@ -165,14 +187,16 @@ function extend( model ) {
     Object.values( model.definitions ).forEach( setArtifactLinkForExtensions );
   }
 
-  // TODO: delete again
+  // TODO: delete again - if not, what about extensions in contexts/services?
   function setArtifactLinkForExtensions( source ) {
     if (!source.extensions)
       return;
     for (const ext of source.extensions ) {
       const { name } = ext;
-      if (name?.absolute && name._artifact === undefined) // no link set yet
-        resolvePath( name, ext.kind, ext ); // for LSP
+      if (name?.absolute && name._artifact === undefined) {
+        const refCtx = (name.absolute.startsWith( 'localized.' )) ? '_extensions' : ext.kind;
+        resolvePath( name, refCtx, ext ); // for LSP
+      }
     }
   }
 
@@ -210,7 +234,7 @@ function extend( model ) {
     const dict = Object.create(null);
     for (const ext of art._extensions) {
       for (const prop in ext) {
-        if (ext[prop] === undefined) // deleted propery
+        if (ext[prop] === undefined) // deleted property
           continue;
         // TODO: do this check nicer (after complete move to new extensions mechanism)
         if (prop.charAt(0) === '@' || prop === 'doc' ||
@@ -357,6 +381,8 @@ function extend( model ) {
     }
     else if (prop === 'columns') {
       const { query } = art;
+      for (const col of ext.columns)
+        col.$extended = true;
       if (!query?.from?.path)
         error( 'extend-columns', [ ext.columns[$location], ext ], { art } );
       else if (!query.columns)
@@ -532,6 +558,24 @@ function extend( model ) {
     return 0;
   }
 
+  /**
+   * If the target artifact has both precision and scale set, then extensions on it must also
+   * provide both to avoid user errors for subsequent `extend` statements.
+   *
+   * @param {XSN.Artifact} art
+   * @param {object} exts
+   */
+  function checkPrecisionScaleExtension( art, exts ) {
+    if (art.precision && art.scale) {
+      if ((exts.precision || exts.scale) && !(exts.precision && exts.scale)) {
+        const missing = exts.precision ? 'scale' : 'precision';
+        const prop = exts.precision ? 'precision' : 'scale';
+        error( 'ext-missing-type-property', [ exts[prop].location, exts[prop] ],
+               { art, prop, otherprop: missing } );
+      }
+    }
+  }
+
   function allowsTypeArgument( art, prop ) {
     const { parameters } = art._effectiveType;
     if (!parameters)
@@ -548,8 +592,8 @@ function extend( model ) {
 
     for (const ext of extensions) {
       const extDict = ext[extProp];
+      let dictCheck = (art.kind !== 'annotate'); // no check in super annotate statement
       for (const name in extDict) {
-        let dictCheck = (art.kind !== 'annotate'); // no check in super annotate statement
         const elemExt = extDict[name];
         if (elemExt.kind !== 'annotate' && elemExt.kind !== 'extend') // TODO: specified elems
           continue;             // definitions inside extend, already handled
@@ -561,13 +605,28 @@ function extend( model ) {
     }
   }
 
-  // function moveReturnsExtensions( art, extensionsMap ) {
-  //   const artReturns = art.returns;
-  //   const extensions = extensionsMap.returns;
-  //   // TODO: artItem is null
-  //   for (const ext of extensions)
-  //     pushToDict( artReturns, '_extensions', ext.returns );
-  // }
+  function moveReturnsExtensions( art, extensionsMap ) {
+    if (!extensionsMap.returns)
+      return;
+
+    for (const ext of extensionsMap.returns) {
+      if (!art.returns && art.kind !== 'annotate') { // no check in super annotate statement
+        const variant = art.kind === 'action' || art.kind === 'function' ? art.kind : 'std';
+        warning( 'ext-unexpected-returns', [ ext.returns.location, ext ], {
+          '#': variant, keyword: 'returns',
+        }, {
+          std: 'Unexpected $(KEYWORD); only actions and functions have return parameters',
+          action: 'Unexpected $(KEYWORD) for action without return parameter',
+          // function without `returns` can happen via CSN input!
+          function: 'Unexpected $(KEYWORD) for function without return parameter',
+        });
+      }
+      // If `!art.returns`, then it could be CSN from SQL, where actions are replaced by dummies.
+      const elem = art.returns || annotateFor( art, 'params', '' );
+      setLink( ext.name, '_artifact', (elem.kind !== 'annotate' ? elem : null) );
+      pushToDict(elem, '_extensions', ext.returns);
+    }
+  }
 
   function annotateFor( art, prop, name ) {
     const base = annotateBase( art );
@@ -580,7 +639,7 @@ function extend( model ) {
   }
 
   function annotateBase( art ) {
-    while (art._outer)          // TOOD: think about anonymous target aspect
+    while (art._outer)          // TODO: think about anonymous target aspect
       art = art._outer;
     if (art.kind === 'annotate')
       return art;
@@ -616,19 +675,13 @@ function extend( model ) {
 
   function extendHandleReturns( extensions, art ) {
     for (const ext of extensions || []) {
-      if (ext.$syntax === 'returns') { // TODO tmp: no proper XSN representation
-        ext.$syntax = '$inside-returns';
-        delete ext.params;
-      }
-      else {
-        warning( 'ext-expected-returns', [ ext.name.location, ext ], {
-          '#': art.kind, keyword: 'returns', code: 'annotate ‹name› with returns { … }',
-        }, {
-          std: 'Expected $(CODE)', // unused variant
-          action: 'Expected $(KEYWORD) when annotating action return structure, i.e. $(CODE)',
-          function: 'Expected $(KEYWORD) when annotating function return structure, i.e. $(CODE)',
-        } );
-      }
+      warning( 'ext-expecting-returns', [ ext.name.location, ext ], {
+        '#': art.kind, keyword: 'returns', code: 'annotate ‹name› with returns { … }',
+      }, {
+        std: 'Expected $(CODE)', // unused variant
+        action: 'Expected $(KEYWORD) when annotating action return structure, i.e. $(CODE)',
+        function: 'Expected $(KEYWORD) when annotating function return structure, i.e. $(CODE)',
+      } );
     }
   }
 
@@ -666,12 +719,9 @@ function extend( model ) {
           warning( 'anno-unexpected-params', [ location, ext._parent ], {},
                    'Parameters only exist for actions or functions' );
           break;
-        case 'actions':
-          warning( 'anno-unexpected-actions', [ location, ext._parent ], {},
-                   'Actions and functions only exist top-level and for entities' );
-          break;
         default:
-          // assert
+          if (model.options.testMode)
+            throw new CompilerAssertion(`Missing case for prop: ${ prop }`);
       }
       return false;
     }
@@ -767,17 +817,12 @@ function extend( model ) {
 
     // --> without art._block, art not found
     if (construct.kind === 'annotate' && art._block?.$frontend === 'cdl') {
-      if (construct.$syntax === 'returns' && art.kind !== 'action' && art.kind !== 'function' ) {
-        // `annotate ABC with returns {}` is handled just like `elements`. Warn if it is used
-        // for non-actions.  We can't only check for !art.returns, because `action A();` is valid.
-        // `art._block` ensures that `art` is a defined def.
-        return;
-        // warning('ext-unexpected-returns', [ construct.name.location, construct ],
-        //         { keyword: 'returns', meta: art.kind }, 'Unexpected $(KEYWORD) for $(META)');
+      if (construct.returns && art.kind !== 'action' && art.kind !== 'function' ) {
+        // See moveReturnsExtensions()
       }
-      else if (construct.$syntax !== 'returns' &&
+      else if (!construct.returns &&
           (art.kind === 'action' || art.kind === 'function') && construct.elements) {
-        warning('ext-expected-returns', [ construct.name.location, construct ], {
+        warning('ext-expecting-returns', [ construct.name.location, construct ], {
           '#': art.kind, keyword: 'returns', code: 'annotate ‹name› with returns { … }',
         }, {
           std: 'Expected $(CODE)', // unused variant
@@ -1084,13 +1129,21 @@ function extend( model ) {
     const parent = ext === art && art;
     const members = ext[prop];
     ext[prop] = Object.create(null); // TODO: do not set actions property if there are none
+    let hasNewElement = false;
+
     for (const ref of ext.includes) {
       const template = ref._artifact; // already resolved
       if (template) {           // be robust
+        // eslint-disable-next-line no-loop-func
         forEachInOrder( template, prop, ( origin, name ) => {
-          if (members && name in members)
-            return; // warning for overwritten element in checks.js
+          if (members && members[name]) {
+            if (!includesNonShadowedFirst && !ext[prop][name])
+              dictAdd( ext[prop], name, members[name] ); // to keep order
+            return;
+          }
+          hasNewElement = true;
           const elem = linkToOrigin( origin, name, parent, prop, weakLocation( ref.location ) );
+          setLink( elem, '_block', origin._block );
           if (!parent) // not yet set for EXTEND foo WITH bar => linkToOrigin() did not add it
             dictAdd( ext[prop], name, elem );
           elem.$inferred = 'include';
@@ -1101,6 +1154,7 @@ function extend( model ) {
           if (origin.value && origin.$syntax === 'calc') {
             // TODO: If paths become invalid in the new artifact, should we mark
             //       all usages in the expressions? Possibly just the first one?
+            // TODO: Unify with coding in extend.js
             elem.value = Object.assign( { $inferred: 'include' }, copyExpr( origin.value ));
             elem.$syntax = 'calc';
             setLink( elem, '_calcOrigin', origin._calcOrigin || origin );
@@ -1109,11 +1163,19 @@ function extend( model ) {
         });
       }
     }
+
     checkRedefinitionThroughIncludes( parent, prop );
-    // TODO: expand elements having direct elements (if needed)
-    if (members) {
+
+    if (!hasNewElement && members) {
+      ext[prop] = members;
+    }
+    else if (members) {
+      // TODO: expand elements having direct elements (if needed)
       forEachInOrder( { [prop]: members }, prop, ( elem, name ) => {
-        dictAdd( ext[prop], name, elem );
+        // The element could have been added in the previous loop (includes) to keep
+        // the element order.
+        if (ext[prop][name] !== elem )
+          dictAdd( ext[prop], name, elem );
       });
     }
   }
@@ -1130,15 +1192,8 @@ function extend( model ) {
     forEachInOrder(parent, prop, ( member, name ) => {
       if (member.$inferred === 'include' && Array.isArray(member.$duplicates)) {
         const includes = [ member, ...member.$duplicates ].map(dup => dup._origin._main);
-        if (isBetaEnabled(options, 'v4preview')) {
-          error( 'duplicate-definition', [ parent.name.location, member ],
-                 { '#': `include-${ prop }`, name, sorted_arts: includes } );
-        }
-        else {
-          // Error accidentally removed in v2/v3, therefore only a warning.
-          warning( 'ref-duplicate-include-member', [ parent.name.location, member ],
-                   { '#': prop, name, sorted_arts: includes } );
-        }
+        error( 'duplicate-definition', [ parent.name.location, member ],
+               { '#': `include-${ prop }`, name, sorted_arts: includes } );
       }
     });
   }

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

@@ -13,8 +13,8 @@
 
 'use strict';
 
+const { CompilerAssertion } = require('../base/error');
 const { forEachGeneric } = require('../base/model');
-const { setLink, setArtifactLink } = require('./utils');
 
 
 // Used for resolving types in parseCdl mode.
@@ -24,7 +24,6 @@ const parseCdlIgnoredXsnProps = [ 'location', 'query', '$tableAliases' ];
 
 function finalizeParseCdl( model ) {
   // Get simplified "resolve" functionality and the message function:
-  const { message, error } = model.$messageFunctions;
   const {
     resolveUncheckedPath,
     resolveTypeArgumentsUnchecked,
@@ -41,7 +40,7 @@ function finalizeParseCdl( model ) {
     // TODO: why not just use the extensions as they are from the first source?
     for (const name in late) {
       for (const ext of late[name]._extensions) {
-        ext.name.absolute = resolveUncheckedPath( ext.name, 'extend', ext );
+        ext.name.absolute = resolveUncheckedPath( ext.name, '_extensions', ext );
         // Initialize members and define annotations in sub-elements.
         initMembers( ext, ext, ext._block, true );
         extensions.push( ext );
@@ -53,7 +52,7 @@ function finalizeParseCdl( model ) {
 
     if (extensions.length > 0) {
       // TODO: do a sort based on the location in case there were two extensions
-      // on the same definition?
+      // on the same definition?  Yes: anno first outside, then inside service def
       model.extensions = extensions;
       model.extensions.forEach(ext => resolveTypesForParseCdl(ext, ext));
     }
@@ -149,51 +148,21 @@ function finalizeParseCdl( model ) {
    * `artWithType` has the `type` property, i.e. it could be an `items` object.
    * `user` is the actual artifact, e.g. entity or element.
    *
+   * TODO: this should basically be covered by a function of shared.js
+   *
    * @param {object} artWithType
    * @param {XSN.Artifact} user
    */
   function resolveTypeUnchecked( artWithType, user ) {
-    const root = artWithType.type.path && artWithType.type.path[0];
-    if (!root) // parse error
-      return;
-    // `scope` is only `typeOf` for `type of element` and not
-    // `type of Entity:element`. For the latter we can resolve the path
-    // without special treatment.
-    if (artWithType.type.scope !== 'typeOf') {
-      // elem: Type   or   elem: type of Artifact:elem
-      const name = resolveUncheckedPath( artWithType.type, 'type', user );
-      const type = name && model.definitions[name] || { name: { absolute: name } };
+    const name = resolveUncheckedPath( artWithType.type, 'type', user );
+    if (name) {                 // correct ref to main artifact
+      const type = model.definitions[name];
       resolveTypeArgumentsUnchecked( artWithType, type, user );
     }
-    else if (!user._main) {
-      error( 'ref-undefined-typeof', [ artWithType.type.location, user ], {},
-             'Current artifact has no element to refer to as type' );
-    }
-    else if (root.id === '$self' || root.id === '$projection') {
-      setArtifactLink( root, user._main );
-    }
-    else {
-      // For better error messages, check for invalid TYPE OFs similarly
-      // to how `resolveType()` does.
-      let struct = artWithType;
-      // `items` have no kind, but need to be skipped as well
-      while (struct.kind === 'element' || struct._outer?.items) {
-        if (struct._outer?.items)
-          struct = struct._outer;
-        else
-          struct = struct._parent;
-      }
-      if (struct.kind === 'select' || struct.kind === 'annotation' || struct !== user._main) {
-        message( 'type-unexpected-typeof', [ artWithType.type.location, user ],
-                 { keyword: 'type of', '#': struct.kind } );
-        return;
-      }
-
-      const fake = { name: { absolute: user.name.absolute } };
-      // to-csn just needs a fake element whose absolute name and _parent/_main links are correct
-      setLink( fake, '_parent', user._parent );
-      setLink( fake, '_main', user._main ); // value does not matter...
-      setArtifactLink( root, fake );
+    else if (name === '' && artWithType.$typeArgs && model.options.testMode) {
+      // Ensure: parser does not allow type args with Main:elem/`type of`,
+      // extend … with type only with named type arguments
+      throw new CompilerAssertion( 'Unexpected type arguments for TYPE OF' );
     }
   }
 }

package/lib/compiler/generate.js

@@ -16,6 +16,7 @@ const {
   augmentPath,
   splitIntoPath,
   isDirectComposition,
+  copyExpr,
 } = require('./utils');
 
 function generate( model ) {
@@ -250,7 +251,8 @@ function generate( model ) {
       }
       else if (!art._block.$withLocalized && !options.$recompile) {
         art._block.$withLocalized = true;
-        info( 'recalculated-text-entities', [ art.name.location, null ], {},
+        // no semantic loc: message only emitted once
+        info( 'def-unexpected-texts-entities', [ art.name.location, null ], {},
               'Input CSN contains expansions for localized data' );
         return textElems;       // make compilation idempotent
       }
@@ -548,6 +550,7 @@ function generate( model ) {
       }
       else if (art.type && art._block && art.type.scope !== 'typeOf') {
         // TODO: also do something special for TYPE OF inside `art`s own elements
+        // TODO: check for own - add test case with Type:elem (not TYPE OF elem)
         name = resolveUncheckedPath( art.type, 'type', art );
         art = name && model.definitions[name];
       }
@@ -593,7 +596,7 @@ function generate( model ) {
         origin = origin._origin;
       let target = origin.targetAspect;
       if (target && target.path)
-        target = resolvePath( origin.targetAspect, 'compositionTarget', origin );
+        target = resolvePath( origin.targetAspect, 'targetAspect', origin );
       if (!target || !target.elements)
         return;
       const entityName = `${ base.name.absolute }.${ elem.name.id }`;
@@ -692,12 +695,11 @@ function generate( model ) {
       $inferred: 'aspect-composition',
     };
 
-    const elements = Object.create(null);
     const art = {
       kind: 'entity',
       name: { path: splitIntoPath( location, entityName ), absolute: entityName, location },
       location,
-      elements,
+      elements: Object.create(null),
       $inferred: 'composition-entity',
     };
     if (target.name) {          // named target aspect
@@ -752,16 +754,25 @@ function generate( model ) {
   }
 
   function addProxyElements( proxyDict, elements, inferred, location, prefix = '', anno = '' ) {
-    // TODO: also use for includeMembers()?
+    // TODO: also use for includeMembers()? Both are similar. Combine?
     for (const name in elements) {
       const pname = `${ prefix }${ name }`;
       const origin = elements[name];
       const proxy = linkToOrigin( origin, pname, null, null, location || origin.location );
+      setLink( proxy, '_block', origin._block );
       proxy.$inferred = inferred;
       if (origin.masked)
         proxy.masked = Object.assign( { $inferred: 'include' }, origin.masked );
       if (origin.key)
         proxy.key = Object.assign( { $inferred: 'include' }, origin.key );
+      if (origin.value && origin.$syntax === 'calc') {
+        // TODO: If paths become invalid in the new artifact, should we mark
+        //       all usages in the expressions? Possibly just the first one?
+        // TODO: Unify with coding in extend.js
+        proxy.value = Object.assign( { $inferred: 'include' }, copyExpr( origin.value ));
+        proxy.$syntax = 'calc';
+        setLink( proxy, '_calcOrigin', origin._calcOrigin || origin );
+      }
       if (anno)
         setAnnotation( proxy, anno );
       dictAdd( proxyDict.elements, pname, proxy );

package/lib/compiler/index.js

@@ -9,8 +9,6 @@
 // - 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';
 
@@ -55,6 +53,7 @@ const extensionParsers = {
 class InvocationError extends Error {
   constructor( errs, ...args ) {
     super(...args);
+    this.code = 'ERR_CDS_COMPILER_INVOCATION';
     this.errors = errs;
     this.hasBeenReported = false;
   }
@@ -65,6 +64,7 @@ class InvocationError extends Error {
 class ArgumentError extends Error {
   constructor( arg, ...args ) {
     super(...args);
+    this.code = 'ERR_CDS_COMPILER_ARGUMENT';
     this.argument = arg;
   }
 }
@@ -410,8 +410,12 @@ function compileSourcesX( sourcesDict, options = {} ) {
  * TODO: probably issue message api-recompiled-csn there.
  */
 function recompileX( csn, options ) {
-  // Explicitly set parseCdl to false because backends cannot handle it
-  options = { ...options, parseCdl: false, $recompile: true };
+  options = {
+    ...options,
+    parseCdl: false, // Explicitly set parseCdl to false because backends cannot handle it
+    docComment: null, // Input is CSN: leave doc comments alone
+    $recompile: true,
+  };
   // Reset csnFlavor: Use client style (default)
   delete options.csnFlavor;
   delete options.toCsn;
@@ -453,7 +457,6 @@ function compileDoX( model ) {
     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.

package/lib/compiler/kick-start.js

@@ -77,7 +77,7 @@ function kickStart( model ) {
            (preferredRedirectionTarget || !annotationIsFalse( art['@cds.redirection.target'] ) )) {
       chain.push( art );
       setLink( art, '_ancestors', 0 ); // avoid infloop with cyclic from
-      const name = resolveUncheckedPath( art.query.from, 'include', art ); // TODO: 'include'?
+      const name = resolveUncheckedPath( art.query.from, 'from', art );
       art = name && model.definitions[name];
       if (autoexposed)
         break;                  // only direct projection for auto-exposed
@@ -146,9 +146,10 @@ function kickStart( model ) {
       if (art && art.$duplicates)
         continue;
       const ref = def.extern;
-      const from = (topLevel ? def : src).fileDep;
+      const user = (topLevel ? def : src);
+      const from = user.fileDep;
       if (art || !from || from.realname)   // no error for non-existing ref with non-existing module
-        resolvePath( ref, 'global', def ); // TODO: consider FROM for validNames
+        resolvePath( ref, 'using', def ); // TODO: consider FROM for validNames
     }
   }
 }