@sap/cds-compiler 3.5.4 → 3.6.0

package/lib/base/messages.js

@@ -664,9 +664,9 @@ const quote = {            // could be an option in the future
 
 const paramsTransform = {
   // simple convenience:
-  name: quoted,
-  id: quoted,
-  alias: quoted,
+  name: quote.double,
+  id: quote.double,
+  alias: quote.double,
   anno,
   annos: transformManyWith( anno ),
   delimited: n => quote.single( `![${ n }]` ), // represent as delimited id (TODO: double-']')
@@ -688,6 +688,7 @@ const paramsTransform = {
   line: quote.direct,
   col: quote.direct,
   value,
+  rawvalue: quote.single,
   rawvalues: transformManyWith( quote.single ),  // no 'double' quotes for strings
   othervalue: value,
   art: transformArg,
@@ -719,7 +720,7 @@ function value( val ) {
       return quote.single( val );
     }
     case 'string': {
-      // TODO: should we also shorten the string if too long?
+      // TODO: should we also shorten the string if too long? TODO: false, true, null?
       return (!val ||
               Number.parseFloat( val ).toString() === val ||
               // with quotes (TODO: use `…` with escape chars):
@@ -768,7 +769,7 @@ function transformManyWith( t, sorted ) {
 function quoted( name ) {
   if (typeof name === 'string')
     return quote.double( name );
-  throw new CompilerAssertion( `Expecting a string, not ${ name }` );
+  throw new CompilerAssertion( `Expecting a string, not ${ typeof name } (${ JSON.stringify(name) })` );
 }
 
 function tokenSymbol( token ) {
@@ -882,7 +883,7 @@ function replaceInString( text, params ) {
   parts.push( text.substring( start ) );
   const remain = (params['#']) ? [] : Object.keys( params ).filter( n => !usedParams.includes(n) );
   if (remain.length) {
-    const remains  = remain.map( n => `${ n.toUpperCase() } = ${ params[n] }` ).join(', ');
+    const remains = remain.map( n => `${ n.toUpperCase() } = ${ params[n] }` ).join(', ');
     return `${ parts.join('') }; ${ remains }`;
   }
   return parts.join('');
@@ -1197,9 +1198,15 @@ function artName( art, omit ) {
     r.push( (art.kind === 'mixin' ? 'mixin:' : 'alias:') + quoted( name.alias ) );
   if (name.param != null && omit !== 'param')
     r.push( name.param ? `param:${ quoted( name.param ) }` : 'returns' ); // TODO: join
-  if (name.element && omit !== 'element')
-    // r.push( `${ art.kind }: ${ quoted( name.element )}` ); or even better element:"assoc"/key:"i" same with enum
-    r.push( (art.kind === 'enum' ? 'enum:' : 'element:') + quoted( name.element ) );
+
+  if (name.element && omit !== 'element') {
+    if (name.select != null && !art.$inferred)
+      r.push( 'column:' + quoted( name.element ) );
+    else
+      // r.push( `${ art.kind }: ${ quoted( name.element )}` ); or even better element:"assoc"/key:"i" same with enum
+      r.push( (art.kind === 'enum' ? 'enum:' : 'element:') + quoted( name.element ) );
+  }
+
   if (art.kind === '$self')
     r.push( `alias:${ quoted( name.alias ) }` ); // should be late due to $self in anonymous aspect
   return r.join('/');
@@ -1237,7 +1244,7 @@ function homeName( art, absoluteOnly ) {
 }
 
 // The "home" for extensions is handled differently because `_artifact` is not
-// set for unknown extensions and we could have nested extensions.
+// set for unknown extensions, and we could have nested extensions.
 function homeNameForExtend( art ) {
   const kind = art.kind || 'extend';
   // TODO: fix the following - do like in collectArtifactExtensions() or
@@ -1286,252 +1293,308 @@ function homeNameForExtend( art ) {
   }
 }
 
+/**
+ * Construct a semantic location for the given CSN path.
+ * Works without a CSN model, but is less precise.
+ *
+ * Example:
+ *   path:   ["definitions", "E", "elements", "s"],
+ *   result: entity:“E”/element:“s”
+ *
+ * @param {CSN.Model} model
+ * @param {CSN.Options} options
+ * @param {CSN.Path} csnPath
+ * @return {string|null}
+ */
 function constructSemanticLocationFromCsnPath( model, options, csnPath ) {
   if (!model)
     return null;
-  // Copy because this function shift()s from the path.
-  csnPath = [ ...csnPath ];
+  let result = '';
   const csnDictionaries = [
     'args', 'params', 'enum', 'mixin', 'elements', 'actions', 'definitions',
   ];
-  const queryProps = [ 'from', 'where', 'groupBy', 'having', 'orderBy', 'limit', 'offset' ];
+  // Properties that (currently) end the semantic location.
+  const queryPropsLast = [ 'where', 'groupBy', 'having', 'orderBy', 'limit', 'offset' ];
+
+  let index = 0;
+  /** @type {CSN.PathSegment} */
+  let step = csnPath[index];
+  let currentThing = model?.[step];
+
+  function next(steps = 1) {
+    for (; steps > 0; --steps) {
+      ++index;
+      step = csnPath[index];
+      currentThing = currentThing && currentThing[step];
+    }
+  }
 
-  if (csnPath[0] === 'extensions') {
-    const ext = model.extensions && model.extensions[csnPath[1]] || {};
-    if (ext.annotate)
-      return `annotate:${ quoted(ext.annotate) }`;
-    return `extend:${ quoted(ext.extend) }`;
+  function peek(steps = 1) {
+    return csnPath[index + steps];
   }
 
-  let { query } = analyseCsnPath(csnPath, model, false);
+  // First step; always one of: -------------------------------------
 
-  const dictName = csnPath.shift();
-  const dict = model[dictName];
-  const artifactName = csnPath.shift();
-  let currentThing = dict ? dict[artifactName] : undefined;
-  let result = `${ (currentThing?.kind)
-    ? currentThing.kind
-    : (dictName === 'vocabularies'
-      ? 'annotation'
-      : 'artifact') }:${ quoted(artifactName) }`;
+  if (step === 'definitions') {
+    next(); // "definitions"
+    const kind = currentThing?.kind || 'artifact';
+    result += `${ kind }:${ quoted(step) }`;
+  }
+  else if (step === 'vocabularies') {
+    next(); // dictionary name
+    if (index < csnPath.length)
+      result += `annotation:${ quoted(csnPath[index]) }`;
+    else
+      result += 'vocabularies';
+  }
+  else if (step === 'extensions') {
+    next(); // "extensions"
+    if (!currentThing) {
+      result += `extension:${ step }`;
+    }
+    else {
+      const name = currentThing.annotate || currentThing.extend;
+      const kind = currentThing.annotate ? 'annotate' : 'extend';
+      result += `${ kind }:${ quoted(name) }`;
+    }
+  }
 
   if (!currentThing)
     return result;
 
-  if (query)
-    query = queryDepth(currentThing.query || { SELECT: currentThing.projection }, query);
-
-  const elements = [];
-  let inCsnDict = false;
-  let inElement = false;
-  let inAction = false;
-  let inParam = false;
-  let inKeys = false;
-  let inRef = false;
-  let inEnum = false;
-  let inQuery = false;
-  let inColumn = false;
-  let inMixin = false;
-  let inItems = false;
-  let currentAnno = null;
-
-  // for top level actions
-  if (currentThing.kind === 'action')
-    inAction = true;
-  for (const [ index, step ] of csnPath.entries()) {
-    currentThing = currentThing[step];
-    if (csnDictionaries.includes(step) && !inCsnDict) {
-      inCsnDict = true;
-      switch (step) {
-        case 'elements':
-          if (!inElement) {
-            inElement = true;
-            // do not print intermediate items
-            inItems = false;
-          }
-          break;
-        case 'actions':
-          inAction = true;
-          break;
-        case 'params':
-          inParam = true;
-          break;
-        case 'enum':
-          inElement = false;
-          inEnum = true;
-          break;
-        case 'mixin':
-          inMixin = true;
-          inQuery = false;
-          break;
-        default:
-          if (inElement) {
-            // close element
-            result += element();
-            inElement = false;
-          }
-      }
-    }
-    else if ( inQuery ) {
-      if (step === 'SELECT') {
-        if (!csnPath[index + 1]) {
-          result += select();
-        }
-        // only print last query prop for paths like
-        // [... 'query', 'SELECT', 'from', 'SELECT', 'elements', 'struct'] -> select:2/element:"struct"
-        // no from in the semantic location in this case
-        else if (queryProps.includes(csnPath[index + 1]) && (!csnPath[index + 2] || query.isOnlySelect)) {
-          const clause = csnPath[index + 1];
-          result += select();
-          result += `/${ clause }`;
+  let selectDepth = (csnPath[0] !== 'extensions') ? queryDepthForMessage(csnPath, model, currentThing) : null;
+
+  // Artifact ref -------------------------------------
+
+  next();
+  while (index < csnPath.length) {
+    if (step === 'elements' || step === 'items') {
+      if (index >= csnPath.length - 1)
+        break; // last segment
+
+      const elementHierarchy = [];
+      while (index < (csnPath.length - 1) && (step === 'items' || step === 'elements')) {
+        if (step === 'elements') {
+          next();
+          elementHierarchy.push(step);
         }
+        next();
       }
-      else if (step === 'columns') {
-        result += select();
-        result += '/column';
-        inColumn = true;
-        inQuery = false;
-      }
-      else if (inElement) {
-        result += select();
-        elements.push(step);
-        inQuery = false;
-      }
+      if (elementHierarchy.length > 0)
+        result += `/element:${quoted(elementHierarchy.join('.'))}`;
+      // no trailing /elements or /items
+      continue;
     }
-    else if ( inMixin ) {
-      if (step === 'on') {
-        result += '/on';
-        break;
+    else if (step === 'actions') {
+      next(); // "actions"
+      if (index < csnPath.length) {
+        const kind = currentThing?.kind || 'action';
+        result += `/${ kind }:${ quoted(csnPath[index]) }`;
       }
-      else {
-        result += selectAndMixin(step);
+      else { // actions is last segment
+        result += '/actions';
       }
     }
-    else if (inEnum) {
-      result += elementAndEnum(step);
+    else if (step === 'params') {
+      dictEntry('param');
+    }
+    else if (step === 'enum' || step === 'mixin') {
+      dictEntry(step);
     }
-    else if (!inElement && step === 'query') {
-      inQuery = true;
+    else if (step === 'cast') {
+      // To shorten the location, only print 'cast' if it's not a
+      // redirection target.
+      if (csnPath[index+1] !== 'on' && csnPath[index+1] !== 'target') {
+        result += '/cast';
+      }
     }
-    else if (inElement && step === 'keys') {
-      // close element
-      result += `${ element() }/key`;
-      inElement = false;
-      inKeys = true;
+    // @ts-ignore
+    else if (queryPropsLast.includes(step)) {
+      result += '/' + step;
+      break; // always last step
     }
-    else if (inElement && step === 'on') {
-      // close element
-      result += `${ element() }/on`;
-      inElement = false;
+    else if (step === 'on') {
+      result += '/on';
       break;
     }
-    else if (inElement && step === 'items') {
-      // this is an element called items
-      if (csnPath[index - 1] === 'elements' && elements[elements.length - 1] !== 'elements') {
-        elements.push(step);
-      }
-      else {
-        inElement = false;
-        inItems = true;
-      }
+    else if (step === 'target') {
+      if (currentThing)
+        result += '/target:' + quoted(currentThing);
+      else
+        result += '/target';
+      break;
     }
-    else if (inElement && step === 'elements') {
-      // this is an element called elements
-      if (csnPath[index - 1] === 'elements')
-        elements.push(step);
+    else if (step === 'xpr' || step === 'ref' || step === 'as') {
+      break; // don't go into xprs, refs, aliases, etc.
     }
-    else if (inItems && step === 'elements') {
-      inElement = true;
-      inItems = false;
+    else if (step === 'returns') {
+      result += '/returns';
     }
-    else if ( inKeys || inColumn) {
-      if (typeof step === 'number') {
-        if (currentThing.as)
-          result += `:${ quoted(currentThing.as) }`;
-        else if (inRef)
-          result += `:${ quoted(currentThing) }`;
-        else if (currentThing.ref)
-          result += `:${ quoted(currentThing.ref.map(r => (r.id ? r.id : r)).join('.')) }`;
-        else
-          return '';
-
-        break;
-      }
-      if ( step === 'ref')
-        inRef = true;
+    else if (step === 'query' || step === 'projection') {
+      if (!queryPath())
+        break; // something failed
+      continue;
     }
-    else if (inAction && step === 'returns') {
-      result += `/${ step }`;
+    else if (step === 'cardinality') {
+      // ignore; all messages pointing to cardinality already mention "cardinality".
+      // Also, no annotations on cardinalities.
       break;
     }
-    else if (inCsnDict) {
-      if (inElement)
-        elements.push(step);
-      else if (inParam)
-        result += param(step);
-
-      else if (inAction)
-        result += func(step);
-
-      inCsnDict = false;
+    else if (step === 'type') {
+      break; // we don't go into types
+    }
+    else if (step === 'keys') { // e.g. association foreign keys
+      next(); // "keys"
+      if (index < csnPath.length) {
+        const key = aliasOrReference();
+        result += `/key:${ key ? quoted(key) : step }`;
+      }
+      break;
     }
     else if (step[0] === '@') {
-      currentAnno = step;
-      break; // we don't go inside annotation values
+      // Annotations are always the last step.
+      // Nothing comes after them, everything is user defined.
+      result += `/${ quoted(csnPath[index]) }`;
+      break;
+    }
+    else {
+      if (options.testMode)
+        throw new CompilerAssertion(`semantic location: Missing segment: ${ csnPath[index] } for path ${ JSON.stringify( csnPath) }`);
+      break;
     }
+    next();
   }
-  if ( inItems )
-    result += `${ element() }/items`;
-  else if ( inElement )
-    result += element();
-  if ( currentAnno )
-    result += `/${ quoted(currentAnno) }`;
+
   return result;
 
-  function select() {
-    let s = '/select';
-    s += query.isOnlySelect ? '' : `:${ query.depth }`;
-    return s;
-  }
-  function selectAndMixin( name ) {
-    return `${ select() }/mixin:${ quoted(name) }`;
-  }
-  function element() {
-    return `/element:${ quoted(elements.join('.')) }`;
-  }
-  function param( name ) {
-    return `/param:${ quoted(name) }`;
-  }
-  function func( name ) {
-    if (currentThing?.kind)
-      return `/${ currentThing.kind }:${ quoted(name) }`;
-    return `/action:${ quoted(name) }`;
-  }
-  function elementAndEnum( name ) {
-    return `${ element() }/enum:${ quoted(name) }`;
+  function dictEntry( prefix ) {
+    next(); // dictionary name
+    if (index < csnPath.length)
+      result += `/${ prefix }:${ quoted(csnPath[index]) }`;
   }
 
   /**
-   * Traverse rootQuery until targetQuery is found and count the depth,
-   * check if targetQuery is only select in entity.
+   * @return {string}
    */
-  function queryDepth( rootQuery, targetQuery ) {
-    let targetQueryDepth = 1;
-    let totalQueryDepth = 0;
-
-    let isFound = false;
-    traverseQuery(rootQuery, null, null, (q, querySelect) => {
-      if ( querySelect )
-        totalQueryDepth += 1;
-      if ( querySelect && !isFound)
-        targetQueryDepth += 1;
-      if (q === targetQuery)
-        isFound = true;
-    });
-    return { depth: targetQueryDepth, isOnlySelect: totalQueryDepth === 1 };
+  function currentRefName() {
+    if (currentThing?.id)
+      return currentThing?.id;
+    else if (currentThing?.as)
+      return currentThing?.as;
+    else if (typeof currentThing === 'string')
+      return currentThing;
+    return undefined;
+  }
+
+  function aliasOrReference() {
+    if (!currentThing?.as && currentThing?.ref) {
+      // Create implicit alias.
+      const { ref } = currentThing;
+      const name = ref[ref.length - 1]?.id || ref[ref.length - 1];
+      if (csnPath[index + 1] === 'ref' && csnPath[index + 2] === ref.length - 1) {
+        // if the next ref points to the implicit alias, consume it to avoid duplicate names.
+        next(2);
+      }
+      return name;
+    }
+    return currentRefName();
+  }
+
+  function queryPath() {
+    next();
+    while (index < csnPath.length) {
+      if (step === 'SELECT' || step === 'SET') {
+        if (selectDepth > 0) {
+          // Once inside a SELECT, go to the "last" SELECT. Only print path steps after
+          // the last SELECT, e.g. "columns".
+          for (let j = csnPath.length - 1; j > index; --j) {
+            // @ts-ignore
+            if (csnPath[j] === 'SELECT' && !csnDictionaries.includes(csnPath[j-1])) {
+              next(j - index); // found last SELECT
+              break;
+            }
+          }
+          result += `/select:${ selectDepth }`;
+        } else {
+          result += '/select';
+        }
+      }
+      else if (step === 'from') {
+        // Don't check for alias, possibly confuses users.
+        result += '/from';
+      }
+      else if (step === 'columns') {
+        next();
+        if (index >= csnPath.length)
+          continue; // no column name
+
+        let elementHierarchy = [];
+
+        // Concat column+expand/inline to get a name similar to elements.
+        do {
+          if (currentThing?.inline)
+            elementHierarchy.push(quote.angle(step + 1));
+          else if (currentThing === '*')
+            elementHierarchy.push(quote.angle(currentThing));
+          else
+            elementHierarchy.push(aliasOrReference());
+
+          if (peek() === 'expand' || peek() === 'inline') {
+            next(); // skip expand/inline
+            next(); // go to next column
+          } else {
+            break;
+          }
+        } while (index < csnPath.length);
+
+        if (elementHierarchy.length > 0)
+          result += `/column:${ quoted(elementHierarchy.join('.')) }`;
+      }
+      else if(step === 'args') {
+        // Should only be reached for cases, where no SELECT in a union is picked.
+        next(); // skip index
+      }
+      else {
+        return true;
+      }
+      next();
+    }
+    return true;
   }
 }
 
+/**
+ * Traverse the view's query until targetQuery is found and count the depth.
+ * If there is only one or no query at all, returns `0` so that the semantic
+ * location knows it does not need to print the query index.
+ *
+ * @param {CSN.Path} csnPath
+ * @param {CSN.Model} model
+ * @param {CSN.Artifact} view
+ * @return {number}
+ */
+function queryDepthForMessage( csnPath, model, view ) {
+  const { query: targetQuery } = analyseCsnPath(csnPath, model, false);
+  if (!targetQuery)
+    return 0;
+  const rootQuery = view.query || { SELECT: view.projection };
+  let depth = 1;
+  let totalDepth = 0;
+  let isFound = false;
+  traverseQuery(rootQuery, null, null, (q, querySelect) => {
+    if (querySelect) {
+      totalDepth += 1;
+      if (!isFound)
+        depth += 1;
+    }
+    if (q === targetQuery)
+      isFound = true;
+  });
+  if (totalDepth > 1)
+    return depth;
+  return 0;
+}
+
 /**
  * Get the explanation string for the given message-id.
  * Ensure to have called hasMessageExplanation() before.
@@ -1587,5 +1650,7 @@ module.exports = {
   explainMessage,
   hasMessageExplanation,
   messageIdsWithExplanation,
+  // for tests only
   constructSemanticLocationFromCsnPath,
+  homeName,
 };

package/lib/base/optionProcessorHelper.js

@@ -641,8 +641,15 @@ function createOptionProcessor() {
     // hard-coded option dependencies (they disappear with command)
     return result;
 
-    // Verify parameter value 'param' against option definition 'opt'. Return an error
-    // string or false for an accepted param. Use 'prefix' when mentioning the option name.
+    /**
+     * Verify parameter value 'param' against option definition 'opt'. Return an error
+     * string or false for an accepted param. Use 'prefix' when mentioning the option name.
+     *
+     * @param param
+     * @param opt
+     * @param prefix
+     * @return {string|boolean}
+     */
     function verifyOptionParam( param, opt, prefix ) {
       if (opt.param) {
         // Parameter is required for this option

package/lib/base/shuffle.js

@@ -0,0 +1,50 @@
+// Return shuffle functions using pseudo random functions
+
+// By <https://github.com/bryc/code/blob/c97a26ad27a9f9d4f48cd3307fd8ee6f1772d4eb/jshash/PRNGs.md>:
+
+// The random seed must be an integer between 0 and 4294967295 (or 1 and 4294967296  = 2**32)
+function shuffleGen( seed ) {
+  return (Number.isSafeInteger( seed ) && seed > 0)
+    ? { shuffleArray, shuffleDict }
+    : { shuffleArray: a => a, shuffleDict: d => d };
+
+  function random() {           // from function mulberry32() in doc above
+    seed = seed + 0x6D2B79F5 | 0;
+    let t = Math.imul( seed ^ seed >>> 15, 1 | seed );
+    t = t + Math.imul( t ^ t >>> 7, 61 | t ) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  }
+
+  /**
+   * Shuffles array in place.
+   * https://en.wikipedia.org/wiki/Fisher–Yates_shuffle#The_modern_algorithm
+   *
+   * @param {Array} array items An array containing the items.
+   */
+  function shuffleArray( array ) {
+    let i = array.length;
+    while (i > 1) {
+      const j = Math.floor( random() * i );
+      --i;
+      const temp = array[i];
+      array[i] = array[j];
+      array[j] = temp;
+    }
+    return array;
+  }
+
+  /**
+   * Return a shuffled version of `dict`.
+   */
+  function shuffleDict( dict ) {
+    if (!dict)
+      return dict;
+    const names = shuffleArray( Object.keys( dict ) );
+    const r = Object.create( null );
+    for (const n of names)
+      r[n] = dict[n];
+    return r;
+  }
+}
+
+module.exports = shuffleGen;