@sap/cds-compiler 2.7.0 → 2.10.2

package/lib/language/language.g4

@@ -20,7 +20,7 @@
 //    allow integers at certain places), one token type for non-quoted and
 //    quoted identifiers.
 //
-//  * Keep the number of keywords as small as possibile.  Thus, built-ins is a
+//  * Keep the number of keywords as small as possible.  Thus, built-ins is a
 //    topic for the semantic analysis, not the grammar.  Examples: no keywords
 //    for built-in types or built-in SQL functions.  This also avoids noise in
 //    the grammar and a huge/slow generated parser.
@@ -43,7 +43,7 @@
 //    is not enough for a decision), write a comment starting with `#ATN:`
 //    which describes the ambiguity.  Additionally, put a comment `/* #ATN n
 //    */` INSIDE an (`@after`) action of a rule if the corresponding function
-//    in '../gen/langageParser.js' contains `n` occurrences of
+//    in '../gen/languageParser.js' contains `n` occurrences of
 //    `adaptivePredict` calls.  This is checked in 'test/testCompiler.js',
 //    which also counts the total number of `adaptivePredict` occurrences.
 //  └─────────────────────────────────────────────────────────────────────────┘
@@ -55,6 +55,10 @@
 //    good idea anyway to avoid calls to `adaptivePredict`, see the rules
 //    starting with `annotationAssignment_`.
 //
+//  * Factoring out a sub rule into a named rule influences the error recovery:
+//    the parser tries to consume all tokens which are neither in the follow
+//    set of loops and named rules.  So be careful.
+//
 //  * Do not use actions in the lexer.  Examples: de-quote string literals not
 //    in the lexer, but in the parser; do not throw errors, but produce error
 //    tokens if necessary.
@@ -106,6 +110,9 @@
 //
 //  * The ANTLR error "missing attribute access on rule reference c in $c" can
 //    be solved with using $ctx.c instead of $c
+//
+//  * If you want to set a property starting with '$' like $syntax, use
+//    obj['$'+'syntax'] as the ANTLR tool would replace $syntax by $ctx.syntax
 
 grammar language;
 options {
@@ -114,6 +121,7 @@ options {
 }
 tokens {
   VIRTUAL,                      // used with setLocalToken()
+  OVER,                         // used with setLocalTokenIfBefore()
   HelperToken1,                 // used with setLocalToken(), does not appear in messages
   HelperToken2,                 // used with setLocalToken(), does not appear in messages
   HideAlternatives,             // hide alternative tokens (no token seq!)
@@ -818,7 +826,7 @@ annotateArtifact[ outer, loc, annos ] locals[ art, name = {} ]
       )*
       ')'
       (
-        RETURNS '{'
+        RETURNS '{' { $art['$'+'syntax'] = 'returns'; }
         annotateElement[ $art ]*
         '}'
         optionalSemi
@@ -826,7 +834,7 @@ annotateArtifact[ outer, loc, annos ] locals[ art, name = {} ]
         requiredSemi
       )
     |
-      RETURNS '{'
+      RETURNS '{' { $art['$'+'syntax'] = 'returns'; }
       annotateElement[ $art ]*
       '}'
       optionalSemi
@@ -1124,13 +1132,7 @@ bracedSelectItemListDef[ query ]
     '{'
     { if (!$query.columns) $query.columns = []; }  // set it early to avoid "wildcard" errors
     (
-      ( star='*'                // TODO: allow everywhere
-        {
-          $query.columns = [ this.tokenLocation( $star, undefined, '*' ) ];
-        }
-      |
-        selectItemDef[ $query.columns ]
-      )
+      selectItemDef[ $query.columns ]
       ( ',' { if (this.isStraightBefore("}")) break; } // allow ',' before '}'
         selectItemDef[ $query.columns ]
       )*
@@ -1139,8 +1141,11 @@ bracedSelectItemListDef[ query ]
   ;
 
 selectItemDef[ outer ] locals[ annos = [] ]
-@after{ this.attachLocation($art.art); }
+@after{ if ($ctx.art) this.attachLocation($art.art); }
   :
+    star='*'
+    { $outer.push( this.tokenLocation( $star, undefined, '*' ) ); }
+  |
     { this.docComment( $annos ); }
     annotationAssignment_atn[ $annos ]*
     // VIRTUAL is keyword, except if before the following tokens texts:
@@ -1159,6 +1164,8 @@ selectItemDefBody[ outer, annos ] returns[ art = {} ]
   :
     (
       e=expression
+      // we cannot use 'condition' instead, as long as we allow aliases without
+      // AS (using rule 'ident' instead of 'identNoKeyword') -> ambiguities
       {
         $art = this.addItem( $outer, null, null, $annos, { value: $e.expr } );
       }
@@ -1218,11 +1225,7 @@ selectItemInlineList[ art, clause ]
     '{'
     { $art[$clause] = []; }
     (
-      ( star='*'                // TODO: allow everywhere
-        { $art[$clause].push( this.tokenLocation( $star, undefined, '*' ) ); }
-      |
-        selectItemInlineDef[ $art[$clause] ]
-      )
+      selectItemInlineDef[ $art[$clause] ]
       ( ',' { if (this.isStraightBefore("}")) break; } // allow ',' before '}'
         selectItemInlineDef[ $art[$clause] ]
       )*
@@ -1231,8 +1234,11 @@ selectItemInlineList[ art, clause ]
   ;
 
 selectItemInlineDef[ outer ] locals[ annos = [] ]
-@after{ this.attachLocation($art.art); }
+@after{ if ($ctx.art) this.attachLocation($art.art); }
   :
+    star='*'
+    { $outer.push( this.tokenLocation( $star, undefined, '*' ) ); }
+  |
     { this.docComment( $annos ); }
     annotationAssignment_atn[ $annos ]*
     art=selectItemDefBody[ $outer, $annos ]
@@ -1471,8 +1477,20 @@ typeSpecSemi[ art, annos ]      // with 'includes', for type and annotation defs
         head=Number
         { $art['$'+'typeArgs'] = [ this.numberLiteral( $head ) ]; }
         ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
-          tail=Number
-          { $art['$'+'typeArgs'].push( this.numberLiteral( $tail ) ); }
+          (
+            v=VARIABLE
+            { $art['$'+'typeArgs'].push(
+              { literal: 'string', val: 'variable', location: this.tokenLocation($v) } );
+            }
+          |
+            f=FLOATING
+            { $art['$'+'typeArgs'].push(
+              { literal: 'string', val: 'floating', location: this.tokenLocation($f) } );
+            }
+          |
+            tail=Number
+            { $art['$'+'typeArgs'].push( this.numberLiteral( $tail ) ); }
+          )
         )*
         ')'
         { this.docComment( $annos ); }
@@ -1696,8 +1714,20 @@ typeRefOptArgs[ art ]
       head=Number
       { $art['$'+'typeArgs'] = [ this.numberLiteral( $head ) ]; }
       ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
-        tail=Number
-        { $art['$'+'typeArgs'].push( this.numberLiteral( $tail ) ); }
+        (
+          v=VARIABLE
+          { $art['$'+'typeArgs'].push(
+            { literal: 'string', val: 'variable', location: this.tokenLocation($v) } );
+          }
+        |
+          f=FLOATING
+          { $art['$'+'typeArgs'].push(
+            { literal: 'string', val: 'floating', location: this.tokenLocation($f) } );
+          }
+        |
+          tail=Number
+          { $art['$'+'typeArgs'].push( this.numberLiteral( $tail ) ); }
+        )
       )*
       ')'
     |
@@ -1732,6 +1762,30 @@ orderByClause[ inQuery ] returns [ query ]
     ( ',' obn=orderBySpec  { $query.orderBy.push( $obn.ob ); } )*
   ;
 
+overOrderByClause returns [ expr ]
+  :
+    o=ORDER b=BY { $expr = { op: this.tokenLocation($o, $b, 'orderBy' ) , args: [] }}
+    ob1=orderBySpec { $expr.args.push( $ob1.ob ); }
+    ( ',' obn=orderBySpec { $expr.args.push( $obn.ob ); } )*
+  ;
+
+partitionByClause returns [ expr ]
+  :
+    p=PARTITION b=BY { $expr = { op: this.tokenLocation($p, $b, 'partitionBy' ) , args: [] }}
+    e1=expression { $expr.args.push( $e1.expr ); }
+    ( ',' en=expression { $expr.args.push( $en.expr ); } )*
+  ;
+
+overClause returns [ over ]
+@after { this.attachLocation($over); }
+  :
+    o=OVER { $over = { op: this.tokenLocation( $o, null, 'over' ) , args: []  } }
+    '('
+      ( pb=partitionByClause { $over.args.push( $pb.expr ); } )?
+      ( ob=overOrderByClause { $over.args.push( $ob.expr ); } )?
+    ')'
+  ;
+
 limitClause[ inQuery ] returns [ query ]
   :
     limkw=LIMIT { $query = this.unaryOpForParens( $inQuery, '$'+'query' ); }
@@ -1790,13 +1844,7 @@ queryPrimary returns[ query = {} ]
       { $query.quantifier = this.tokenLocation( $ad, undefined, $ad.text.toLowerCase() ); }
       )?
       { $query.columns = []; }  // set it early to avoid "wildcard" errors
-      ( star='*'
-        {
-          $query.columns = [ this.tokenLocation( $star, undefined, '*' ) ];
-        }
-      |
-        selectItemDef[ $query.columns ]
-      )
+      selectItemDef[ $query.columns ]
       ( ',' { if (this.isStraightBefore("}")) break; } // allow ',' before '}'
         selectItemDef[ $query.columns ]
       )*
@@ -1954,7 +2002,7 @@ fromPath[ qp, idkind ]
 condition returns [ cond ] locals [ args = [], orl = [] ]
 @after{
   $cond = ($args.length == 1)
-    ? $args[0]
+    ? this.attachLocation( $args[0] )
     : this.attachLocation({ op: $orl[0], args: $args });
 }
   :
@@ -2115,6 +2163,10 @@ expressionTerm returns [ expr ] locals [ op, args = [] ]
         this.notSupportedYet( $ne ); }
     |
       vp=valuePath[ 'ref', null ] { $expr = this.valuePathAst( $vp.qp ); }
+      { this.setLocalTokenIfBefore( 'OVER', 'OVER', /^\($/i ); }
+      (
+        over=overClause { $expr.suffix = [ $over.over ] }
+      )?
     |
       ':'
       ( vp=valuePath[ 'paramref', this.startLocation() ]
@@ -2315,7 +2367,7 @@ optionalCardinality[ pathStep ]
     // completion just produces `:`after having inserted a Number - TODO.
     { if (this._input.LT(2).text !== ':') return $ctx; }
     ( trgMax=Number ':'
-      { if ($pathStep) $pathStep.cardinality = { targetMax: this.numberLiteral( $trgMax ) } }
+      { if ($pathStep) $pathStep.cardinality = { targetMax: this.numberLiteral( $trgMax ), location: this.startLocation() }; }
     )
   ;
 
@@ -2566,6 +2618,7 @@ ident[ category ] returns[ id ]
   | EXCLUDING
   | EXTEND
   | FIRST
+  | FLOATING
   | FULL
   | FUNCTION
   | GROUP
@@ -2596,6 +2649,7 @@ ident[ category ] returns[ id ]
   | ORDER
   | OUTER
   | PARAMETERS
+  | PARTITION
   | PROJECTION
   | REDIRECTED
   | RETURNS
@@ -2608,6 +2662,7 @@ ident[ category ] returns[ id ]
   | TO
   | TYPE
   | USING
+  | VARIABLE
   | VIEW
   | YEAR
   ;
@@ -2724,6 +2779,7 @@ EXCEPT : [eE][xX][cC][eE][pP][tT] ;
 EXCLUDING : [eE][xX][cC][lL][uU][dD][iI][nN][gG] ;
 EXTEND : [eE][xX][tT][eE][nN][dD] ;
 FIRST : [fF][iI][rR][sS][tT] ;
+FLOATING : [fF][lL][oO][aA][tT][iI][nN][gG] ;
 FULL : [fF][uU][lL][lL] ;
 FUNCTION : [fF][uU][nN][cC][tT][iI][oO][nN] ;
 GROUP : [gG][rR][oO][uU][pP] ;
@@ -2753,7 +2809,9 @@ ONE : [oO][nN][eE] ;
 OR : [oO][rR] ;
 ORDER : [oO][rR][dD][eE][rR] ;
 OUTER : [oO][uU][tT][eE][rR] ;
+// OVER : [oO][vV][eE][rR] ;
 PARAMETERS : [pP][aA][rR][aA][mM][eE][tT][eE][rR][sS] ;
+PARTITION: [pP][aA][rR][tT][iI][tT][iI][oO][nN] ;
 PROJECTION : [pP][rR][oO][jJ][eE][cC][tT][iI][oO][nN] ;
 REDIRECTED : [rR][eE][dD][iI][rR][eE][cC][tT][eE][dD] ;
 RETURNS : [rR][eE][tT][uU][rR][nN][sS] ;
@@ -2766,6 +2824,7 @@ TO : [tT][oO] ;                 // or make reserved? (is in SQL-92)
 TYPE : [tT][yY][pP][eE] ;
 UNION : [uU][nN][iI][oO][nN] ;
 USING : [uU][sS][iI][nN][gG] ;
+VARIABLE : [vV][aA][rR][iI][aA][bB][lL][eE] ;
 VIEW : [vV][iI][eE][wW] ;
 // VIRTUAL: [vV][iI][rR][tT][uU][aA][lL] ; see tokens {}
 YEAR : [yY][eE][aA][rR] ;

package/lib/main.js

@@ -16,6 +16,7 @@
 const backends = require('./backends');
 const { odata, cdl, sql, hdi, hdbcds, edm, edmx } = require('./api/main');
 const { getArtifactDatabaseNameOf, getElementDatabaseNameOf } = require('./model/csnUtils');
+const { traverseCsn } = require('./model/api');
 const { createMessageFunctions, sortMessages, sortMessagesSeverityAware, deduplicateMessages } = require('./base/messages');
 
 const parseLanguage = require('./language/antlrParser');
@@ -111,6 +112,9 @@ module.exports = {
   getArtifactCdsPersistenceName: getArtifactDatabaseNameOf,
   getElementCdsPersistenceName: getElementDatabaseNameOf,
 
+  // Other API functions:
+  traverseCsn,
+
   // INTERNAL functions for the cds-lsp package and friends - before you use
   // it, you MUST talk with us - there can be potential incompatibilities with
   // new releases (even having the same major version):

package/lib/model/api.js

@@ -0,0 +1,78 @@
+// Miscellaneous CSN functions we put into our compiler API
+
+// Do not change at will - they are in the compiler API!
+
+/**
+ * Dictionary of default traversal functions for function `traverseCsn`.
+ * It maps CSN property names to functions which are used by default
+ * to traverse the CSN node which is the value of the corresponding property.
+ * Users specify their own traversal function via argument `userFunctions`.
+ *
+ * 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 ‹property name› (might be useful if the same function is used for several props)
+ */
+const defaultFunctions = {
+  '@': () => {},                // do not traverse annotation assignments
+  args: dictionary,
+  elements: dictionary,
+  enum: dictionary,
+  params: dictionary,
+  actions: dictionary,
+  mixin: dictionary,
+  definitions: dictionary,
+  '$': () => {},                // do not traverse properties starting with '$'
+}
+
+/**
+ * Traverse the CSN node `csn`.
+ * If `csn` is an array, call it recursively on each array item.
+ * If `csn` is an(other) object, call a function on each property:
+ * - The property name is a used as key in argument `userFunctions` and the
+ *   constant `defaultFunctions` above to get the function which is called on
+ *   the property value, see `defaultFunctions` for details.
+ * - If no function is found with the property name, try to find one with the first char.
+ * - If still not found, call `traverseCsn` recursively.
+ *
+ * The functions in `userFunctions` are usually transformer functions, which
+ * change the input CSN destructively.
+ */
+function traverseCsn( userFunctions, csn ) {
+  if (!csn || typeof csn !== 'object')
+    return;
+  if (Array.isArray( csn )) {
+    csn.forEach( node => traverseCsn( userFunctions, node ) );
+  }
+  else {
+    for (const prop of Object.keys( csn )) {
+      const func = userFunctions[prop] || defaultFunctions[prop] ||
+            userFunctions[prop.charAt(0)] || defaultFunctions[prop.charAt(0)] ||
+            traverseCsn;
+      func( userFunctions, csn[prop], csn, prop );
+    }
+  }
+}
+// people might want to have their own traversal function for `elements`, etc:
+traverseCsn.dictionary = dictionary;
+
+/**
+ * Traverse the CSN dictionary node `csn`.
+ * Call `traverseCsn` on each property value in `csn`, passing down `userFunctions`.
+ */
+function dictionary( userFunctions, csn ) {
+  if (!csn || typeof csn !== 'object')
+    return;
+  if (Array.isArray( csn )) {   // args can be both array and dictionary
+    csn.forEach( node => traverseCsn( userFunctions, node ) );
+  }
+  else {
+    for (const name of Object.keys( csn ))
+      traverseCsn( userFunctions, csn[name] );
+  }
+}
+
+module.exports = {
+  traverseCsn,
+};

package/lib/model/csnRefs.js

@@ -175,6 +175,7 @@ const referenceSemantics = {
   type: { lexical: false, dynamic: 'global' },
   includes: { lexical: false, dynamic: 'global' },
   target: { lexical: false, dynamic: 'global' },
+  targetAspect: { lexical: false, dynamic: 'global' },
   from: { lexical: false, dynamic: 'global' },
   keys: { lexical: false, dynamic: 'target' },
   excluding: { lexical: false, dynamic: 'source' },
@@ -688,6 +689,7 @@ function analyseCsnPath( csnPath, csn, resolve ) {
   let isName = false;
   let baseRef = null;
   let baseEnv = null;
+  let main = csn.definitions[csnPath[1]];
 
   for (let index = 0; index < csnPath.length; index++) {
     const prop = csnPath[index];
@@ -700,6 +702,10 @@ function analyseCsnPath( csnPath, csn, resolve ) {
       isName = false;
     }
     else if (artifactProperties.includes( String(prop) )) {
+      if (refCtx === 'target' || refCtx === 'targetAspect') { // with 'elements'
+        main = art = obj;       // $self refers to the anonymous aspect
+        parent = null;
+      }
       isName = prop;
       refCtx = prop;
     }
@@ -758,7 +764,7 @@ function analyseCsnPath( csnPath, csn, resolve ) {
   // console.log( 'CPATH:', csnPath, refCtx, obj, parent.$location );
   if (!resolve)
     return { query };           // for constructSemanticLocationFromCsnPath
-  return resolve( obj, refCtx, csn.definitions[csnPath[1]], query, parent, baseEnv );
+  return resolve( obj, refCtx, main, query, parent, baseEnv );
 }
 
 module.exports = {

package/lib/model/csnUtils.js

@@ -36,7 +36,7 @@ const version = require('../../package.json').version;
  * @param {CSN.Model} model (Compact) CSN model
  */
 function getUtils(model) {
-  const { artifactRef, inspectRef, effectiveType } = csnRefs(model);
+  const { artifactRef, inspectRef, effectiveType, getOrigin } = csnRefs(model);
 
   return {
     getCsnDef,
@@ -59,6 +59,7 @@ function getUtils(model) {
     artifactRef,
     effectiveType,
     get$combined,
+    getOrigin,
   };
 
   /**
@@ -630,12 +631,12 @@ function forEachMember( construct, callback, path=[], ignoreIgnore=true, iterate
   // Backends rely on the fact that `forEachElement` also goes through all
   // `elements` of the return type (if structured).
   // TODO: `returns` should be handled like a parameter just like XSN (maybe with different prop name)
-  if (construct.returns) {
+  if (construct.returns && !iterateOptions.elementsOnly) {
     forEachMember( construct.returns, callback, [...path, 'returns'], ignoreIgnore, iterateOptions );
   }
 
   path = [...path]; // Copy
-  const propsWithMembers = ['elements', 'enum', 'foreignKeys', 'actions', 'params'];
+  const propsWithMembers = (iterateOptions.elementsOnly ? ['elements'] : ['elements', 'enum', 'foreignKeys', 'actions', 'params']);
   propsWithMembers.forEach((prop) => forEachGeneric( construct, prop, callback, path, iterateOptions ));
 }
 
@@ -1097,7 +1098,7 @@ function applyTransformations( csn, customTransformers={}, artifactTransformers=
       for (let name of Object.getOwnPropertyNames( node )) {
         const trans = transformers[name] || standard;
         if(customTransformers[name])
-          customTransformers[name](node, name, node[name], csnPath);
+          customTransformers[name](node, name, node[name], csnPath, parent, prop);
 
         trans( node, name, node[name], csnPath );
       }

package/lib/optionProcessor.js

@@ -37,8 +37,10 @@ optionProcessor
   .option('    --test-mode')
   .option('    --test-sort-csn')
   .option('    --doc-comment')
+  .option('    --add-texts-language-assoc')
   .option('    --localized-without-coalesce')
   .option('    --defaultStringLength <length>')
+  .option('    --no-recompile')
   .positionalArgument('<files...>')
   .help(`
   Usage: cdsc <command> [options] <files...>
@@ -93,6 +95,7 @@ optionProcessor
                               hanaAssocRealCardinality
                               mapAssocToJoinCardinality
                               ignoreAssocPublishingInUnion
+                              windowFunctions
        --constraints-not-enforced  If this option is supplied, referential constraints are NOT ENFORCED
                                    This option is also applied to result of "cdsc manageConstraints"
        --constraints-not-validated If this option is supplied, referential constraints are NOT VALIDATED
@@ -123,8 +126,11 @@ optionProcessor
                             OData CSN, CDL order and more.  When --test-mode is enabled, this
                             option is implicitly enabled as well.
        --doc-comment        Preserve /** */ comments at annotation positions as doc property in CSN
+       --add-texts-language-assoc   In generated texts entities, add association "language"
+                                    to "sap.common.Languages" if it exists
        --localized-without-coalesce Omit coalesce in localized convenience views
-
+       --no-recompile       Don't recompile in case of internal errors
+  
   Commands
     H, toHana [options] <files...>              Generate HANA CDS source files
     O, toOdata [options] <files...>             Generate ODATA metadata and annotations

package/lib/render/.eslintrc.json

@@ -7,9 +7,11 @@
     "prefer-template": "error",
     "no-trailing-spaces": "error",
     "sonarjs/cognitive-complexity": "off",
+    "sonarjs/no-duplicate-string": ["off"],
     "sonarjs/no-nested-template-literals": "off",
     "template-curly-spacing":["error", "never"],
-    "complexity": ["warn", 30],
+    // Who cares - just very whiny and in the way
+    "complexity": "off",
     "max-len": "off",
     // We should enable this
     "no-shadow": "off"

package/lib/render/toCdl.js

@@ -8,11 +8,13 @@ const {
   isBuiltinType, generatedByCompilerVersion, getNormalizedQuery,
 } = require('../model/csnUtils');
 const keywords = require('../base/keywords');
-const { renderFunc, processExprArray, findElement } = require('./utils/common');
+const { renderFunc, beautifyExprArray, findElement } = require('./utils/common');
 const { checkCSNVersion } = require('../json/csnVersion');
 const timetrace = require('../utils/timetrace');
 const { csnRefs } = require('../model/csnRefs');
 const { forEachDefinition } = require('../model/csnUtils');
+const enrichUniversalCsn = require('../transform/universalCsnEnricher');
+const { isBetaEnabled } = require('../base/model');
 
 /**
  * Render the CSN model 'model' to CDS source text. One source is created per
@@ -33,6 +35,9 @@ function toCdsSourceCsn(csn, options) {
   // Skip compactModel if already using CSN
   // const csn = cloneCsn(model, options);
 
+  if (options.csnFlavor === 'universal' && isBetaEnabled(options, 'enableUniversalCsn'))
+    enrichUniversalCsn(csn, options);
+
   checkCSNVersion(csn, options);
 
   const result = Object.create(null);
@@ -50,16 +55,20 @@ function toCdsSourceCsn(csn, options) {
       result[main] += `${sourceStr}\n`;
   });
 
-  // Apply possible subelement annotations with an "annotate X with"
+  // Apply possible subelement/action return annotations with an "annotate X with"
+  // Some of them appear in csn.extensions, some not...
   if (subelementAnnotates.length > 0) {
-    for (const [ artName, element, elementName ] of subelementAnnotates) {
-      let sourceStr = `annotate ${artName} with {\n`;
-      sourceStr += `  ${elementName} {\n`;
+    for (const [ artName, element, elementName, suffix ] of subelementAnnotates) {
+      // Suffix is used with action return annotations
+      let sourceStr = `annotate ${artName} with ${suffix ? `${suffix} ` : ''}{\n`;
+      if (elementName) // action returns do not have element name - we need less {} there
+        sourceStr += `  ${elementName} {\n`;
       const env = increaseIndent(increaseIndent(createEnv()));
       const subelements = renderSubelementAnnotates(element, env);
       if (subelements !== '') {
         sourceStr += `${subelements}\n`;
-        sourceStr += '  }\n';
+        if (elementName) // action returns do not have element name - we need less {} there
+          sourceStr += '  }\n';
         sourceStr += '}\n';
         result[main] += `${sourceStr}\n`;
       }
@@ -145,6 +154,12 @@ function toCdsSourceCsn(csn, options) {
       if (ext.elements)
         result += renderElementExtensions(ext.elements, env);
 
+      // Returns annotations
+      if (ext.returns) {
+        const childEnv = increaseIndent(env);
+        result += ` with returns${renderElementExtensions(ext.returns.elements, childEnv)}`;
+      }
+
       // Action annotations
       if (ext.actions) {
         result += ' actions {\n';
@@ -162,10 +177,19 @@ function toCdsSourceCsn(csn, options) {
 
             result += `${paramAnnotations.join(',\n')}\n${childEnv.indent})`;
           }
+          // Annotations on action returns
+          if (action.returns && action.returns.elements) {
+            const grandChildEnv = increaseIndent(childEnv);
+            result += ` returns${renderElementExtensions(action.returns.elements, grandChildEnv)}`;
+          }
+
+
           result += ';\n';
         }
         result += `${env.indent}}`;
       }
+
+
       result += ';';
       return result;
     }).join('\n');
@@ -205,6 +229,7 @@ function toCdsSourceCsn(csn, options) {
   function renderArtifact(artifactName, art, env) {
     // FIXME: Correctly build the paths during runtime to give better locations
     env.path = [ 'definitions', artifactName ];
+    env.artifactName = artifactName;
 
     switch (art.kind) {
       case 'entity':
@@ -509,6 +534,7 @@ function toCdsSourceCsn(csn, options) {
    * @param {Boolean} [isSubElement]
    */
   function renderElement(elementName, elm, env, isSubElement) {
+    env.elementName = elementName;
     let result = renderDocComment(elm, env) + renderAnnotationAssignments(elm, env);
     const quotedElementName = quoteOrUppercaseId(elementName);
     result += `${env.indent + (elm.virtual ? 'virtual ' : '') +
@@ -516,10 +542,11 @@ function toCdsSourceCsn(csn, options) {
                          ((elm.masked && !elm._ignoreMasked) ? 'masked ' : '') +
                          quotedElementName} : ${
       renderTypeReference(elm, env, undefined)
-    }${renderNullability(elm)}`;
+    }${elm.on ? '' : renderNullability(elm)}`;
     if (elm.default)
       result += ` default ${renderExpr(elm.default, env)}`;
 
+    delete env.elementName;
     return `${result};\n`;
   }
 
@@ -1056,8 +1083,11 @@ function toCdsSourceCsn(csn, options) {
     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})`;
-    if (act.returns)
+    if (act.returns) {
+      if (act.returns.type && act.returns.elements) // action returns annotations
+        subelementAnnotates.push([ actionName, act.returns, '', 'returns' ]);
       result += ` returns ${renderTypeReference(act.returns, env)}${renderNullability(act.returns)}`;
+    }
 
     result += ';\n';
     return result;
@@ -1133,6 +1163,10 @@ function toCdsSourceCsn(csn, options) {
       let rc = `many ${renderTypeReference(elm.items, env)}`;
       if (elm.items.notNull != null)
         rc += elm.items.notNull ? ' not null' : ' null';
+      // many sub element annotates
+      if (elm.items.type && elm.items.elements && env.artifactName)
+        subelementAnnotates.push([ env.artifactName, elm.items, env.elementName ]);
+
       return rc;
     }
 
@@ -1316,7 +1350,7 @@ function toCdsSourceCsn(csn, options) {
   function renderExpr(x, env, inline = true, inExpr = false) {
     // Compound expression
     if (Array.isArray(x))
-      return processExprArray(x, renderExpr, env, inline, inExpr);
+      return beautifyExprArray(x.map(item => renderExpr(item, env, inline, inExpr)));
 
     if (typeof x === 'object' && x !== null) {
       if (inExpr && x.cast && x.cast.type)
@@ -1861,6 +1895,8 @@ function toCdsSourceCsn(csn, options) {
  *
  * @property {string}   indent Current indentation as a string, e.g. '  ' for two spaces.
  * @property {CSN.Path} [path] CSN path to the current artifact
+ * @property {string}   artifactName Name of the artifact - set in renderArtifact
+ * @property {string}   elementName Name of the element being rendered - set in renderElement
  * @property {{[name: string]: {
       quotedName: string,
       quotedAlias: string