@sap/cds-compiler 2.10.4 → 2.12.0

package/lib/compiler/shared.js

@@ -1,86 +1,32 @@
 // 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.targetAspect || obj)[prop];
-}
+const { setLink, dependsOn, pathName } = 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 ) {
-  /** @type {CSN.Options} */
-  const options = model.options || {};
+// TODO: yes, this function will be renamed
+function fns( model ) {
+  const { options } = model;
   const {
     info, warning, error, message,
   } = model.$messageFunctions;
@@ -204,13 +150,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 );
@@ -224,16 +172,25 @@ function fns( model, environment = artifactsEnv ) {
     return !(art.elements && !art.query && !art.type && !art.params);
   }
 
+  /**
+   * @returns {boolean|string}
+   */
   function checkTypeRef( art ) {
     if (art.kind === 'type' || art.kind === 'element')
       return false;
     return ![ 'entity', 'aspect', 'event' ].includes( art.kind ) || 'sloppy';
   }
 
+  /**
+   * @returns {boolean|string}
+   */
   function checkActionParamTypeRef( art ) {
     return !(art.kind === 'entity' && art._service) && checkTypeRef( art );
   }
 
+  /**
+   * @returns {boolean|string}
+   */
   function checkEventTypeRef( art ) {
     return art.kind !== 'event' && checkActionParamTypeRef( art );
   }
@@ -242,6 +199,9 @@ function fns( model, environment = artifactsEnv ) {
     return art.kind !== 'entity';
   }
 
+  /**
+   * @returns {boolean|string}
+   */
   function checkTargetRef( art ) {
     if (art.kind === 'entity' || art.kind === 'aspect')
       return false;
@@ -257,7 +217,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 +305,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 +399,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 +473,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 +530,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 },
@@ -658,31 +620,26 @@ function fns( model, environment = artifactsEnv ) {
         continue;
       }
 
-      const fn = (spec.envFn && artItemsCount >= 0) ? spec.envFn : environment;
+      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) {
-        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 sub = setLink( item, env && env[item.id] );
 
-      if (!sub)
-        return (sub === 0) ? 0 : errorNotFound( item, env );
-      else if (Array.isArray(sub)) // redefinitions
+      if (!sub) {
+        // element was not found in environment
+        if (sub === 0)
+          return 0;
+        if (art.$uncheckedElements) { // magic variable / replacement variable
+          signalNotFound( 'ref-unknown-var', [ item.location, user ], [ env ],
+                          { id: path.map(n => n.id).join('.') } );
+        }
+        else {
+          errorNotFound( item, env );
+        }
+        return null;
+      }
+      else if (Array.isArray(sub)) { // redefinitions
         return false;
+      }
 
       if (nav) {              // we have already "pseudo-followed" a managed association
         // We currently rely on the check that targetElement references do
@@ -764,7 +721,7 @@ function fns( model, environment = artifactsEnv ) {
                         { param: 'Entity $(ART) has no parameter $(MEMBER)' } );
       }
       else {
-        signalNotFound( 'ref-undefined-element', [ item.location, user ],
+        signalNotFound( spec.undefinedDef || 'ref-undefined-element', [ item.location, user ],
                         [ env ], { art: searchName( art, item.id, 'element' ) } );
       }
       return null;
@@ -847,7 +804,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:
@@ -861,7 +820,7 @@ function fns( model, environment = artifactsEnv ) {
             setProp( a, '_block', block );
             a.$priority = priority;
             if (construct !== art)
-              dictAddArray( art, annoProp, a );
+              addAnnotation( art, annoProp, a );
           }
         }
       }
@@ -912,143 +871,19 @@ function fns( model, environment = artifactsEnv ) {
       // TODO: _parent, _main is set later (if we have ElementRef), or do we
       // set _artifact?
       anno.$priority = priority;
-      dictAddArray( art, annoProp, anno );
+      addAnnotation( art, annoProp, anno );
     }
   }
 }
 
-// Return string 'A.B.C' for parsed source `A.B.C` (is vector of ids with
-// locations):
-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 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;
+// 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 = {
-  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 ) {
@@ -27,6 +30,13 @@ function annotationIsFalse( anno ) {                   // falsy, but not null (u
   return anno && (anno.val === false || anno.val === 0 || anno.val === '');
 }
 
+/**
+ * @param {XSN.Artifact} art
+ * @param {string} anno
+ * @param {XSN.Location} [location]
+ * @param {*} [val]
+ * @param {string} [literal]
+ */
 function annotateWith( art, anno, location = art.location, val = true, literal = 'boolean' ) {
   if (art[anno])  // do not overwrite user-defined including null
     return;
@@ -38,10 +48,191 @@ 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;
+}
+
+/**
+ * Return string 'A.B.C' for parsed source `A.B.C` (is vector of ids with
+ * locations).
+ *
+ * @param {XSN.Path} path
+ */
+function pathName(path) {
+  return (path.broken) ? '' : path.map( id => id.id ).join('.');
+}
+
+/**
+ * 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,
+  pathName,
+  augmentPath,
+  splitIntoPath,
 };