@sap/cds-compiler 3.0.2 → 3.1.0

package/lib/language/language.g4

@@ -385,10 +385,9 @@ artifactDef[ outer, defOnly = false ] locals[ art = {} ] // cannot use `parent`
       }
       // #ATN: EXTEND elem, while CONTEXT, ENTITY etc are not reserved
       ( extendContext[ $art, $outer ]
-      | extendEntity[ $art, $outer ]
+      | extendEntity[ $art, $outer ] // or aspect
       | extendProjection[ $art, $outer ]
       | extendType[ $art, $outer ]
-      | extendAspect[ $art, $outer ]
       // Streamlined Syntax
       | extendArtifact[ $art, $outer ]
       )
@@ -544,11 +543,12 @@ projectionExclusion[ outer ] locals[ art = {} ]
     { this.addDef( $art, $outer, 'excludingDict', '', $name.id ); }
   ;
 
+// also used for aspect
 extendEntity[ art, outer ] locals[ name = {} ]
 @after { /* #ATN 1 */ this.attachLocation( $art ); }
   :
-    ENTITY simplePath[ $name, 'Extend' ]
-    { $art.expectedKind = 'entity'; $art.name = $name;
+    kind=(ASPECT | ENTITY) simplePath[ $name, 'Extend' ]
+    { $art.expectedKind = $kind.text.toLowerCase(); $art.name = $name;
       this.addItem( $art, $outer, 'extensions', 'extend' );
     }
     (
@@ -556,7 +556,7 @@ extendEntity[ art, outer ] locals[ name = {} ]
       annotationAssignment_ll1[ $art ]*
       // ATN: the ref can start with ACTIONS
       (
-        includeRef[ $art ]
+        includeRef[ $art ] ( ',' includeRef[ $art ] )*
         requiredSemi
       |
         extendForEntity[ $art ]
@@ -754,17 +754,6 @@ extendType[ art, outer ] locals[ name = {} ]
     extendWithOptElements[ $art, $art ]
   ;
 
-extendAspect[ art, outer ] locals[ name = {} ]
-@after { this.attachLocation( $art ); }
-  :
-    // aspects are types, i.e. kind is 'type' for aspects
-    ASPECT simplePath[ $name, 'Extend' ]
-    { $art.expectedKind = 'aspect'; $art.name = $name;
-      this.addItem( $art, $outer, 'extensions', 'extend' );
-    }
-    extendWithOptElements[ $art, $art ]
-  ;
-
 annotationDef[ art, outer ] locals[ name = {} ]
 @after { this.attachLocation( $art ); }
   :
@@ -805,7 +794,7 @@ extendArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
       // #ATN: DEFINITIONS, COLUMNS, ACTIONS etc are not reserved and could be identifiers (ref).
       // TODO: exclude "expected" according to disallowElementExtension()
       (
-        includeRef[ $art ]
+        includeRef[ $art ] ( ',' includeRef[ $art ] )*
         requiredSemi
       |
         '{' { $art.elements = this.createDict(); }
@@ -860,7 +849,7 @@ extendWithOptElements[ art ]
     WITH { this.noSemicolonHere(); this.docComment( $art ); }
     annotationAssignment_ll1[ $art ]*
     (
-      includeRef[ $art ]
+      includeRef[ $art ] ( ',' includeRef[ $art ] )*
       requiredSemi
     |
       '{' { $art.elements = this.createDict(); }
@@ -1558,46 +1547,14 @@ typeSpecSemi[ art ]      // with 'includes', for type and annotation defs
     |
       // alt lookahead includes MANY '{'
       { $art.type = {}; }
+      // Can't use typeRefOptArgs because of clash with include rule below (ATN would change)
       simplePath[ $art.type, 'artref' ]
       (
-        typeRefArgs[ $art ]
-        { this.docComment( $art ); }
-        annotationAssignment_ll1[ $art ]*
-        (
-          ENUM '{' { $art.enum = this.createDict(); }
-          enumSymbolDef[ $art ]*
-          '}' { this.finalizeDictOrArray( $art.enum ); }
-          (
-            optionalSemi
-          |
-            defaultValue[ $art ]
-            requiredSemi
-          )
-        |
-          defaultValue[ $art ]?
-          requiredSemi
-        )
-      |
-        ':' // with element, e.g. `type T : E:elem enum { ... }`
-        { $art.type.scope = $art.type.path.length; }
-        simplePath[ $art.type, 'ref']
-        { this.docComment( $art ); }
-        annotationAssignment_ll1[ $art ]*
-        (
-          ENUM '{' { $art.enum = this.createDict(); }
-          enumSymbolDef[ $art ]*
-          '}' { this.finalizeDictOrArray( $art.enum ); }
-          (
-            optionalSemi
-          |
-            defaultValue[ $art ]
-            requiredSemi
-          )
-        |
-          defaultValue[ $art ]?
-          requiredSemi
-        )
-      |
+        ( typeRefArgs[ $art ]
+        | ':' // with element, e.g. `type T : E:elem enum { ... }`
+          { $art.type.scope = $art.type.path.length; }
+          simplePath[ $art.type, 'ref']
+        )?
         { this.docComment( $art ); }
         annotationAssignment_ll1[ $art ]*
         (
@@ -2481,7 +2438,12 @@ pathArguments[ pathStep, considerSpecial ]
     '('                         // dict or array, see below
     // Make sure that we do not introduce A:B paths in expressions!
     // Need to avoid adaptPredict(), otherwise Generic keywords won't work in funcExpression
-    { this.setLocalTokenForId( { ':': 'HelperToken1', '=>': 'HelperToken2' } ); }
+    //
+    // For code completion, we need to handle generic tokens directly after the
+    // '('.  To avoid invalidating an assoc `trim` to an entity with parameter
+    // `leading` (ok, a bit constructed), we do not do it with named parameters.
+    { if (!this.setLocalTokenForId( { ':': 'HelperToken1', '=>': 'HelperToken2' } ))
+        this.prepareGenericKeywords( $considerSpecial ); }
     (
       { $pathStep.args = this.createDict(); $pathStep['$'+'syntax'] = ':'; }
       id=HelperToken1 ':'

package/lib/main.d.ts

@@ -896,6 +896,7 @@ declare namespace compiler {
      * but not `cds.foundation.*`.
      *
      * @param definitionName Top-level definition name of the artifact.
+     * @since v2.14.0
      */
     function isInReservedNamespace(definitionName: string): boolean;
   }

package/lib/model/api.js

@@ -11,7 +11,7 @@
  * Each function in `userFunctions` and `defaultFunctions` is called with:
  * - `userFunctions`
  * - the current CSN node, i.e. ‹parent node›.‹property name›
- * - the the ‹parent node›
+ * - the ‹parent node›
  * - the ‹property name› (might be useful if the same function is used for several props)
  */
 const defaultFunctions = {

package/lib/model/csnRefs.js

@@ -210,8 +210,11 @@ const referenceSemantics = {
   ref_where: { lexical: justDollar , dynamic: 'ref-target'}, // ...using baseEnv
   on: { lexical: justDollar, dynamic: 'query' }, // assoc defs, redirected to
   // there are also 'on_join' and 'on_mixin' with default semantics
-  orderBy: { lexical: query => query, dynamic: 'query' },
-  orderBy_set: { lexical: query => query.$next, dynamic: 'query' }, // to outer SELECT (from UNION)
+  orderBy_ref: { lexical: query => query, dynamic: 'query' },
+  orderBy_expr: { lexical: query => query, dynamic: 'source' }, // ref in ORDER BY expression
+  orderBy_set_ref: { lexical: query => query.$next, dynamic: 'query' }, // to outer SELECT (from UNION)
+  // refs in ORDER BY expr in UNION not really allowed - only with table alias (of outer queries) or $self
+  orderBy_set_expr: { lexical: query => query.$next, dynamic: false },
   // default: { lexical: query => query, dynamic: 'source' }
 }
 
@@ -551,37 +554,39 @@ function csnRefs( csn, universalReady ) {
       }
     }
     // now the dynamic environment: ------------------------------------------
-    if (semantics.dynamic === 'target') { // ref in keys
-      const target = assocTarget( parent, refCtx );
-      return resolvePath( path, target.elements[head], target, 'target' );
-    }
-    if (baseEnv)                // ref-target (filter condition), expand, inline
-      return resolvePath( path, baseEnv.elements[head], baseEnv, semantics.dynamic );
-    if (!query) {                // outside queries - TODO: items?
-      let art = parent.elements[head];
-      // Ref to up_ in anonymous aspect
-      if (!art && head === 'up_') {
-        const up = getCache( parent, '_parent' );
-        const target = up && typeof up.target === 'string' && csn.definitions[up.target];
-        if (target && target.elements) {
-          initDefinition( target );
-          art = target.elements.up_;
+    if (semantics.dynamic !== false) {
+      if (semantics.dynamic === 'target') { // ref in keys
+        const target = assocTarget( parent, refCtx );
+        return resolvePath( path, target.elements[head], target, 'target' );
+      }
+      if (baseEnv)                // ref-target (filter condition), expand, inline
+        return resolvePath( path, baseEnv.elements[head], baseEnv, semantics.dynamic );
+      if (!query) {                // outside queries - TODO: items?
+        let art = parent.elements[head];
+        // Ref to up_ in anonymous aspect
+        if (!art && head === 'up_') {
+          const up = getCache( parent, '_parent' );
+          const target = up && typeof up.target === 'string' && csn.definitions[up.target];
+          if (target && target.elements) {
+            initDefinition( target );
+            art = target.elements.up_;
+          }
         }
+        return resolvePath( path, art, parent, 'parent' );
       }
-      return resolvePath( path, art, parent, 'parent' );
-    }
 
-    if (semantics.dynamic === 'query')
-      // TODO: for ON condition in expand, would need to use cached _element
-      return resolvePath( path, qcache.elements[head], null, 'query' );
-    for (const name in qcache.$aliases) {
-      const alias = qcache.$aliases[name];
-      const found = alias.elements[head];
-      if (found)
-        return resolvePath( path, found, alias._ref, 'source', name )
+      if (semantics.dynamic === 'query')
+        // TODO: for ON condition in expand, would need to use cached _element
+        return resolvePath( path, qcache.elements[head], null, 'query' );
+      for (const name in qcache.$aliases) {
+        const alias = qcache.$aliases[name];
+        const found = alias.elements[head];
+        if (found)
+          return resolvePath( path, found, alias._ref, 'source', name )
+      }
     }
     // console.log(query.SELECT,qcache,qcache.$next,main)
-    throw new ModelError ( `Path item ${ 0 }=${ head } refers to nothing, refCtx: ${ refCtx }` );
+    throw new ModelError ( `Path item 0=${ head } refers to nothing, refCtx: ${ refCtx }` );
   }
 
   /**
@@ -933,6 +938,15 @@ function analyseCsnPath( csnPath, csn, resolve ) {
         parent = art;
         art = obj[prop];
       }
+      else if (refCtx === 'orderBy') {
+        const isSelect = isSelectQuery( query );
+        // use _query_ elements with direct refs (consider sub-optimal CSN,
+        // representation of the CAST function), otherwise source elements:
+        if (obj[prop].ref && !obj[prop].cast)
+          refCtx = (isSelect ? 'orderBy_ref' : 'orderBy_set_ref');
+        else
+          refCtx = (isSelect ? 'orderBy_expr' : 'orderBy_set_expr');
+      }
       isName = false;
     }
     else if (artifactProperties.includes( String(prop) )) {
@@ -983,7 +997,7 @@ function analyseCsnPath( csnPath, csn, resolve ) {
       refCtx = prop;
     }
     else if (prop === 'orderBy') {
-      refCtx = (query.SET ? 'orderBy_set' : 'orderBy');
+      refCtx = 'orderBy';
     }
     else if (prop !== 'xpr') {
       refCtx = prop;
@@ -996,6 +1010,18 @@ function analyseCsnPath( csnPath, csn, resolve ) {
   return resolve( obj, refCtx, main, query, parent, baseEnv );
 }
 
+// A SELECT which is (unnecessarily) put into parentheses, the CSN
+// representation uses SET without `op` and args of length 1:
+function isSelectQuery( query ) {
+  while (query.SET) {
+    const { args } = query.SET;
+    if (args.length !== 1)
+      return false;
+    query = args[0];
+  }
+  return true;
+}
+
 module.exports = {
   csnRefs,
   traverseQuery,

package/lib/model/csnUtils.js

@@ -492,15 +492,18 @@ function getUtils(model, universalReady) {
 
   /**
    * Resolve to the final type of a type, that means follow type chains, references, etc.
-   * Input is a type name, i.e. string, or type ref, i.e. `{ ref: [...] }`.
+   * Input is a fully qualified type name, i.e. string, or type ref, i.e. `{ ref: [...] }`.
    *
    * Returns `null` if the type can't be resolved or if the referenced element has no type,
    * e.g. `typeof V:calculated`.
    * Otherwise, if scalar, returns an object that has a `type` property and all collected type
    * properties, or the type object with `elements` or `items` property if structured/arrayed.
    *
-   * Caches type lookups.  If the CSN changes drastically, you will need to re-call `csnUtils()`
-   * and use the newly returned `getFinalBaseTypeWithProps()`.
+   * Notes:
+   *   - Caches type lookups.  If the CSN changes drastically, you will need to re-call
+   *    `csnUtils()` and use the newly returned `getFinalBaseTypeWithProps()`.
+   *   - Does _not_ return the underlying type definition! It is an object with all relevant
+   *     type properties collected while traversing the type chain!
    *
    * @param {string|object} type Type as string or type ref, i.e. `{ ref: [...] }`
    * @returns {object|null}
@@ -517,7 +520,7 @@ function getUtils(model, universalReady) {
 
     // We differentiate between ref and type to avoid collisions due to dict key.
     // Delimiter chosen arbitrarily; just one that is rarely used.
-    const resolvedKey = (typeof type === 'object') ? `ref:${type.ref.join('\\')}` : `type:${type}`;
+    const resolvedKey = (typeof type === 'object') ? `ref[${type.ref.length}]:${type.ref.join('\\')}` : `type:${type}`;
 
     if (finalBaseTypeCache[resolvedKey]) {
       if (finalBaseTypeCache[resolvedKey] === true)
@@ -786,10 +789,12 @@ function forEachGeneric( construct, prop, callback, path = [], iterateOptions =
     executeCallbacks( dictObj, name );
   }
   function executeCallbacks(o, name ) {
+    const p = iterateOptions.pathWithoutProp ? [ name ] : [ prop, name ];
+
     if (Array.isArray(callback))
-      callback.forEach(cb => cb( o, name, prop, path.concat([prop, name]), construct ));
+      callback.forEach(cb => cb( o, name, prop, path.concat(p), construct ));
     else
-      callback( o, name, prop, path.concat([prop, name]), construct )
+      callback( o, name, prop, path.concat(p), construct )
   }
 }
 
@@ -1286,7 +1291,6 @@ function copyAnnotationsAndDoc(fromNode, toNode, overwrite = false) {
  *       override: Whether to ignore existing annotations.
  *       filter:   Positive filter. If it returns true, annotations for the referenced artifact
  *                 will be applied.
- * @todo Improve to also apply element annotations
  */
 function applyAnnotationsFromExtensions(csn, config) {
   if (!csn.extensions)

package/lib/model/revealInternalProperties.js

@@ -58,7 +58,6 @@ function tableAliasAsLink( art, parent, name ) {
  *
  * @param {XSN.Model} model
  * @param {string} [nameOrPath]
- * @returns {string}
  */
 function revealInternalProperties( model, nameOrPath ) {
   const transformers = {
@@ -299,8 +298,8 @@ function revealInternalProperties( model, nameOrPath ) {
 function array( node, fn ) {
   const r = node.map( n => fn( n, node ) );
   if (node[$location])
-    r.push( { $location: locationString( node[$location] ) } );
-  return r;
+    r.push( { '[$location]': locationString( node[$location] ) } );
+  return (node.$prefix) ? [ { $prefix: node.$prefix }, ...node ] : r;
 }
 
 function artifactIdentifier( node, parent ) {

package/lib/modelCompare/compare.js

@@ -169,6 +169,9 @@ function getElementComparator(otherArtifact, addedElementsDict = null, changedEl
       }
       if (relevantTypeChange(element.type, otherElement.type) || typeParametersChanged(element, otherElement)) {
         // Type or parameters, e.g. association target, changed.
+        if(otherElement.notNull && element.notNull === undefined) {
+          element.$notNull = false; // Explictily set notNull to the implicit default so we render the correct ALTER
+        }
         changedElementsDict[name] = changedElement(element, otherElement);
       }
 

package/lib/optionProcessor.js

@@ -102,8 +102,11 @@ optionProcessor
                               hanaAssocRealCardinality
                               mapAssocToJoinCardinality
                               ignoreAssocPublishingInUnion
+                              odataOpenType
+                              optionalActionFunctionParameters
        --deprecated <list>  Comma separated list of deprecated options.
                             Valid values are:
+                              autoCorrectOrderBySourceRefs
                               eagerPersistenceForGeneratedEntities
        --fallback-parser <type>  If the language cannot be deduced by the file's extensions, use this
                                  parser as a fallback. Valid values are:
@@ -138,6 +141,7 @@ optionProcessor
        toRename [options] <files...>            (internal) Generate SQL DDL rename statements
        manageConstraints [options] <files...>   (internal) Generate ALTER TABLE statements to
                                                            add / modify referential constraints.
+       inspect [options] <files...>             (internal) Inspect the given CDS files.
 `);
 
 // ----------- toHana -----------
@@ -153,6 +157,7 @@ optionProcessor.command('H, toHana')
   .option('    --integrity-not-enforced')
   .option('    --assert-integrity <mode>', ['true', 'false', 'individual'])
   .option('    --assert-integrity-type <type>', ['RT', 'DB'], { ignoreCase: true })
+  .option('    --disable-hana-comments')
   .help(`
   Usage: cdsc toHana [options] <files...>
 
@@ -187,6 +192,7 @@ optionProcessor.command('H, toHana')
                                            RT : (default) No database constraint for an association
                                                if not explicitly demanded via annotation
                                            DB : Create database constraints for associations
+   --disable-hana-comments    Disable rendering of doc comments as SAP HANA comments.
 `);
 
 optionProcessor.command('O, toOdata')
@@ -263,6 +269,7 @@ optionProcessor.command('Q, toSql')
   .option('    --assert-integrity <mode>', ['true', 'false', 'individual'])
   .option('    --assert-integrity-type <type>', ['RT', 'DB'], { ignoreCase: true })
   .option('    --constraints-in-create-table')
+  .option('    --disable-hana-comments')
   .help(`
   Usage: cdsc toSql [options] <files...>
 
@@ -310,6 +317,7 @@ optionProcessor.command('Q, toSql')
    --constraints-in-create-table    If set, the foreign key constraints will be rendered as
                                     part of the "CREATE TABLE" statements rather than as separate
                                     "ALTER TABLE ADD CONSTRAINT" statements
+   --disable-hana-comments    Disable rendering of doc comments as SAP HANA comments.
 `);
 
 optionProcessor.command('toRename')
@@ -377,6 +385,7 @@ optionProcessor.command('toCsn')
   .option('-h, --help')
   .option('-f, --csn-flavor <flavor>', ['client', 'gensrc', 'universal'], { aliases: ['--flavor'] })
   .option('    --with-localized')
+  .option('    --with-locations')
   .help(`
   Usage: cdsc toCsn [options] <files...>
 
@@ -391,6 +400,8 @@ optionProcessor.command('toCsn')
                                           statements, but not suitable for consumption by clients or
                                           backends
                                 universal: in development (BETA)
+       --with-locations   Add $location to CSN artifacts. In contrast to \`--enrich-csn\`,
+                          $location is an object with 'file', 'line' and 'col' properties.
 
   Internal options (for testing only, may be changed/removed at any time)
        --with-localized   Add localized convenience views to the CSN output.
@@ -444,6 +455,22 @@ optionProcessor.command('explain')
    -h, --help        Show this help text
 `);
 
+optionProcessor.command('inspect')
+  .option('-h, --help')
+  .option('    --statistics')
+  .option('    --propagation <art>')
+  .positionalArgument('<files...>')
+  .help(`
+  Usage: cdsc inspect [options] <files...>
+
+  (internal): Inspect the CSN model compiled from the provided CDS files.
+
+  Options
+   -h, --help                Show this help text
+       --statistics          Print model statistics
+       --propagation <art>   Show propagation sources for <art>
+`);
+
 module.exports = {
   optionProcessor
 };

package/lib/render/toCdl.js

@@ -142,11 +142,10 @@ function csnToCdl(csn, options) {
     let result = renderAnnotationAssignmentsAndDocComment(ext, env);
 
     if (ext.includes && ext.includes.length > 0) {
-      // Includes can't be combined with anything in braces {}.  Multiple includes
-      // are possible through CSN, but in CDL, only one include at once is possible.
+      // Includes can't be combined with anything in braces {}.
       const affix = isElementExtend ? 'element ' : '';
-      for (const id of ext.includes)
-        result += `${env.indent}extend ${affix}${extName} with ${quotePathIfRequired(id)};\n`;
+      const includes = ext.includes.map(inc => quotePathIfRequired(inc)).join(', ');
+      result += `${env.indent}extend ${affix}${extName} with ${includes};\n`;
       return result;
     }
 
@@ -358,17 +357,21 @@ function csnToCdl(csn, options) {
       case 'context':
       case 'service':
         return renderContextOrService(artifactName, art, env);
+
       case 'type':
       case 'aspect':
       case 'annotation': // annotation in 'csn.definitions' for compiler v1 compatibility
         return renderTypeOrAnnotation(artifactName, art, env);
+
       case 'action':
       case 'function':
         return renderActionOrFunction(artifactName, art, env);
+
       case 'event':
         return renderEvent(artifactName, art, env);
+
       default:
-        throw new ModelError(`Unknown artifact kind: ${art.kind}`);
+        throw new ModelError(`to.cdl: Unknown artifact kind: ${art.kind}`);
     }
   }
 
@@ -426,14 +429,16 @@ function csnToCdl(csn, options) {
    */
   function renderEntity(artifactName, art, env) {
     let result = renderAnnotationAssignmentsAndDocComment(art, env);
-    const childEnv = increaseIndent(env);
-    const normalizedArtifactName = renderArtifactName(artifactName);
-    result += `${env.indent + (art.abstract ? 'abstract ' : '')}entity ${normalizedArtifactName}`;
-    const parameters = Object.keys(art.params || []).map(name => renderParameter(name, art.params[name], childEnv)).join(',\n');
-    result += (parameters === '') ? '' : ` (\n${parameters}\n${env.indent})`;
+    result += env.indent + (art.abstract ? 'abstract ' : '');
+    result += `entity ${renderArtifactName(artifactName)}`;
+
+    if (art.params)
+      result += renderParameters(art, env);
+
     if (art.includes)
       result += renderIncludes(art.includes);
     result += ' {\n';
+    const childEnv = increaseIndent(env);
     for (const name in art.elements) {
       const element = art.elements[name];
       result += renderElement(name, element, childEnv);
@@ -664,8 +669,11 @@ function csnToCdl(csn, options) {
     if (path.ref[0].args)
       result += `(${renderArgs(path.ref[0], ':', env)})`;
 
-    if (path.ref[0].where)
-      result += `[${path.ref[0].cardinality ? (`${path.ref[0].cardinality.max}: `) : ''}${renderExpr(path.ref[0].where, env, true, true)}]`;
+    if (path.ref[0].where) {
+      const cardinality = path.ref[0].cardinality ? (`${path.ref[0].cardinality.max}: `) : '';
+      const expr = renderExpr(path.ref[0].where, env, true, true);
+      result += `[${cardinality}${expr}]`;
+    }
 
     // Add any path steps (possibly with parameters and filters) that may follow after that
     if (path.ref.length > 1)
@@ -841,14 +849,9 @@ function csnToCdl(csn, options) {
     const syntax = (art.projection) ? 'projection' : 'entity';
     let result = renderAnnotationAssignmentsAndDocComment(art, env);
     result += `${env.indent}${art.abstract ? 'abstract ' : ''}${syntax === 'projection' ? 'entity' : syntax} ${renderArtifactName(artifactName)}`;
-    if (art.params) {
-      const childEnv = increaseIndent(env);
-      const parameters = Object.keys(art.params).map(name => renderParameter(name, art.params[name], childEnv)).join(',\n');
-      result += `(\n${parameters}\n${env.indent}) as `;
-    }
-    else {
-      result += ' as ';
-    }
+    if (art.params)
+      result += renderParameters(art, env);
+    result += ' as ';
     result += renderQuery(getNormalizedQuery(art).query, true, syntax, env, [ 'definitions', artifactName, 'query' ], art.elements);
     result += ';\n';
     result += renderQueryElementAnnotations(artifactName, art, env);
@@ -959,9 +962,10 @@ function csnToCdl(csn, options) {
       if (limit.rows !== undefined)
         limitStr += `limit ${renderExpr(limit.rows, limitEnv)}`;
 
-      if (limit.offset !== undefined)
-        limitStr += `${limitStr !== '' ? `\n${increaseIndent(limitEnv).indent}` : ''}offset ${renderExpr(limit.offset, limitEnv)}`;
-
+      if (limit.offset !== undefined) {
+        const offsetIndent = (limitStr === '') ? '' : `\n${increaseIndent(limitEnv).indent}`;
+        limitStr += `${offsetIndent}offset ${renderExpr(limit.offset, limitEnv)}`;
+      }
       return limitStr;
     }
 
@@ -1040,10 +1044,9 @@ function csnToCdl(csn, options) {
    * @return {string}
    */
   function renderActionOrFunction(actionName, act, env) {
-    let result = `${renderAnnotationAssignmentsAndDocComment(act, env) + env.indent + act.kind} ${renderArtifactName(actionName)}`;
-    const childEnv = increaseIndent(env);
-    const parameters = Object.keys(act.params || []).map(name => renderParameter(name, act.params[name], childEnv)).join(',\n');
-    result += (parameters === '') ? '()' : `(\n${parameters}\n${env.indent})`;
+    let result = renderAnnotationAssignmentsAndDocComment(act, env) + env.indent + act.kind;
+    result += ` ${renderArtifactName(actionName)}`;
+    result += renderParameters(act, env);
     if (act.returns) {
       const actEnv = envAddPath(env, [ 'returns' ]);
       result += ` returns ${renderTypeReferenceAndProps(act.returns, actEnv)}`;
@@ -1053,6 +1056,23 @@ function csnToCdl(csn, options) {
     return result;
   }
 
+  /**
+   * Render art.params, i.e. list of parameter in parentheses.  If there is only one
+   * parameter, a single line is used, otherwise an indented list is used.
+   * If there are no params, an empty list `()` is returned.
+   *
+   * @param {CSN.Artifact} art
+   * @param {CdlRenderEnvironment} env
+   * @returns {string}
+   */
+  function renderParameters(art, env) {
+    const childEnv = increaseIndent(env);
+    const parameters = Object.keys(art.params || {}).map(name => renderParameter(name, art.params[name], childEnv));
+    if (parameters.length === 0)
+      return '()';
+    return `(\n${parameters.join(',\n')}\n${env.indent})`;
+  }
+
   /**
    * Render an action or function parameter 'par' with name 'parName'. Return the resulting source string (no trailing LF).
    *
@@ -1075,7 +1095,7 @@ function csnToCdl(csn, options) {
    * @param {string} artifactName
    * @param {CSN.Artifact} art
    * @param {CdlRenderEnvironment} env
-   * @param {String} [artType] - used for rendering csn.vocabularies, as the annotations there do not have a kind. Only in toCdl mode
+   * @param {String} [artType] - used for rendering csn.vocabularies, as the annotations there do not have a kind.
    * @return {string}
    */
   function renderTypeOrAnnotation(artifactName, art, env, artType) {
@@ -1085,9 +1105,11 @@ function csnToCdl(csn, options) {
       result += renderIncludes(art.includes);
 
     if (!art.type && art.elements) // For nicer output, no colon if unnamed structure is used.
-      result += ` ${renderTypeReferenceAndProps(art, env)};\n`;
+      result += ` ${renderTypeReferenceAndProps(art, env)}`;
     else
-      result += ` : ${renderTypeReferenceAndProps(art, env)};\n`;
+      result += ` : ${renderTypeReferenceAndProps(art, env)}`;
+    // for aspects, but since types don't have `actions` this does not hurt
+    result += `${renderActionsAndFunctions(art, env)};\n`;
     return result;
   }
 
@@ -1373,7 +1395,9 @@ function csnToCdl(csn, options) {
       }
       if (s.where) {
         // Filter, possibly with cardinality
-        result += `[${s.cardinality ? (`${s.cardinality.max}: `) : ''}${renderExpr(s.where, env, inline, true)}]`;
+        const cardinality = s.cardinality ? (`${s.cardinality.max}: `) : '';
+        const expr = renderExpr(s.where, env, inline, true);
+        result += `[${cardinality}${expr}]`;
       }
 
       return result;
@@ -1516,7 +1540,8 @@ function csnToCdl(csn, options) {
    * @return {string}
    */
   function renderForeignKey(fKey, env) {
-    return `${renderExpr(fKey, env)}${fKey.as ? (` as ${fKey.as}`) : ''}`;
+    const alias = fKey.as ? (` as ${fKey.as}`) : '';
+    return renderExpr(fKey, env) + alias;
   }
 
   /**