@sap/cds-compiler 2.7.0 → 2.11.2

package/lib/compiler/shared.js

@@ -1,86 +1,33 @@
 // Compiler functions and utilities shared across all phases
-
+// TODO: rename to paths.js and move non resolve-paths functions to somewhere else
 
 'use strict';
 
 const { searchName } = require('../base/messages');
-const { dictAdd, dictAddArray, pushToDict } = require('../base/dictionaries');
+const { dictAddArray } = require('../base/dictionaries');
 const { setProp } = require('../base/model');
 
-const dictKinds = {
-  definitions: 'absolute',
-  elements: 'element',
-  enum: 'enum',
-  foreignKeys: 'key',
-  actions: 'action',
-  params: 'param',
-};
-
-const kindProperties = {
-  // TODO: also foreignKeys ?
-  namespace: { artifacts: true }, // on-the-fly context
-  context: { artifacts: true, normalized: 'namespace' },
-  service: { artifacts: true, normalized: 'namespace' },
-  entity: { elements: true, actions: true, params: () => false },
-  select: { normalized: 'select', elements: true },
-  $join: { normalized: 'select' },
-  $tableAlias: { normalized: 'alias' }, // table alias in select
-  $self: { normalized: 'alias' }, // table alias in select
-  $navElement: { normalized: 'element' },
-  $inline: { normalized: 'element' }, // column with inline property
-  event: { elements: true },
-  type: { elements: propExists, enum: propExists },
-  aspect: { elements: propExists },
-  annotation: { elements: propExists, enum: propExists },
-  enum: { normalized: 'element' },
-  element: { elements: propExists, enum: propExists, dict: 'elements' },
-  mixin: { normalized: 'alias' },
-  action: {
-    params: () => false, elements: () => false, enum: () => false, dict: 'actions',
-  }, // no extend params, only annotate
-  function: {
-    params: () => false, elements: () => false, enum: () => false, normalized: 'action',
-  }, // no extend params, only annotate
-  key: { normalized: 'element' },
-  param: { elements: () => false, enum: () => false, dict: 'params' },
-  source: { artifacts: true },  // TODO -> $source
-  using: {},
-  extend: {
-    isExtension: true,
-    noDep: 'special',
-    elements: true, /* only for parse-cdl */
-    actions: true,  /* only for parse-cdl */
-  },
-  annotate: {
-    isExtension: true, noDep: 'special', elements: true, enum: true, actions: true, params: true,
-  },
-  builtin: {},                  // = CURRENT_DATE, TODO: improve
-  $parameters: {},              // $parameters in query entities
-};
-
-function propExists( prop, parent ) {
-  const obj = parent.returns || parent;
-  return (obj.items || obj)[prop];
-}
+const { setLink, dependsOn } = require('./utils');
 
 function artifactsEnv( art ) {
   return art._subArtifacts || Object.create(null);
 }
 
 /**
- * Main export function of this file.  Return "resolve" functions shared for phase
- * "define" and "resolve".  Argument `model` is the augmented CSN.  Optional
- * argument `environment` is a function which returns the search environment
- * defined by its argument - it defaults to the dictionary of subartifacts of
- * the argument.
+ * Main export function of this file.  Attach "resolve" functions shared for phase
+ * "define" and "resolve" to `model.$functions`, where argument `model` is the XSN.
+ *
+ * Before calling these functions, make sure that the following function
+ * in model.$volatileFunctions is set:
+ * - `environment`: a function which returns the search environment defined by
+ *    its argument, e.g. a function which returns the dictionary of subartifacts.
  *
  * @param {XSN.Model} model
- * @param {(a, b?, c?) => any} environment
- * @returns {object} Commonly used "resolve" functions.
  */
-function fns( model, environment = artifactsEnv ) {
+// TODO: yes, this function will be renamed
+function fns( model ) {
   /** @type {CSN.Options} */
-  const options = model.options || {};
+  const { options } = model;
   const {
     info, warning, error, message,
   } = model.$messageFunctions;
@@ -204,13 +151,15 @@ function fns( model, environment = artifactsEnv ) {
     },
   };
 
-  return {
+  const VolatileFns = model.$volatileFunctions;
+  Object.assign( model.$functions, {
     resolveUncheckedPath,
     resolvePath,
     resolveTypeArguments,
     defineAnnotations,
     attachAndEmitValidNames,
-  };
+  } );
+  return;
 
   function checkConstRef( art ) {
     return ![ 'builtin', 'param' ].includes( art.kind );
@@ -257,7 +206,7 @@ function fns( model, environment = artifactsEnv ) {
     // TODO: better error location if error for main
     if (elem._main.kind !== 'entity' )
       return true;              // elem not starting at entity
-    environment( art );         // sets _effectiveType on art
+    VolatileFns.environment( art );         // sets _effectiveType on art
     return !(art._effectiveType || art).target;
   }
 
@@ -345,7 +294,7 @@ function fns( model, environment = artifactsEnv ) {
                   // first step: only use _combined of real query - TODO:
                   // reject if not visible, but not allow more (!)
                   (query._combined || query._parent._combined) ||
-                  environment( user._main ? user._parent : user );
+                  VolatileFns.environment( user._main ? user._parent : user );
       }
     }
 
@@ -439,7 +388,7 @@ function fns( model, environment = artifactsEnv ) {
       }
       else {
         dependsOn( user, art._main, location );
-        environment( art, location, user );
+        VolatileFns.environment( art, location, user );
       // Without on-demand resolve, we can simply signal 'undefined "x"'
       // instead of 'illegal cycle' in the following case:
       //    element elem: type of elem.x;
@@ -513,7 +462,7 @@ function fns( model, environment = artifactsEnv ) {
   function getPathRoot( path, spec, user, env, extDict, msgArt ) {
     if (!spec.envFn && user._pathHead) {
       // TODO: not necessarily for explicit ON condition in expand
-      environment( user._pathHead ); // make sure _origin is set
+      VolatileFns.environment( user._pathHead ); // make sure _origin is set
       return user._pathHead._origin;
     }
     const head = path[0];
@@ -570,8 +519,10 @@ function fns( model, environment = artifactsEnv ) {
     if (extDict && (!spec.dollar || head.id[0] !== '$')) {
       const r = extDict[head.id];
       if (Array.isArray(r)) {
-        if (r[0].kind === '$navElement') {
-          const names = r.filter( e => !e.$duplicates)
+        if (r[0].kind === '$navElement' && r.every( e => !e._parent.$duplicates )) {
+          // only complain about ambiguous source elements if we do not have
+          // duplicate table aliases, only mention non-ambiguous source elems
+          const names = r.filter( e => !e.$duplicates )
             .map( e => `${ e.name.alias }.${ e.name.element }` );
           if (names.length) {
             error( 'ref-ambiguous', [ head.location, user ], { id: head.id, names },
@@ -657,13 +608,28 @@ function fns( model, environment = artifactsEnv ) {
           return false;
         continue;
       }
+
+      const fn = (spec.envFn && artItemsCount >= 0) ? spec.envFn : VolatileFns.environment;
+      const env = fn( art, item.location, user, spec.assoc );
+
+      // do not check any elements of the path, e.g. $session - but still don't return path-head
       if (art && art.$uncheckedElements) {
-        // do not check any elements of the path, e.g. $session
-        return art;
+        if (env && env[item.id]) // something like $user.id/$user.locale
+          return env[item.id];
+
+        // $user.foo - build our own valid path step obj
+        // Important: Don't directly modify item!
+        const obj = {
+          location: item.location,
+          kind: 'builtin',
+          name: { id: item.id, element: path.map(p => p.id).join('.') },
+        };
+        setLink(obj, art, '_parent');
+        return obj;
       }
-      const fn = (spec.envFn && artItemsCount >= 0) ? spec.envFn : environment;
-      const env = fn( art, item.location, user, spec.assoc );
+
       const sub = setLink( item, env && env[item.id] );
+
       if (!sub)
         return (sub === 0) ? 0 : errorNotFound( item, env );
       else if (Array.isArray(sub)) // redefinitions
@@ -832,7 +798,9 @@ function fns( model, environment = artifactsEnv ) {
     }
     // TODO: block should be construct._block
     if (construct.$annotations && construct.$annotations.doc )
-      art.doc = construct.$annotations.doc;
+      art.doc = construct.$annotations.doc; // e.g. through `annotate` statement in CDL
+    else if (construct.doc)
+      art.doc = construct.doc; // e.g. through `extensions` array in CSN
     if (!construct.$annotations) {
       if (!block || block.$frontend !== 'json')
         return;                 // namespace, or in CDL source without @annos:
@@ -908,127 +876,6 @@ function pathName(path) {
   return (path.broken) ? '' : path.map( id => id.id ).join('.');
 }
 
-// The link (_artifact,_effectiveType,...) usually has the artifact as value.
-// Falsy values are:
-// - undefined: not computed yet, parse error, no ref
-// - null: no valid reference, param:true if that is not allowed
-// - false (only complete ref): multiple definitions, rejected
-// - 0 (for _effectiveType only): circular reference
-function setLink( obj, value = null, prop = '_artifact' ) {
-  Object.defineProperty( obj, prop, { value, configurable: true, writable: true } );
-  return value;
-}
-
-function linkToOrigin( origin, name, parent, prop, location, silentDep ) {
-  const elem = {
-    name: { location: location || origin.name.location, id: name },
-    kind: origin.kind,
-    location: location || origin.location,
-  };
-  if (origin.name.$inferred)
-    elem.name.$inferred = origin.name.$inferred;
-  if (parent)
-    setMemberParent( elem, name, parent, prop ); // TODO: redef in template
-  setProp( elem, '_origin', origin );
-  // TODO: should we use silent dependencies also for other things, like
-  // included elements?  (Currently for $inferred: 'expand-element' only)
-  if (silentDep)
-    dependsOnSilent( elem, origin );
-  else
-    dependsOn( elem, origin, location );
-  return elem;
-}
-
-function setMemberParent( elem, name, parent, prop ) {
-  if (prop) {              // extension or structure include
-    // TODO: consider ARRAY OF and RETURNS, COMPOSITION OF type
-    if (!(prop in parent))
-      parent[prop] = Object.create(null);
-    dictAdd( parent[prop], name, elem );
-  }
-  if (parent._outer)
-    parent = parent._outer;
-  setProp( elem, '_parent', parent );
-  setProp( elem, '_main', parent._main || parent );
-  elem.name.absolute = elem._main.name.absolute;
-  if (name == null)
-    return;
-  const normalized = kindProperties[elem.kind].normalized || elem.kind;
-  [ 'element', 'alias', 'select', 'param', 'action' ].forEach( ( kind ) => {
-    if (normalized === kind)
-      elem.name[kind] = (parent.name[kind] != null && kind !== 'select' && kind !== 'alias') ? `${ parent.name[kind] }.${ name }` : name;
-
-    else if (parent.name[kind] != null)
-      elem.name[kind] = parent.name[kind];
-
-    else
-      delete elem.name[kind];
-  });
-  // try { throw new Error('Foo') } catch (e) { elem.name.stack = e; };
-}
-
-/**
- * Adds a dependency user -> art with the given location.
- *
- * @param {XSN.Artifact} user
- * @param {XSN.Artifact} art
- * @param {XSN.Location} location
- */
-function dependsOn( user, art, location ) {
-  if (!user._deps)
-    setProp( user, '_deps', [] );
-  user._deps.push( { art, location } );
-}
-
-/**
- * Same as "dependsOn" but the dependency from user -> art is silent,
- * i.e. not reported to the user.
- *
- * @param {XSN.Artifact} user
- * @param {XSN.Artifact} art
- */
-function dependsOnSilent( user, art ) {
-  if (!user._deps)
-    setProp( user, '_deps', [] );
-  user._deps.push( { art } );
-}
-
-function storeExtension( elem, name, prop, parent, block ) {
-  if (prop === 'enum')
-    prop = 'elements';
-  setProp( elem, '_block', block );
-  const kind = `_${ elem.kind }`; // _extend or _annotate
-  if (!parent[kind])
-    setProp( parent, kind, {} );
-  if (!parent[kind][prop])
-    parent[kind][prop] = Object.create(null);
-  pushToDict( parent[kind][prop], name, elem );
-}
-
-/** @type {(a: any, b: any) => boolean} */
-const testFunctionPlaceholder = () => true;
-
-// Return path step if the path navigates along an association whose final type
-// satisfies function `test`; "navigates along" = last path item not considered
-// without truthy optional argument `alsoTestLast`.
-function withAssociation( ref, test = testFunctionPlaceholder, alsoTestLast = false ) {
-  for (const item of ref.path || []) {
-    const art = item && item._artifact; // item can be null with parse error
-    if (art && art._effectiveType && art._effectiveType.target && test( art._effectiveType, item ))
-      return (alsoTestLast || item !== ref.path[ref.path.length - 1]) && item;
-  }
-  return false;
-}
-
 module.exports = {
-  dictKinds,
-  kindProperties,
   fns,
-  setLink,
-  linkToOrigin,
-  dependsOn,
-  dependsOnSilent,
-  setMemberParent,
-  storeExtension,
-  withAssociation,
 };

package/lib/compiler/utils.js

@@ -8,6 +8,9 @@
 
 'use strict';
 
+const { dictAdd, pushToDict } = require('../base/dictionaries');
+const { kindProperties } = require('./base');
+
 // for links, i.e., properties starting with an underscore '_':
 
 function pushLink( obj, prop, value ) {
@@ -38,10 +41,180 @@ function annotateWith( art, anno, location = art.location, val = true, literal =
   };
 }
 
+// TODO: define setLink() like the current setProp(), we might have setArtifactLink()
+// Do not share this function with CSN processors!
+
+// The link (_artifact,_effectiveType,...) usually has the artifact as value.
+// Falsy values are:
+// - undefined: not computed yet, parse error, no ref
+// - null: no valid reference, param:true if that is not allowed
+// - false (only complete ref): multiple definitions, rejected
+// - 0 (for _effectiveType only): circular reference
+function setLink( obj, value = null, prop = '_artifact' ) {
+  Object.defineProperty( obj, prop, { value, configurable: true, writable: true } );
+  return value;
+}
+
+/**
+ * Like `obj.prop = value`, but not contained in JSON / CSN
+ * It's important to set enumerable explicitly to false (although 'false' is the default),
+ * as else, if the property already exists, it keeps the old setting for enumerable.
+ *
+ * @param {object} obj
+ * @param {string} prop
+ * @param {any} value
+ */
+function setProp(obj, prop, value) {
+  const descriptor = {
+    value,
+    configurable: true,
+    writable: true,
+    enumerable: false,
+  };
+  Object.defineProperty( obj, prop, descriptor );
+  return value;
+}
+
+function linkToOrigin( origin, name, parent, prop, location, silentDep ) {
+  const elem = {
+    name: { location: location || origin.name.location, id: name },
+    kind: origin.kind,
+    location: location || origin.location,
+  };
+  if (origin.name.$inferred)
+    elem.name.$inferred = origin.name.$inferred;
+  if (parent)
+    setMemberParent( elem, name, parent, prop ); // TODO: redef in template
+  setProp( elem, '_origin', origin );
+  // TODO: should we use silent dependencies also for other things, like
+  // included elements?  (Currently for $inferred: 'expand-element' only)
+  if (silentDep)
+    dependsOnSilent( elem, origin );
+  else
+    dependsOn( elem, origin, location );
+  return elem;
+}
+
+function setMemberParent( elem, name, parent, prop ) {
+  if (prop) {              // extension or structure include
+    // TODO: consider nested ARRAY OF and RETURNS, COMPOSITION OF type
+    const p = parent.items || parent.targetAspect || parent;
+    if (!(prop in p))
+      p[prop] = Object.create(null);
+    dictAdd( p[prop], name, elem );
+  }
+  if (parent._outer)
+    parent = parent._outer;
+  setProp( elem, '_parent', parent );
+  setProp( elem, '_main', parent._main || parent );
+  elem.name.absolute = elem._main.name.absolute;
+  if (name == null)
+    return;
+  const normalized = kindProperties[elem.kind].normalized || elem.kind;
+  [ 'element', 'alias', 'select', 'param', 'action' ].forEach( ( kind ) => {
+    if (normalized === kind)
+      elem.name[kind] = (parent.name[kind] != null && kind !== 'select' && kind !== 'alias') ? `${ parent.name[kind] }.${ name }` : name;
+
+    else if (parent.name[kind] != null)
+      elem.name[kind] = parent.name[kind];
+
+    else
+      delete elem.name[kind];
+  });
+  // try { throw new Error('Foo') } catch (e) { elem.name.stack = e; };
+}
+
+/**
+ * Adds a dependency user -> art with the given location.
+ *
+ * @param {XSN.Artifact} user
+ * @param {XSN.Artifact} art
+ * @param {XSN.Location} location
+ */
+function dependsOn( user, art, location ) {
+  if (!user._deps)
+    setProp( user, '_deps', [] );
+  user._deps.push( { art, location } );
+}
+
+/**
+ * Same as "dependsOn" but the dependency from user -> art is silent,
+ * i.e. not reported to the user.
+ *
+ * @param {XSN.Artifact} user
+ * @param {XSN.Artifact} art
+ */
+function dependsOnSilent( user, art ) {
+  if (!user._deps)
+    setProp( user, '_deps', [] );
+  user._deps.push( { art } );
+}
+
+function storeExtension( elem, name, prop, parent, block ) {
+  if (prop === 'enum')
+    prop = 'elements';
+  setProp( elem, '_block', block );
+  const kind = `_${ elem.kind }`; // _extend or _annotate
+  if (!parent[kind])
+    setProp( parent, kind, {} );
+  // if (name === '' && prop === 'params') {
+  //   pushToDict( parent[kind], 'returns', elem ); // not really a dict
+  //   return;
+  // }
+  if (!parent[kind][prop])
+    parent[kind][prop] = Object.create(null);
+  pushToDict( parent[kind][prop], name, elem );
+}
+
+/** @type {(a: any, b: any) => boolean} */
+const testFunctionPlaceholder = () => true;
+
+// Return path step if the path navigates along an association whose final type
+// satisfies function `test`; "navigates along" = last path item not considered
+// without truthy optional argument `alsoTestLast`.
+function withAssociation( ref, test = testFunctionPlaceholder, alsoTestLast = false ) {
+  for (const item of ref.path || []) {
+    const art = item && item._artifact; // item can be null with parse error
+    if (art && art._effectiveType && art._effectiveType.target && test( art._effectiveType, item ))
+      return (alsoTestLast || item !== ref.path[ref.path.length - 1]) && item;
+  }
+  return false;
+}
+
+/**
+ * Generates an XSN path out of the given name. Path segments are delimited by a dot.
+ * Each segment will have the given location assigned.
+ *
+ * @param {CSN.Location} location
+ * @param {string} name
+ * @returns {XSN.Path}
+ */
+function splitIntoPath( location, name ) {
+  return name.split('.').map( id => ({ id, location }) );
+}
+
+/**
+ * @param {CSN.Location} location
+ * @param  {...any} args
+ */
+function augmentPath( location, ...args ) {
+  return { path: args.map( id => ({ id, location }) ), location };
+}
+
 
 module.exports = {
   pushLink,
   annotationVal,
   annotationIsFalse,
   annotateWith,
+  setLink,
+  setProp,
+  linkToOrigin,
+  dependsOn,
+  dependsOnSilent,
+  setMemberParent,
+  storeExtension,
+  withAssociation,
+  augmentPath,
+  splitIntoPath,
 };