@sap/cds-compiler 6.2.2 → 6.3.4

package/lib/checks/validator.js

@@ -42,7 +42,6 @@ const checkForInvalidTarget = require('./invalidTarget');
 const { validateAssociationsInItems } = require('./arrayOfs');
 const checkQueryForNoDBArtifacts = require('./queryNoDbArtifacts');
 const checkExplicitlyNullableKeys = require('./nullableKeys');
-const nonexpandableStructuredInExpression = require('./nonexpandableStructured');
 const existsMustEndInAssoc = require('./existsMustEndInAssoc');
 const forbidAssocInExists = require('./existsExpressionsOnlyForeignKeys');
 const checkPathsInStoredCalcElement = require('./checkPathsInStoredCalcElement');
@@ -56,20 +55,20 @@ const featureFlags = require('./featureFlags');
 const { timetrace } = require('../utils/timetrace');
 
 const forRelationalDBMemberValidators
-= [
+  = [
   // For HANA CDS specifically, reject any default parameter values, as these are not supported.
-  rejectParamDefaultsInHanaCds,
-  checkTypeIsScalar,
-  checkDecimalScale,
-  checkExplicitlyNullableKeys,
-  managedWithoutKeys,
-  warnAboutDefaultOnAssociationForHanaCds,
-  // sql.prepend/append
-  checkSqlAnnotationOnElement,
-  // no temporal annotations on calc elements
-  rejectAnnotationsOnCalcElement,
-  checkElementTypeDefinitionHasType,
-];
+    rejectParamDefaultsInHanaCds,
+    checkTypeIsScalar,
+    checkDecimalScale,
+    checkExplicitlyNullableKeys,
+    managedWithoutKeys,
+    warnAboutDefaultOnAssociationForHanaCds,
+    // sql.prepend/append
+    checkSqlAnnotationOnElement,
+    // no temporal annotations on calc elements
+    rejectAnnotationsOnCalcElement,
+    checkElementTypeDefinitionHasType,
+  ];
 
 const forRelationalDBArtifactValidators = [
   checkPrimaryKey,
@@ -87,7 +86,6 @@ const forRelationalDBCsnValidators = [
   checkCdsMap,
   existsMustEndInAssoc,
   forbidAssocInExists,
-  nonexpandableStructuredInExpression,
   navigationIntoMany,
   checkPathsInStoredCalcElement,
   featureFlags,
@@ -103,35 +101,35 @@ const forRelationalDBQueryValidators = [
 ];
 
 const forOdataMemberValidators
-= [
+  = [
   // OData allows only simple values, no expressions or functions
-  validateDefaultValues,
-  managedWithoutKeys,
-];
+    validateDefaultValues,
+    managedWithoutKeys,
+  ];
 
 const forOdataArtifactValidators
-= [
+  = [
   // actions and functions are not of interest for the database
-  checkActionOrFunction,
-  // arrays are just CLOBs/LargeString for the database,
-  // no inner for the array structure is of interest for the database
-  // NOTE: moved to the renderer for a while
-  // TODO: Re-enable this code and remove the duplicated code from the renderer.
-  //       Not possible at the moment, because running this at the beginning of
-  //       the renderer does not work because the enricher can't handle certain
-  //       OData specifics.
-  // checkChainedArray,
-  checkReadOnlyAndInsertOnly,
-];
+    checkActionOrFunction,
+    // arrays are just CLOBs/LargeString for the database,
+    // no inner for the array structure is of interest for the database
+    // NOTE: moved to the renderer for a while
+    // TODO: Re-enable this code and remove the duplicated code from the renderer.
+    //       Not possible at the moment, because running this at the beginning of
+    //       the renderer does not work because the enricher can't handle certain
+    //       OData specifics.
+    // checkChainedArray,
+    checkReadOnlyAndInsertOnly,
+  ];
 
-const forOdataCsnValidators = [ checkCdsMap, nonexpandableStructuredInExpression ];
+const forOdataCsnValidators = [ checkCdsMap ];
 
 const forOdataQueryValidators = [];
 
 const commonMemberValidators
-= [ validateOnCondition, validateForeignKeys,
-  validateAssociationsInItems, checkForInvalidTarget,
-  checkVirtualElement, checkManagedAssoc ];
+  = [ validateOnCondition, validateForeignKeys,
+    validateAssociationsInItems, checkForInvalidTarget,
+    checkVirtualElement, checkManagedAssoc ];
 
 // TODO: checkManagedAssoc is a forEachMemberRecursively!
 const commonArtifactValidators = [
@@ -202,8 +200,6 @@ function getDBCsnValidators( options ) {
     validations.push(checkForParams.csnValidator);
   if (options.sqlDialect === 'h2' || options.sqlDialect === 'postgres')
     validations.push(checkForHanaTypes);
-  if (options.transformation === 'effective' && options.effectiveServiceName)
-    validations.push(assertNoAssocUsageOutsideOfService);
 
   return validations;
 }
@@ -232,6 +228,9 @@ function forRelationalDB( csn, that ) {
                      },
                      (artifact, artifactName) => {
                        if (that.options.transformation === 'effective') {
+                         if (that.options.effectiveServiceName)
+                           assertNoAssocUsageOutsideOfService.bind(that)(artifact, artifactName);
+
                          forEachMemberRecursively(artifact, checkAnnotationExpression.bind(that), [ 'definitions', artifactName ], false, {
                            skipArtifact: a => a.returns || (a.params && !a.query),
                          });

package/lib/compiler/assert-consistency.js

@@ -602,7 +602,7 @@ function assertConsistency( model, stage ) {
     cardinality: {
       kind: true,
       requires: [ 'location' ],
-      optional: [ 'sourceMin', 'sourceMax', 'targetMin', 'targetMax' ],
+      optional: [ 'sourceMin', 'sourceMax', 'targetMin', 'targetMax', '$inferred' ],
     },
     sourceMin: { test: isNumberVal },
     sourceMax: { test: isNumberVal, also: [ '*' ] },

package/lib/compiler/checks.js

@@ -116,13 +116,21 @@ function check( model ) {
       return;
 
     const isVirtual = parentProps.virtual?.val || elem.virtual?.val;
+    const typeName = elem._effectiveType?.name?.id;
     if (isVirtual) {
       error( 'def-unexpected-key', [ (parentProps.key || elem.key).location, elem ],
-             { '#': 'virtual', prop: 'key' } );
+             { '#': 'virtual', keyword: 'key' } );
     }
-    else if (elem._effectiveType?.name?.id === 'cds.Map') {
+    else if (typeName === 'cds.Map') {
       error( 'def-unexpected-key', [ elem.type?.location || elem.location, elem ],
-             { '#': 'invalidType', prop: 'key', type: 'cds.Map' } );
+             { '#': 'invalidType', keyword: 'key', type: typeName } );
+    }
+    else if (typeName === 'cds.LargeString' ||
+        typeName === 'cds.Vector' ||
+        typeName === 'cds.hana.CLOB' ||
+        typeName === 'cds.LargeBinary') {
+      warning( 'def-unsupported-key', [ elem.type?.location || elem.location, elem ],
+               { '#': 'type', keyword: 'key', type: typeName } );
     }
   }
 
@@ -704,12 +712,15 @@ function check( model ) {
    *
    * @param {any} xpr The expression to check
    * @param {XSN.Artifact} user User for semantic location
+   * @param {any} _parentExpr
    * @param {string} [context] where the expression is used, e.g. 'anno'
    */
-  function checkGenericExpression( xpr, user, context ) {
+  function checkGenericExpression( xpr, user, _parentExpr, context ) {
     if (context !== 'anno')
       checkExpressionNotVirtual( xpr, user );
-    checkExpressionAssociationUsage( xpr, user, false );
+    checkExpressionAssociationUsage( xpr, user, {
+      context, rejectManaged: context === 'anno', rejectUnmanaged: true,
+    } );
     if (xpr.op?.val === 'cast') {
       requireExplicitTypeInSqlCast( xpr, user );
       checkTypeCast( xpr, user );
@@ -730,7 +741,7 @@ function check( model ) {
 
     visitExpression( elem.on, elem, (xpr, user) => {
       checkExpressionNotVirtual( xpr, user );
-      checkExpressionAssociationUsage( xpr, user, true );
+      checkExpressionAssociationUsage( xpr, user, null );
 
       if (xpr._artifact?._effectiveType?.name.id === 'cds.Map') {
         error( 'ref-unexpected-map', [ xpr.location, user ], { '#': 'onCond', type: 'cds.Map' } );
@@ -744,7 +755,9 @@ function check( model ) {
   }
 
   function checkSelectItemValue( elem ) {
-    checkExpressionAssociationUsage( elem.value, elem, false );
+    checkExpressionAssociationUsage( elem.value, elem, {
+      context: 'query', rejectManaged: false, rejectUnmanaged: true,
+    } );
     checkVirtualSelectItemChangeForV6( elem );
     // To avoid duplicate messages, only run this check if the type wasn't inferred from
     // the cast, as otherwise we will check it twice (once here, once via element).
@@ -753,8 +766,8 @@ function check( model ) {
       checkTypeCast( elem.value, elem );
       checkTypeArguments( elem.value, elem );
     }
-    visitSubExpression( elem.value, elem, (xpr) => {
-      checkGenericExpression( xpr, elem );
+    visitSubExpression( elem.value, elem, (xpr, user, parentExpr) => {
+      checkGenericExpression( xpr, elem, parentExpr, 'query' );
     } );
   }
 
@@ -811,7 +824,8 @@ function check( model ) {
         // For inferred (e.g. included) calc elements, this error is already emitted at the origin.
         // And users can't change structured to non-structured elements.
         if (!elem.$inferred && xpr._artifact._effectiveType?.elements) {
-          error( 'ref-unexpected-structured', [ sourceLoc, elem ], { '#': 'expr' } );
+          error( 'ref-unexpected-structured', [ sourceLoc, elem ],
+                 { '#': 'struct-expr', elemref: xpr } );
         }
         else if (xpr._artifact.target !== undefined && (!lastStep.where || isStored)) {
           // Allow using an association _with filter_, but only for on-read calculated elements.
@@ -884,10 +898,11 @@ function check( model ) {
    *
    * @param {any} xpr The expression to check
    * @param {XSN.Artifact} user
-   * @param {boolean} allowAssocTail
+   * @param {{context: string, rejectUnmanaged, rejectManaged}|null} [rejectAssocTail]
+   *        Context where association tails are not allowed.
    * @returns {void}
    */
-  function checkExpressionAssociationUsage( xpr, user, allowAssocTail ) {
+  function checkExpressionAssociationUsage( xpr, user, rejectAssocTail = null ) {
     if (!xpr.args)
       return;
 
@@ -902,12 +917,18 @@ function check( model ) {
       const op = getBinaryOp( xpr );
       for (const arg of args) {
         if (arg && !(op?.val !== '=' && isDollarSelfOrProjectionOperand( arg )))
-          checkExpressionIsNotAssocOrSelf( arg, user, allowAssocTail );
+          checkExpressionIsNotAssocOrSelf( arg, user, rejectAssocTail );
       }
     }
   }
 
-  function checkExpressionIsNotAssocOrSelf( arg, user, allowAssocTail ) {
+  /**
+   * @param arg
+   * @param {XSN.Artifact} user
+   * @param {{context: string, rejectUnmanaged, rejectManaged}|null} [rejectAssocTail]
+   *        Context where association tails are not allowed.
+   */
+  function checkExpressionIsNotAssocOrSelf( arg, user, rejectAssocTail ) {
     // Arg must not be an association and not $self
     // Only if path is not approved exists path (that is non-query position)
     if (arg.path && arg.$expected !== undefined) { // not 'approved-exists'
@@ -916,9 +937,17 @@ function check( model ) {
         error( 'ref-unexpected-assoc', [ arg.location, user ], { '#': variant } );
       }
     }
-    else if (!allowAssocTail && isAssociationOperand( arg )) {
-      const variant = isComposition( model, arg._artifact ) ? 'expr-comp' : 'expr';
-      error( 'ref-unexpected-assoc', [ arg.location, user ], { '#': variant } );
+    else if (rejectAssocTail && isAssociationOperand( arg )) {
+      if (rejectAssocTail.rejectManaged && rejectAssocTail.rejectUnmanaged ||
+          rejectAssocTail.rejectManaged && arg._artifact.keys ||
+          rejectAssocTail.rejectUnmanaged && arg._artifact.on) {
+        // only a few contexts have special message
+        const context = rejectAssocTail.context === 'query' && 'query-' ||
+          rejectAssocTail.context === 'anno' && 'anno-' ||
+          '';
+        const variant = isComposition( model, arg._artifact ) ? 'expr-comp' : 'expr';
+        error( 'ref-unexpected-assoc', [ arg.location, user ], { '#': `${ context }${ variant }` } );
+      }
     }
   }
 
@@ -1105,7 +1134,7 @@ function check( model ) {
    */
   function checkAnnotationExpressions( anno, art ) {
     if (anno.$tokenTexts) {
-      checkGenericExpression( anno, art, 'anno' );
+      checkGenericExpression( anno, art, null, 'anno' );
     }
     else if (anno.literal === 'array') {
       anno.val.forEach( val => checkAnnotationExpressions( val, art ) );

package/lib/compiler/extend.js

@@ -75,7 +75,7 @@ function extend( model ) {
   } );
 
   const includesNonShadowedFirst
-      = isDeprecatedEnabled( model.options, '_includesNonShadowedFirst' );
+    = isDeprecatedEnabled( model.options, '_includesNonShadowedFirst' );
 
   sortModelSources();
   const extensionsDict = Object.create( null ); // TODO TMP

package/lib/compiler/index.js

@@ -183,7 +183,7 @@ function compileX( filenames, dir = '', options = {}, fileCache = Object.create(
   return all.then( () => {
     options.abortSignal?.throwIfAborted();
     moduleLayers.setLayers( input.sources );
-    return compileDoX( model );
+    return compileDoX( model ); // also async
   } );
 
   // Read file `filename` and parse its content, return messages
@@ -303,7 +303,7 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
   }
 
   moduleLayers.setLayers( a.sources );
-  return compileDoX( model );
+  return compileDoXSync( model );
 
   // Read file `filename` and parse its content, return messages
   function readAndParseSync( filename, cb ) {
@@ -423,7 +423,7 @@ function compileSourcesX( sourcesDict, options = {} ) {
   }
   moduleLayers.setLayers( sources );
 
-  return compileDoX( model );
+  return compileDoXSync( model );
 }
 
 /**
@@ -457,8 +457,8 @@ function recompileX( csn, options ) {
 
   sources[file] = parseCsn.augment( csn, file, options, model.$messageFunctions );
   moduleLayers.setLayers( sources );
-  const compiled = compileDoX( model ); // calls throwWithError()
-  if (options.messages)         // does not help with exception in compileDoX()
+  const compiled = compileDoXSync( model ); // calls throwWithError()
+  if (options.messages)         // does not help with exception in compileDoXSync()
     deduplicateMessages( options.messages ); // TODO: do better
   return compiled;
 }
@@ -467,10 +467,12 @@ function recompileX( csn, options ) {
  * On the given model (AST like CSN) run the definer, resolver as well as semantic checks.
  * Creates an augmented CSN (XSN) and returns it.
  *
+ * This is the non-interruptible version of `compileDoX()` and can be used in non-`async` functions.
+ *
  * @param {object} model AST like CSN generated e.g. by `parsers.parseCdl()`
  * @returns {XSN.Model} Augmented CSN (XSN)
  */
-function compileDoX( model ) {
+function compileDoXSync( model ) {
   const { options } = model;
   const { throwWithError } = model.$messageFunctions;
   if (!options.testMode)
@@ -512,6 +514,61 @@ function compileDoX( model ) {
   return propagator.propagate( model );
 }
 
+/**
+ * On the given model (AST like CSN) run the definer, resolver as well as semantic checks.
+ * Creates an augmented CSN (XSN) and returns it.
+ *
+ * @param {object} model AST like CSN generated e.g. by `parsers.parseCdl()`
+ * @returns {XSN.Model} Augmented CSN (XSN)
+ */
+async function compileDoX( model ) {
+  const { options } = model;
+  const { throwWithError } = model.$messageFunctions;
+  if (!options.testMode)
+    model.meta = {}; // provide initial central meta object
+
+  checkRemovedDeprecatedFlags( options, model.$messageFunctions );
+
+  if (options.parseOnly) {
+    throwWithError();
+    return model;
+  }
+  model.$functions = {};
+  fns( model );                 // attach (mostly) paths functions
+  define( model );
+  await checkAsyncAbortFlag( options.abortSignal );
+
+  // do not run the resolver in parse-cdl mode or we get duplicate annotations, etc.
+  // TODO: do not use this function for parseCdl anyway…
+  if (options.parseCdl) {
+    finalizeParseCdl( model );
+    throwWithError();
+    return model;
+  }
+
+  for (const phase of [ extend, generate, kickStart, populate ]) {
+    phase( model );
+    // eslint-disable-next-line no-await-in-loop
+    await checkAsyncAbortFlag( options.abortSignal );
+  }
+
+  model.definitions = model.$functions.shuffleDict( model.definitions );
+  // Shuffling extensions is more difficult due to intra-file extensions of same artifact
+  // TODO: think about making this work
+
+  for (const phase of [ resolve, tweakAssocs, assertConsistency, check ]) {
+    phase( model );
+    // eslint-disable-next-line no-await-in-loop
+    await checkAsyncAbortFlag( options.abortSignal );
+  }
+
+  throwWithError();
+  if (options.lintMode)
+    return model;
+
+  return propagator.propagate( model );
+}
+
 /**
  * Process an array of `filenames`.  Returns an object with properties:
  *  - `sources`: dictionary which has a filename as key (value is irrelevant)
@@ -595,6 +652,31 @@ function createSourcesDict( filenames, filenameMap, dir ) {
   return { sources, files, repeated };
 }
 
+/**
+ * An `await`able function to fake a real asynchronous event.
+ *
+ * @returns {Promise<unknown>}
+ */
+async function waitForNextEventLoopIteration() {
+  return new Promise( ( r ) => {
+    setTimeout( r, 0 );
+  });
+}
+
+/**
+ * An actual async function that uses `setTimeout()` to allow the Node event loop to
+ * start its next iteration, but only if the `abortSignal` is defined.
+ *
+ * @param {AbortSignal?} abortSignal
+ * @returns {Promise<void>}
+ */
+async function checkAsyncAbortFlag( abortSignal ) {
+  if (!abortSignal)
+    return;
+  await waitForNextEventLoopIteration();
+  abortSignal.throwIfAborted();
+}
+
 module.exports = {
   parseX,
   compileX,

package/lib/compiler/populate.js

@@ -92,7 +92,7 @@ function populate( model ) {
   let newAutoExposed = [];
 
   const ignoreSpecifiedElements
-        = isDeprecatedEnabled( model.options, 'ignoreSpecifiedQueryElements' );
+    = isDeprecatedEnabled( model.options, 'ignoreSpecifiedQueryElements' );
 
   forEachDefinition( model, traverseElementEnvironments );
   while (newAutoExposed.length) {

package/lib/compiler/resolve.js

@@ -430,10 +430,7 @@ function resolve( model ) {
       }
       else if (!allowedInMain || !isTopLevelElement) {
         warning( 'def-unsupported-key', [ art.key.location, art ],
-                 { '#': allowedInMain ? 'sub' : 'std', keyword: 'key' }, {
-                   std: '$(KEYWORD) is only supported for elements in an entity or an aspect',
-                   sub: '$(KEYWORD) is only supported for top-level elements',
-                 } );
+                 { '#': allowedInMain ? 'sub' : 'kind', keyword: 'key' } );
       }
     }
 
@@ -905,10 +902,13 @@ function resolve( model ) {
     }
     else if (effectiveType( art )?.elements && !art.$inferred) {
       // For inferred (e.g. included) calc elements, this error is already emitted at the origin.
-      if (art.type)
+      if (art.type) {
         error( 'type-unexpected-structure', [ art.type.location, art ], { '#': 'calc' } );
-      else
-        error( 'ref-unexpected-structured', [ art.value.location, art ], { '#': 'expr' } );
+      }
+      else {
+        error( 'ref-unexpected-structured', [ art.value.location, art ],
+               { '#': 'struct-expr', elemref: art.value } );
+      }
     }
     else if (effectiveType( art )?.items && !art.$inferred) {
       // For inferred (e.g. included) calc elements, this error is already emitted at the origin.

package/lib/compiler/tweak-assocs.js

@@ -349,42 +349,46 @@ function tweakAssocs( model ) {
       setLink( fk, '_effectiveType', fk );
       fk.targetElement = copyExpr( orig.targetElement, location );
       if (elem._redirected)
-        rewriteKey( elem, fk.targetElement );
+        rewriteKey( elem, fk );
     } );
     if (elem.foreignKeys) // Possibly no fk was set
       elem.foreignKeys[$inferred] = 'rewrite';
   }
 
-  function rewriteKey( elem, targetElement ) {
+  function rewriteKey( elem, fk ) {
+    const { targetElement } = fk;
     let projectedKey = null;
     // rewrite along redirection chain
     for (const alias of elem._redirected) {
-      if (alias.kind !== '$tableAlias')
-        continue;
-
-      projectedKey = firstProjectionForPath( targetElement.path, 0, alias, null );
-      if (projectedKey.elem) {
-        const item = targetElement.path[projectedKey.index];
-        item.id = projectedKey.elem.name.id;
-        if (projectedKey.index > 0)
-          targetElement.path.splice(0, projectedKey.index);
-      }
-      else {
-        setArtifactLink( targetElement.path[0], null );
-        setArtifactLink( targetElement, null );
+      if (alias.kind === '$tableAlias') {
+        projectedKey = firstProjectionForPath( targetElement.path, 0, alias, null );
+        if (projectedKey.elem) {
+          const item = targetElement.path[projectedKey.index];
+          item.id = projectedKey.elem.name.id;
+          if (projectedKey.index > 0)
+            targetElement.path.splice(0, projectedKey.index);
+        }
+        else {
+          setArtifactLink( targetElement.path[0], null );
+          setArtifactLink( targetElement, null );
 
-        const culprit = !elem.target.$inferred && elem.target ||
+          const culprit = !elem.target.$inferred && elem.target ||
           elem.value?.path?.[elem.value.path.length - 1] ||
           elem;
-        // TODO: probably better to collect the non-projected foreign keys
-        // and have one message for all
-        error('rewrite-undefined-key', [ weakLocation( culprit.location ), elem ], {
-          '#': 'std',
-          id: targetElement.path.map(p => p.id).join('.'),
-          target: alias._main,
-          name: elem.name.id,
-        });
-        return null;
+          // TODO: probably better to collect the non-projected foreign keys
+          // and have one message for all
+          error('rewrite-undefined-key', [ weakLocation( culprit.location ), elem ], {
+            '#': 'std',
+            id: targetElement.path.map(p => p.id).join('.'),
+            target: alias._main,
+            name: elem.name.id,
+          });
+          return null;
+        }
+      }
+      else {
+        // e.g. redirection target is entity that includes original target
+        projectedKey = { elem: findTargetElement( alias, targetElement ) };
       }
     }
 
@@ -397,6 +401,24 @@ function tweakAssocs( model ) {
     return null;
   }
 
+  /**
+   * Find the target element in the given redirection target.
+   * Used to find the target element in entities that include the original
+   * target entity.
+   *
+   * @param redirected
+   * @param targetElement
+   * @returns {*|null}
+   */
+  function findTargetElement( redirected, targetElement ) {
+    for (const step of targetElement.path) {
+      redirected = redirected.elements?.[step.id];
+      if (!redirected)
+        return null;
+    }
+    return redirected;
+  }
+
   // TODO: there is no need to rewrite the on condition of non-leading queries,
   // i.e. we could just have on = {…}
   // TODO: re-check $self rewrite (with managed composition of aspects),
@@ -505,6 +527,7 @@ function tweakAssocs( model ) {
     if (lastStep.cardinality) {
       elem.cardinality ??= { ...assoc.cardinality };
       elem.cardinality.location = location;
+      elem.cardinality.$inferred = 'rewrite';
       for (const card of [ 'sourceMin', 'targetMin', 'targetMax' ]) {
         if (lastStep.cardinality[card])
           elem.cardinality[card] = copyExpr( lastStep.cardinality[card], location );

package/lib/edm/annotations/edmJson.js

@@ -266,7 +266,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     transformExpression(xpr, undefined, transform);
     delete parent[prop];
     parentparent[parentprop]
-    = {
+      = {
         $And: [
           { $Le: [ xpr[1], xpr[0] ] },
           { $Le: [ xpr[0], xpr[2] ] },
@@ -370,12 +370,12 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
 
       // Map Edm primitive type funcs to $Type funcs
       let [ foundTypeProps, newArgs ]
-      = parent.args
-        ? parent.args.reduce((acc, arg) => {
-          (arg.func === '$Collection' || arg.func === 'Collection' ? acc[0] : acc[1]).push(arg);
-          return acc;
-        }, [ [], [] ] )
-        : [ [], [] ];
+        = parent.args
+          ? parent.args.reduce((acc, arg) => {
+            (arg.func === '$Collection' || arg.func === 'Collection' ? acc[0] : acc[1]).push(arg);
+            return acc;
+          }, [ [], [] ] )
+          : [ [], [] ];
 
       if (foundTypeProps.length === 1) {
         const type = foundTypeProps[0];
@@ -395,7 +395,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
 
       let typePropName = isDollarFunc ? '$Type' : 'Type';
       [ foundTypeProps, newArgs ]
-      = parent.args
+        = parent.args
           ? parent.args.reduce((acc, arg) => {
             (EdmPrimitiveTypeMap[`Edm.${ arg.func }`] ? acc[0] : acc[1]).push(arg);
             return acc;
@@ -429,7 +429,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
       }
 
       [ foundTypeProps, newArgs ]
-      = parent.args
+        = parent.args
           ? parent.args.reduce((acc, arg) => {
             ((arg.func === '$Type' || arg.func === 'Type') ? acc[0] : acc[1]).push(arg);
             return acc;
@@ -448,19 +448,19 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
         typePropName = typeProp.func;
 
         const [ collTypes, newTypeArgs ]
-        = typeProp.args
-          ? typeProp.args.reduce((acc, arg) => {
-            ((arg.func === '$Collection' || arg.func === 'Collection') ? acc[0] : acc[1]).push(arg);
-            return acc;
-          }, [ [], [] ] )
-          : [ [], [] ];
+          = typeProp.args
+            ? typeProp.args.reduce((acc, arg) => {
+              ((arg.func === '$Collection' || arg.func === 'Collection') ? acc[0] : acc[1]).push(arg);
+              return acc;
+            }, [ [], [] ] )
+            : [ [], [] ];
         typeProp.args = newTypeArgs;
 
         const [ scalarTypes, typeFacets ]
-        = typeProp.args.reduce((acc, arg) => {
-          ((/* arg.ref || */ arg.val) ? acc[0] : acc[1]).push(arg);
-          return acc;
-        }, [ [], [] ] );
+          = typeProp.args.reduce((acc, arg) => {
+            ((/* arg.ref || */ arg.val) ? acc[0] : acc[1]).push(arg);
+            return acc;
+          }, [ [], [] ] );
 
         let typeOpStr = collTypes.length
           ? `${ typePropName }(${ isDollarFunc ? '$Collection' : 'Collection' }(…))`

package/lib/gen/BaseParser.js

@@ -1,4 +1,4 @@
-// Base class for generated parser, for redepage v0.2.7
+// Base class for generated parser, for redepage v0.3.0
 
 'use strict';
 

package/lib/gen/CdlGrammar.checksum

@@ -1 +1 @@
-7489417512fa82b33fb6799686ce2917
+bffacbf5acb61179807cb657191c5114