@sap/cds-compiler 3.1.0 → 3.3.2

package/lib/inspect/inspectModelStatistics.js

@@ -14,7 +14,7 @@ function inspectModelStatistics(xsn, options) {
   let result = '';
 
   // Default color mode is 'auto'
-  const color = term(options.color || 'auto');
+  const color = term(options.color !== undefined ? options.color : 'auto');
 
   const defCount = countDefinitionKinds(xsn);
   const sources = {

package/lib/inspect/inspectPropagation.js

@@ -16,7 +16,7 @@ function inspectPropagation(xsn, options, artifactName) {
   const result = [];
 
   // Default color mode is 'auto'
-  const color = term(options.color || 'auto');
+  const color = term(options.color !== undefined ? options.color : 'auto');
 
   const path = stringRefToPath(artifactName);
   if (!path) {
@@ -121,19 +121,28 @@ function _inspectElements(artifactXsn) {
   const result = [];
   const elements = Object.keys(artifactXsn.elements);
 
-  let maxElemLength = 12;
-
   const inferredNiceOutput = {
     '*': 'wildcard',
-    'expand-element': 'expanded',
-    'expand-param': 'expanded',
     'aspect-composition': 'composition',
   };
 
+  let maxElemLength = 12;
+  let maxOriginLength = 6;
+
+  // type: assume max length 11 of 'composition'
+  // element: assume average length of 30, chosen randomly
+  result.push([
+    'type'.padStart(11),
+    'element'.padEnd(maxElemLength),
+    'origin'.padEnd(maxOriginLength),
+    'location (definition)',
+  ].join(' | '));
+
   for (const element of elements) {
     const elementXsn = artifactXsn.elements[element];
     const loc = locationString(_origin(elementXsn).name.location);
     let origin;
+    const originName = elementXsn._origin?.name?.absolute || '';
 
     if (elementXsn.$inferred) {
       // Use nice(r) output for known $inferred
@@ -151,11 +160,16 @@ function _inspectElements(artifactXsn) {
     }
 
     maxElemLength = Math.max(maxElemLength, element.length);
-
-    // origin: assume max length 11 of 'composition'
-    // element: assume average length of 30, chosen randomly
-    result.push([ origin.padStart(11), element.padEnd(maxElemLength), loc ].join(' | '));
+    maxOriginLength = Math.max(maxOriginLength, originName.length);
+
+    result.push([
+      origin.padStart(11),
+      element.padEnd(maxElemLength),
+      originName.padEnd(maxOriginLength),
+      loc,
+    ].join(' | '));
   }
+
   return result;
 }
 

package/lib/json/csnVersion.js

@@ -39,7 +39,7 @@ function checkCSNVersion(csn, options) {
     errStr += `${ csn.version && csn.version.csn ? csn.version.csn : (csn.$version ? csn.$version : 'not available') }"`;
     errStr += (options.newCsn !== undefined) ? `, options.newCsn: ${ options.newCsn }` : '';
 
-    error(null, null, errStr);
+    error(null, null, {}, errStr);
     throwWithAnyError();
   }
 }

package/lib/json/from-csn.js

@@ -117,13 +117,14 @@ const exprProperties = [
 const xorGroups = {
   // include CSN v0.1.0 properties here:
   ':type': [ 'target', 'elements', 'enum', 'items' ],
-  ':expr': [
-    'ref', 'xpr', 'list', 'val', '#', 'func', 'SELECT', 'SET',
+  ':expr': [                    // see also xorException property in schema
+    'ref', 'xpr', 'list', 'val', '#', 'func', 'SELECT', 'SET', 'expand',
     '=', 'path', 'value', 'op', // '='/'path' is CSN v0.1.0 here
   ],
   ':ext': [ 'annotate', 'extend' ], // TODO: better msg for test/negative/UnexpectedProperties.csn
   ':assoc': [ 'on', 'keys', 'foreignKeys', 'onCond' ], // 'foreignKeys'/'onCond' is CSN v0.1.0
-  ':join': [ 'join', 'as' ],
+  // TODO - improve consequential errors: assume no name given with `join` or `inline`?
+  as: [ 'as', 'join', 'inline' ],
   scope: [ 'param', 'global' ],
   quantifier: [ 'some', 'any', 'distinct', 'all' ],
   // quantifiers 'some' and 'any are 'xpr' token strings in CSN v1.0
@@ -155,11 +156,12 @@ const schemaClasses = {
     defaultKind: '$column',
     validKinds: [], // pseudo kind '$column'
     // A column with only as+cast.type is a new association
-    requires: [ 'ref', 'as', 'xpr', 'val', '#', 'func', 'list', 'SELECT', 'SET', 'expand' ],
+    requires: [ 'ref', 'cast', 'xpr', 'val', '#', 'func', 'list', 'SELECT', 'SET', 'expand' ],
     schema: {
       xpr: {
         class: 'condition',
         type: xprInValue,
+        xorException: 'func',   // see xorGroup :expr
         inKind: [ '$column' ],
         inValue: true,
       },
@@ -248,10 +250,12 @@ const schema = compileSchema( {
   },
   expand: {
     class: 'columns',
-    inKind: [ '$column' ], // only valid in $column
+    xorException: 'ref',        // see xorGroup :expr
+    inKind: [ '$column' ],      // only valid in $column
   },
   inline: {
     class: 'columns',
+    onlyWith: 'ref',
     inKind: [ '$column' ], // only valid in $column
   },
   keys: {
@@ -294,7 +298,7 @@ const schema = compileSchema( {
     type: artifactRef,
     msgId: 'syntax-expected-reference',
     optional: [ 'ref', 'global' ],
-    inKind: [ 'element', 'type', 'param', 'mixin', 'event', 'annotation' ],
+    inKind: [ 'element', 'type', 'param', 'mixin', 'event', 'annotation', 'extend' ],
   },
   targetAspect: {
     type: artifactRef,
@@ -323,20 +327,20 @@ const schema = compileSchema( {
   },
   length: {
     type: natnum,
-    inKind: [ 'element', 'type', 'param', 'annotation' ],
+    inKind: [ 'element', 'type', 'param', 'annotation', 'extend' ],
     // we do not require a 'type', too - could be useful alone in a 'cast'
   },
   precision: {
     type: natnum,
-    inKind: [ 'element', 'type', 'param', 'annotation' ],
+    inKind: [ 'element', 'type', 'param', 'annotation', 'extend' ],
   },
   scale: {
     type: scalenum,
-    inKind: [ 'element', 'type', 'param', 'annotation' ],
+    inKind: [ 'element', 'type', 'param', 'annotation', 'extend' ],
   },
   srid: {
     type: natnum,
-    inKind: [ 'element', 'type', 'param', 'annotation' ],
+    inKind: [ 'element', 'type', 'param', 'annotation' ], // no 'extend'!
   },
   srcmin: {                        // in 'cardinality'
     type: renameTo( 'sourceMin', natnum ),
@@ -372,6 +376,7 @@ const schema = compileSchema( {
     minLength: 1,
     requires: 'id',
     optional: [ 'id', 'args', 'cardinality', 'where' ],
+    xorException: 'expand',     // see xorGroup :expr
     inKind: [ '$column', 'key' ],
   },
   id: {                         // in 'ref' item
@@ -389,6 +394,7 @@ const schema = compileSchema( {
   },
   func: {
     type: func,
+    xorException: 'xpr',       // see xorGroup :expr
     inKind: [ '$column' ],
   },
   args: {
@@ -405,6 +411,7 @@ const schema = compileSchema( {
   xpr: {
     class: 'condition',
     type: xpr,
+    xorException: 'func',       // see xorGroup :expr
     // special treatment in $column
   },
   list: {
@@ -747,6 +754,7 @@ function compileSchema( specs, proto = null) {
   }
   if (proto)
     return r;
+  // Set property 'inValue' in main schema only:
   for (const prop of exprProperties) {
     if (r[prop].inValue === undefined)
       r[prop].inValue = true;
@@ -1559,7 +1567,7 @@ function getSpec( parentSpec, csn, prop, xor, expected, kind ) {
              } );
     // TODO: or still augment it? (but then also handle xorGroup)
   }
-  else if (checkAndSetXorGroup( s.xorGroup, prop, xor )) {
+  else if (checkAndSetXorGroup( s.xorGroup, s.xorException, prop, xor )) {
     onlyWith( s, s.onlyWith, csn, prop, xor, expected );
     return s;
   }
@@ -1622,18 +1630,17 @@ function onlyWith( spec, need, csn, prop, xor, expected ) {
   return spec;
 }
 
-function checkAndSetXorGroup( group, prop, xor ) {
+function checkAndSetXorGroup( group, exception, prop, xor ) {
   if (!group)
     return true;
-  if (!xor[group]) {
+  const otherprop = xor[group];
+  if (!otherprop) {
     xor[group] = prop;
     return true;
   }
-  if (prop === 'func' && xor[group] === 'xpr' ||
-      prop === 'xpr' && xor[group] === 'func')
-    return true;                // hack for window function: both func and xpr is allowed
-  error( 'syntax-excluded-property', location(true),
-         { prop, otherprop: xor[group] },
+  if (otherprop === exception)
+    return true;
+  error( 'syntax-excluded-property', location(true), { prop, otherprop },
          'CSN property $(PROP) can only be used alternatively to $(OTHERPROP)');
   return false;
 }
@@ -1767,7 +1774,7 @@ function toXsn( csn, filename, options, messageFunctions ) {
   ({ message, error, warning, info } = messageFunctions);
 
   if (csnVersionZero) {
-    warning( 'syntax-csn-zero-version', location(true),
+    warning( 'syntax-csn-zero-version', location(true), {},
              'Parsing CSN version 0.1.0' );
   }
   const r = object( csn, topLevelSpec );

package/lib/json/to-csn.js

@@ -252,9 +252,10 @@ function sortCsn( csn, cloneOptions = false ) {
     const sortDict = n === 'definitions' &&
                      (!cloneOptions || cloneOptions.testMode || cloneOptions.testSortCsn);
     const val = csn[n];
-    if (!val || typeof val !== 'object' || n.charAt(0) === '@' || csnDirectValues.includes(n))
+    if (!val || typeof val !== 'object' || csnDirectValues.includes(n))
       r[n] = val;
-
+    else if (n.charAt(0) === '@')
+      r[n] = cloneAnnotationValue( val );
     else if (csnDictionaries.includes(n) && !Array.isArray(val))
       // Array check for property `args` which may either be a dictionary or an array.
       r[n] = csnDictionary( val, sortDict, cloneOptions );
@@ -279,6 +280,12 @@ function sortCsn( csn, cloneOptions = false ) {
   return r;
 }
 
+function cloneAnnotationValue(val) {
+  if (typeof val !== 'object') // scalar
+    return val;
+  return JSON.parse( JSON.stringify( val ) );
+}
+
 /**
  * Check whether the given object has non enumerable property.
  * Ensure that we don't take it from the prototype, only "directly" - we accidentally
@@ -663,7 +670,9 @@ function elements( dict, csn, node ) {
     // no 'elements' with SELECT or inferred elements with gensrc;
     // hidden or visible 'elements' will be set in query()
     return undefined;
-  return insertOrderDict( dict );
+  if (dict !== 0)
+    return insertOrderDict( dict );
+  return undefined;
 }
 
 function enumDict( dict, csn, node ) {
@@ -927,6 +936,11 @@ function addOrigin( csn, xsn, node ) {
   let origin = getOrigin( node );
   if (xsn.$inferred === 'composition-entity') {
     csn.$origin = originRef( origin, xsn );
+    inferredPropertiesForOrigin( csn, node );
+    return;
+  }
+  else if (xsn.$inferred === 'localized-entity') {
+    inferredPropertiesForOrigin( csn, node );
     return;
   }
   else if (!isMember( xsn ) || xsn.kind === 'select') {
@@ -993,6 +1007,30 @@ function addOrigin( csn, xsn, node ) {
   }
 }
 
+/**
+ * Copy properties with $inferred === 'parent-origin' to $origin.
+ * This indicates that the property is neither direct nor can be inferred through $origin.
+ *
+ * @param csn
+ * @param node
+ */
+function inferredPropertiesForOrigin( csn, node ) {
+  let hasProp = false;
+  const props = {};
+  for (const prop of Object.keys(node)) {
+    if (node[prop]?.$inferred === 'parent-origin') {
+      hasProp = true;
+      props[prop] = value({ ...node[prop], $inferred: false });
+    }
+  }
+  const origin = csn.$origin;
+  if (hasProp) {
+    csn.$origin = props;
+    if (origin)
+      csn.$origin.$origin = origin;
+  }
+}
+
 function getParent( art ) {
   const parent = art._parent;
   const main = parent._main;
@@ -1092,7 +1130,9 @@ function type( node, csn, xsn ) {
     return undefined;
   if (xsn._origin) {
     if (xsn._origin.$inferred === 'REDIRECTED') { // auto-redirected user-provided target
-      csn.$origin = definition( xsn._origin );
+      const $origin = definition( xsn._origin );
+      if ($origin)              // if not rendered as column
+        csn.$origin = $origin;
     }
   }
   return artifactRef( node, !node.$extra );
@@ -1210,7 +1250,8 @@ function value( node ) {
   if (!node)
     return true;                // `@aBool` short for `@aBool: true`
   if (universalCsn && node.$inferred) {
-    if (node.$inferred === 'prop' || node.$inferred === '$generated') // via propagator.js
+    if (node.$inferred === 'prop' || node.$inferred === '$generated' || // via propagator.js
+      node.$inferred === 'parent-origin')
       return undefined;
     else if (node.$inferred === 'NULL')
       return null;
@@ -1610,6 +1651,7 @@ function initModuleVars( options = { csnFlavor: 'gensrc' } ) {
 
 module.exports = {
   cloneCsnDictionary: (csn, options) => csnDictionary(csn, false, options),
+  cloneAnnotationValue,
   compactModel,
   compactQuery,
   compactExpr,

package/lib/language/antlrParser.js

@@ -25,7 +25,7 @@ class ErrorListener extends antlr4.error.ErrorListener {
   // method which is called by generated parser with --trace-parser[-amg]:
   syntaxError( recognizer, offendingSymbol, line, column, msg, e ) {
     if (!(e instanceof CompileMessage)) // not already reported
-      recognizer.error( null, offendingSymbol, msg );
+      recognizer.error( null, offendingSymbol, {}, msg );
   }
 }
 

package/lib/language/genericAntlrParser.js

@@ -133,7 +133,7 @@ function notSupportedYet( text, ...tokens ) {
     tokens = [ text, ...tokens ];
     text = `${ tokens.map( t => t.text.toUpperCase() ).join(' ') } is not supported`;
   }
-  this.error( null, this.tokenLocation( tokens[0], tokens[tokens.length - 1] ), text );
+  this.error( null, this.tokenLocation( tokens[0], tokens[tokens.length - 1] ), {}, text );
 }
 
 // Use the following function for language constructs which we (currently) do
@@ -146,7 +146,7 @@ function csnParseOnly( text, ...tokens ) {
     tokens = [ text, ...tokens ];
     text = `${ tokens.map( t => t.text.toUpperCase() ).join(' ') } is not supported`;
   }
-  this.error( null, this.tokenLocation( tokens[0], tokens[tokens.length - 1] ), text );
+  this.error( null, this.tokenLocation( tokens[0], tokens[tokens.length - 1] ), {}, text );
 }
 
  /** @this {object} */
@@ -607,6 +607,8 @@ function classifyImplicitName( category, ref ) {
 }
 
 function fragileAlias( ast, safe = false ) {
+  if (this.getCurrentToken().text === '.')
+    return ast;
   if (safe || ast.$delimited || !/^[a-zA-Z][a-zA-Z_]+$/.test( ast.id ))
     this.warning( 'syntax-sloppy-alias', ast.location, { keyword: 'as' },
                   'Please add the keyword $(KEYWORD) in front of the alias name' );
@@ -687,8 +689,8 @@ function valuePathAst( ref ) {
     const item = path.find( i => i.args && i.$syntax !== ':' );
     if (!item)
       return ref;
-    this.error( 'syntax-not-supported', item.location,
-                'Methods in expressions are not supported yet' );
+    this.error( 'syntax-not-supported', item.location, {},
+      'Methods in expressions are not supported yet' );
     path.broken = true;
     path.length = 1;
   }
@@ -1063,15 +1065,29 @@ function associationInSelectItem( art ) {
   }
 }
 
-function reportExpandInline( clauseName ) {
-  let token = this.getCurrentToken();
-  // improve error location when using "inline" `.{…}` after ref (arguments and
-  // filters not covered, not worth the effort); after an expression where
-  // the last token is an identifier, not the `.` is wrong, but the `{`:
-  if (token.text === '.' && this._input.LT(-1).type >= this.constructor.Identifier)
-    token = this._input.LT(2);
-  this.error( 'syntax-unexpected-refclause', token, { prop: clauseName },
-              'Unexpected nested $(PROP), can only be used after a reference' );
+function reportExpandInline( column, isInline ) {
+  const { name } = column;
+  if (column.value && !column.value.path) {
+    let token = this.getCurrentToken();
+    // improve error location when using "inline" `.{…}` after ref (arguments and
+    // filters not covered, not worth the effort); after an expression where
+    // the last token is an identifier, not the `.` is wrong, but the `{`:
+    if (isInline && !name && this._input.LT(-1).type >= this.constructor.Identifier)
+      token = this._input.LT(2);
+    this.error( 'syntax-unexpected-nested-proj', token,
+                { prop: isInline ? 'inline' : 'expand' },
+                { std: 'Unexpected nested $(PROP), can only be used after a reference' } );
+    // continuation semantics:
+    // - add elements anyway (could lead to duplicate errors as usual)
+    // - no errors for refs inside expand/inline, but for refs in sibling expr
+    // - think about: reference to these (sub) elements from other view
+  }
+  if (isInline && name) {
+    const location = this.tokenLocation( isInline, this._input.LT(-1) );
+    this.error( 'syntax-unexpected-alias', location, { prop: 'inline' },
+                'Unexpected alias name before nested $(PROP)' );
+    // continuation semantics: ignore AS
+  }
 }
 
 function checkTypeFacet( art, argIdent ) {

package/lib/language/language.g4

@@ -751,7 +751,7 @@ extendType[ art, outer ] locals[ name = {} ]
     { $art.expectedKind = 'type'; $art.name = $name;
       this.addItem( $art, $outer, 'extensions', 'extend' );
     }
-    extendWithOptElements[ $art, $art ]
+    extendWithOptElementsOrType[ $art, $art ]
   ;
 
 annotationDef[ art, outer ] locals[ name = {} ]
@@ -840,11 +840,16 @@ extendArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
         enumSymbolDef[ $art ]*  // TODO: no EXTEND in enum? (ok, would just allow annos)
         '}' { this.finalizeDictOrArray( $art.enum ); }
         optionalSemi
+      |
+        // extend Art with (length: 10);
+        // `with` is required, or we could have `extend String(length:10);`.
+        typeNamedArgList[ $art ]
+        requiredSemi
       )
     )
   ;
 
-extendWithOptElements[ art ]
+extendWithOptElementsOrType[ art ]
   :
     WITH { this.noSemicolonHere(); this.docComment( $art ); }
     annotationAssignment_ll1[ $art ]*
@@ -857,6 +862,10 @@ extendWithOptElements[ art ]
       '}' { this.finalizeDictOrArray( $art.elements ); }
       { this.checkExtensionDict( $art.elements ); }
       optionalSemi
+    |
+      // extend type|element Art with (length: 10);
+      typeNamedArgList[ $art ]
+      requiredSemi
     |
       requiredSemi
     )
@@ -1220,7 +1229,7 @@ extendElement[ art, outer ]
     ( expected=ELEMENT { $art.expectedKind = 'element'; } )?
     name=ident['Element']
     { this.addDef( $art, $outer, 'elements', 'extend', $name.id ); }
-    extendWithOptElements[ $art, $art ]
+    extendWithOptElementsOrType[ $art, $art ]
   ;
 
 selectItemDef[ outer ] locals[ art ]
@@ -1246,19 +1255,20 @@ selectItemDefBody[ art, outer ]
       e=expression { $art.value = $e.expr; }
       // we cannot use 'condition' instead, as long as we allow aliases without
       // AS (using rule 'ident' instead of 'identNoKeyword') -> ambiguities
-      ( AS n1=ident['Item'] { $art.name = $n1.id }
+      ( as=AS n1=ident['Item'] { $art.name = $n1.id }
       | n2=ident['Item'] { $art.name = this.fragileAlias( $n2.id, true ); }
       | { if (this.getCurrentToken().text !== '.') this.classifyImplicitName( 'Item', $e.expr ); }
       )
-      { if ($art.value && !$art.value.path) this.excludeExpected( ["'.'", "'{'"] ); }
+      { if ($art.value && !$art.value.path) this.excludeExpected( ["'.'", "'{'"] );
+        else if ($art.name) this.excludeExpected( ["'.'"] );
+      }
       (
-        { if ($art.value && !$art.value.path) this.reportExpandInline( 'expand' ); }
+        { this.reportExpandInline( $art, false ); }
         selectItemInlineList[ $art, 'expand' ]
         excludingClause[ $art ]?
         // TODO: we might alternatively allow AS here
       |
-        // TODO: complain if AS has been used - or in definer?
-        { if ($art.value && !$art.value.path) this.reportExpandInline( 'inline' ); }
+        { this.reportExpandInline( $art, $as || this._input.LT(-1) ); }
         DOTbeforeBRACE          // ...orASTERISK
         (
           selectItemInlineList[ $art, 'inline' ]
@@ -1799,6 +1809,16 @@ typeRefArgs[ art ]
     ')'{ this.finalizeDictOrArray( $art['$'+'typeArgs']); }
   ;
 
+typeNamedArgList[ art ]
+  :
+    paren='('
+    typeNamedArg[ $art ]
+    ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
+      typeNamedArg[ $art ]
+    )*
+    ')'
+  ;
+
 typeNamedArg[ art ] locals[ arg = '' ]
   :
     name=ident['paramname']

package/lib/main.d.ts

@@ -786,15 +786,12 @@ declare namespace compiler {
    */
   export type CdlResult = {
     /**
-     * Rendered model, excluding not-applied extensions.
+     * Rendered model, including extensions.
      */
     model?: string
     /**
-     * Rendered extend/annotate statements of `csn.extensions`
-     */
-    unappliedExtensions?: string
-    /**
-     * Rendered csn.namespace property + using directives.
+     * Rendered `csn.namespace` property + using directives.
+     * Useful to keep the `csn.namespace` property when re-compiling the to.cdl() result.
      */
     namespace?: string
   }

package/lib/model/.eslintrc.json

@@ -0,0 +1,13 @@
+{
+  "root": true,
+  "extends": "../../.eslintrc-ydkjsi.json",
+  "rules": {
+    "max-len": [ "error", {
+      "code": 180, // TODO: Remove
+      "tabWidth": 2,
+      "ignoreRegExpLiterals": false,
+      "ignoreStrings": false,
+      "ignoreTemplateLiterals": true
+    }]
+  }
+}

package/lib/model/api.js

@@ -2,6 +2,8 @@
 
 // Do not change at will - they are in the compiler API!
 
+'use strict';
+
 /**
  * Dictionary of default traversal functions for function `traverseCsn`.
  * It maps CSN property names to functions which are used by default
@@ -23,8 +25,8 @@ const defaultFunctions = {
   actions: dictionary,
   mixin: dictionary,
   definitions: dictionary,
-  '$': () => { /*  do not traverse properties starting with '$' */},
-}
+  $: () => { /*  do not traverse properties starting with '$' */ },
+};
 
 /**
  * Traverse the CSN node `csn`.