@sap/cds-compiler 2.13.8 → 2.15.6

package/lib/json/csnVersion.js

@@ -15,18 +15,17 @@
 //  0.1.99 : Like 0.1.0, but with new-style CSN
 //  0.2 : same as 0.1.99, but with new top-level properties: $version, meta
 
-// Use literal version constants intentionally and not number intervals to 
+// Use literal version constants intentionally and not number intervals to
 // record all published version strings of the core compiler.
-const newCSNVersions = ["0.1.99","0.2","0.2.0","1.0","2.0"];
+const newCSNVersions = [ '0.1.99', '0.2', '0.2.0', '1.0', '2.0' ];
 // checks if new-csn is requested via the options of already specified in the CSN
 // default: old-style
 function isNewCSN(csn, options) {
-  if( (options && options.newCsn ===  false) ||
+  if ( (options && options.newCsn === false) ||
         (csn.version && !newCSNVersions.includes(csn.version.csn)) ||
         (csn.$version && !newCSNVersions.includes(csn.$version)))
-        {
     return false;
-  }
+
   return true;
 }
 
@@ -34,18 +33,18 @@ function checkCSNVersion(csn, options) {
   if (!isNewCSN(csn, options)) {
     // the new transformer works only with new CSN
     const { makeMessageFunction } = require('../base/messages');
-    const { error, throwWithError } = makeMessageFunction(csn, options);
+    const { error, throwWithAnyError } = makeMessageFunction(csn, options);
 
     let errStr = 'CSN Version not supported, version tag: "';
-    errStr += (csn.version && csn.version.csn ? csn.version.csn : (csn.$version ? csn.$version : 'not available')) + '"';
-    errStr += (options.newCsn !== undefined) ? ', options.newCsn: ' + options.newCsn : '';
+    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);
-    throwWithError();
+    throwWithAnyError();
   }
 }
 
 module.exports = {
   isNewCSN,
-  checkCSNVersion
-}
+  checkCSNVersion,
+};

package/lib/json/from-csn.js

@@ -152,7 +152,8 @@ const schemaClasses = {
     msgId: 'syntax-csn-expected-column',
     defaultKind: '$column',
     validKinds: [], // pseudo kind '$column'
-    requires: [ 'ref', 'xpr', 'val', '#', 'func', 'list', 'SELECT', 'SET', 'expand' ],
+    // A column with only as+cast.type is a new association
+    requires: [ 'ref', 'as', 'xpr', 'val', '#', 'func', 'list', 'SELECT', 'SET', 'expand' ],
     schema: {
       xpr: {
         class: 'condition',
@@ -197,7 +198,7 @@ const schema = compileSchema( {
     dictionaryOf: definition,
     defaultKind: 'enum',
     validKinds: [ 'enum' ],
-    inKind: [ 'element', 'type', 'param', 'annotation', 'annotate' ],
+    inKind: [ 'element', 'type', 'param', 'annotation', 'annotate', 'extend' ],
   },
   elements: {
     dictionaryOf: definition,

package/lib/json/to-csn.js

@@ -404,8 +404,6 @@ function usings( srcDict ) {
  * @param {object} csn
  * @param {object} model
  */
-
-
 function extensions( node, csn, model ) {
   if (model.kind && model.kind !== 'source')
     return undefined;

package/lib/language/docCommentParser.js

@@ -36,14 +36,14 @@ function parseDocComment(comment) {
   else if (lines.length === 2) {
     // Comment that is essentially just a header + footer.
     // First line, i.e. header, is always trimmed from left.
-    lines[0] = lines[0].trimLeft();
+    lines[0] = lines[0].trimStart();
 
     // If the second line starts with an asterisk then remove it.
     // Otherwise trim all whitespace.
     if ((/^\s*[*]/.test(lines[1])))
       lines[1] = removeFence(lines[1]);
     else
-      lines[1] = lines[1].trimLeft();
+      lines[1] = lines[1].trimStart();
   }
   else {
     const firstNonEmptyLine = lines.find((line, index) => index !== 0 && /[^\s]/.test(line)) || '';

package/lib/language/genericAntlrParser.js

@@ -93,7 +93,9 @@ GenericAntlrParser.prototype = Object.assign(
     setMaxCardinality,
     pushIdent,
     handleComposition,
+    associationInSelectItem,
     reportExpandInline,
+    checkTypeFacet,
     notSupportedYet,
     csnParseOnly,
     disallowElementExtension,
@@ -594,11 +596,11 @@ function numberLiteral( token, sign, text = token.text ) {
     location.endCol = endCol;
     text = sign.text + text;
   }
+
   const num = Number.parseFloat( text || '0' ); // not Number.parseInt() !
   if (!Number.isSafeInteger(num)) {
     if (sign == null) {
-      this.error( 'syntax-no-integer', token, {},
-                  'An integer number is expected here' );
+      this.error( 'syntax-expected-integer', token, { '#': !text.match(/^[0-9]*$/) ? 'normal' : 'unsafe'} );
     }
     else if (text !== `${num}`) {
       return { literal: 'number', val: text, location };
@@ -902,6 +904,31 @@ function handleComposition( cardinality, isComposition ) {
   this.excludeExpected( [ [ "'}'", 'COMPOSITIONofBRACE' ], brace1, ...manyOne ] );
 }
 
+function associationInSelectItem( art ) {
+  const isPath = art.value.path && art.value.path.length
+  const isIdentifier = isPath && art.value.path.length === 1;
+  if (isIdentifier) {
+    if (!art.name) {
+      art.name = art.value.path[0];
+    } else {
+      // Use alias if provided, i.e. ignore art.value.path.
+      this.error( 'query-unexpected-alias', art.name.location, {},
+        'Unexpected alias for association' );
+    }
+    delete art.value;
+  } else {
+    const loc = isPath ? art.value.path[1].location : art.value.location;
+    // If neither path nor alias are present, `query-req-name` is emitted in `populate.js`.
+    if (isPath || art.name) {
+      this.error( 'query-expected-identifier', loc, { '#': 'assoc' } );
+      if (isPath) {
+        art.name = art.value.path[art.value.path.length - 1];
+      }
+      delete art.value;
+    }
+  }
+}
+
 function reportExpandInline( clauseName ) {
   let token = this.getCurrentToken();
   // improve error location when using "inline" `.{…}` after ref (arguments and
@@ -913,6 +940,24 @@ function reportExpandInline( clauseName ) {
               'Unexpected nested $(PROP), can only be used after a reference' );
 }
 
+function checkTypeFacet( art, argIdent ) {
+  const id = argIdent.id;
+  if (id === 'length' || id === 'scale' || id === 'precision' || id === 'srid') {
+    if (art[id] !== undefined) {
+      this.error( 'syntax-duplicate-argument', argIdent.location,
+        { '#': 'duplicate', code: id } );
+      this.error( 'syntax-duplicate-argument', art[id].location,
+        { '#': 'duplicate', code: id } );
+    }
+    return true;
+
+  } else {
+    this.error( 'syntax-duplicate-argument', argIdent.location,
+      { '#': 'unknown', code: id } );
+    return false;
+  }
+}
+
 module.exports = {
   genericAntlrParser: GenericAntlrParser,
 };

package/lib/language/language.g4

@@ -1279,7 +1279,7 @@ selectItemDef[ outer ] locals[ annos = [] ]
   ;
 
 selectItemDefBody[ outer, annos ] returns[ art = {} ]
-@after{ /* #ATN 1 */ this.attachLocation($art); }
+@after{ /* #ATN 2 */ this.attachLocation($art); }
   :
     (
       e=expression
@@ -1335,6 +1335,12 @@ selectItemDefBody[ outer, annos ] returns[ art = {} ]
       | typeRefOptArgs[ $art ]         // TODO: annos here?
         { this.docComment( $annos ); }
         annotationAssignment_ll1[ $annos ]*
+      |
+        typeAssociationBase[ $art, false ]
+        // #ATN: path could start with MANY or ONE - make sure a token follows in same rule!
+        ( typeToMany[ $art ] | typeToOne[ $art ] | simplePath[ $art.target, 'artref' ] )
+        typeAssociationCont[ $art ]?
+        { this.associationInSelectItem( $art ); }
       )
     )?
   ;
@@ -1592,26 +1598,7 @@ typeSpecSemi[ art, annos ]      // with 'includes', for type and annotation defs
       { $art.type = {}; }
       simplePath[ $art.type, 'artref' ]
       (
-        '(' // with type args, e.g. `type T : String(100) enum { ... }`
-        head=Number
-        { $art['$'+'typeArgs'] = [ this.numberLiteral( $head ) ]; }
-        ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
-          (
-            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 ) ); }
-          )
-        )*
-        ')'
+        typeRefArgs[ $art ]
         { this.docComment( $annos ); }
         annotationAssignment_ll1[ $annos ]*
         (
@@ -1855,7 +1842,19 @@ typeRefOptArgs[ art ]
   :
     simplePath[ $art.type, 'artref' ]
     (
-      '('
+      typeRefArgs[ $art ]
+    |
+      ':'
+      { $art.type.scope = $art.type.path.length; }
+      simplePath[ $art.type, 'ref']
+    )?
+  ;
+
+typeRefArgs[ art ]
+  :
+    paren='('
+    (
+      // unnamed arguments
       head=Number
       { $art['$'+'typeArgs'] = [ this.numberLiteral( $head ) ]; }
       ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
@@ -1874,14 +1873,45 @@ typeRefOptArgs[ art ]
           { $art['$'+'typeArgs'].push( this.numberLiteral( $tail ) ); }
         )
       )*
-      ')'
     |
-      ':'
-      { $art.type.scope = $art.type.path.length; }
-      simplePath[ $art.type, 'ref']
-    )?
+      // named arguments
+      typeNamedArg[ $art ]
+      ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
+        typeNamedArg[ $art ]
+      )*
+    )
+    ')'
+  ;
+
+typeNamedArg[ art ] locals[ arg = '' ]
+  :
+    name=ident['paramname']
+    ':'
+    { if (this.checkTypeFacet( $art, $name.id ))
+        $arg = $name.id.id;
+    }
+    (
+      val=Number
+      { if ($arg && $art && $name.id) {
+          $art[$arg] = this.numberLiteral( $val );
+        }
+      }
+    |
+      v=VARIABLE
+      { if ($arg && $art && $name.id) {
+          $art[$arg] = { literal: 'string', val: 'variable', location: this.tokenLocation($v) };
+        }
+      }
+    |
+      f=FLOATING
+      { if ($arg && $art && $name.id) {
+          $art[$arg] = { literal: 'string', val: 'floating', location: this.tokenLocation($f) };
+        }
+      }
+    )
   ;
 
+
 // Queries -------------------------------------------------------------------
 
 queryExpression returns[ query ] // QLSubqueryComplex, SubqueryComplex
@@ -2241,6 +2271,7 @@ conditionAnd returns [ cond ] locals [ args = [], andl = [] ]
     ( and=AND c2=conditionTerm { $args.push($c2.cond); $andl.push(this.valueWithTokenLocation( 'and', $and )) } )*
   ;
 
+// Note: New operators need to be added to functionExpressionOperatorsRequireParentheses[] in toCdl.js.
 conditionTerm returns [ cond ]
 @after{
   if ($cond) { this.attachLocation($cond); } else { $cond = $expr.expr; }
@@ -2288,6 +2319,7 @@ conditionTerm returns [ cond ]
     )?                          // optional: for conditions in parentheses
   ;
 
+// Note: New operators need to be added to functionExpressionOperatorsRequireParentheses[] in toCdl.js.
 predicate[ cond, negated ]
 // As an alternative, we could have a `negated` properties for the operations
 // `isNull`(!), `in`, `between` and `like` (or produce the same AST as for

package/lib/main.d.ts

@@ -81,6 +81,11 @@ declare namespace compiler {
      * use this frontend as the fallback parser.
      */
     fallbackParser?: string | 'cdl' | 'csn'
+    /**
+     * Where to find `@sap/cds/` packages. This string, if set, is used as
+     * the prefix for SAP CDS packages / CDS files.
+     */
+    cdsHome?: string
     /**
      * Option for {@link compileSources}.  If set, all objects inside the
      * provided sources dictionary are interpreted as XSN structures instead
@@ -895,7 +900,20 @@ declare namespace compiler {
    * The functions in `userFunctions` are usually transformer functions, which
    * change the input CSN destructively.
    */
-  export function traverseCsn(userFunctions: Record<string, Function>, csn: object|any[]);
+  export function traverseCsn(userFunctions: Record<string, Function>, csn: object|any[]): void;
+
+  /**
+   * CSN Model related functions.
+   */
+  export namespace model {
+    /**
+     * Returns true if the given definition name is in a reserved namespace such as `cds.*`
+     * but not `cds.foundation.*`.
+     *
+     * @param definitionName Top-level definition name of the artifact.
+     */
+    function isInReservedNamespace(definitionName: string): boolean;
+  }
 
   /**
    * @private

package/lib/main.js

@@ -25,6 +25,7 @@ const parseLanguage = require('./language/antlrParser');
 const { parseX, compileX, compileSyncX, compileSourcesX, InvocationError } = require('./compiler');
 const { fns } = require('./compiler/shared');
 const define = require('./compiler/define');
+const { isInReservedNamespace } = require("./compiler/builtins");
 const finalizeParseCdl = require('./compiler/finalize-parse-cdl');
 
 // The compiler version (taken from package.json)
@@ -148,4 +149,9 @@ module.exports = {
   // it, you MUST talk with us - there can be potential incompatibilities with
   // new releases (even having the same major version):
   $lsp: { parse: parseX, compile: compileX, getArtifactName: a => a.name },
+
+  // CSN Model related functionality
+  model: {
+    isInReservedNamespace,
+  },
 };

package/lib/model/csnRefs.js

@@ -442,7 +442,11 @@ function csnRefs( csn, universalReady ) {
     const queries = cached( main, '$queries', allQueries );
     for (const qcache of queries || []) {
       const { _select } = qcache;
-      traverseType( _select, main, null, null, initNode ); // also inits elements
+      const { elements } = _select;
+      if (elements) {
+        for (const n of Object.keys( elements ))
+          traverseDef( elements[n], _select, 'element', n, initNode );
+      }
       if (_select.mixin) {
         for (const n of Object.keys( _select.mixin ))
           setCache( _select.mixin[n], '_parent', _select ); // relevant initNode() part
@@ -453,7 +457,13 @@ function csnRefs( csn, universalReady ) {
 
   function initNode( art, parent, kind, name ) {
     setCache( art, '_parent', parent );
-    if (art.type || !kind || kind === 'target') // with type, top-level, query or mixin
+    if (kind === 'target') {
+      // Prevent re-initialization of anonymous aspect with initDefinition():
+      // (that would be with parent: null which would be wrong)
+      setCache( art, '$queries', null );
+      return;
+    }
+    if (art.type || !kind)      // with type, top-level, query or mixin
       return;
     const { $origin } = art;
     if (typeof $origin === 'object') // null, […], {…}
@@ -547,8 +557,19 @@ function csnRefs( csn, universalReady ) {
     }
     if (baseEnv)                // ref-target (filter condition), expand, inline
       return resolvePath( path, baseEnv.elements[head], baseEnv, semantics.dynamic );
-    if (!query)                 // outside queries - TODO: items?
-      return resolvePath( path, parent.elements[head], parent, 'parent' );
+    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' );
+    }
 
     if (semantics.dynamic === 'query')
       // TODO: for ON condition in expand, would need to use cached _element
@@ -703,6 +724,11 @@ function csnRefs( csn, universalReady ) {
       hidden = {};
       cache.set( obj, hidden );
     }
+    // TODO: we might keep the following with --test-mode
+    // if (hidden[prop] !== undefined) {
+    //   console.log('RS:',prop,hidden[prop],val,obj)
+    //   throw Error('RESET')
+    // }
     hidden[prop] = val;
     return val;
   }
@@ -818,7 +844,7 @@ function traverseDef( node, parent, kind, name, callback ) {
   }
   if (node.returns)
     traverseType( node.returns, node, 'returns', true, callback );
-  traverseType( node, parent, kind, name, callback );
+  traverseType( node, true, kind, name, callback );
   if (node.actions) {
     for (const n of Object.keys( node.actions ))
       traverseDef( node.actions[n], node, 'action', n, callback )
@@ -826,7 +852,8 @@ function traverseDef( node, parent, kind, name, callback ) {
 }
 
 function traverseType( node, parent, kind, name, callback ) {
-  callback ( node, parent, kind, name );
+  if (parent !== true)
+    callback ( node, parent, kind, name );
   const target = targetAspect( node );
   if (target && typeof target === 'object' && target.elements) {
     callback ( target, node, 'target', true );