@sap/cds-compiler 4.2.2 → 4.3.0

package/lib/json/to-csn.js

@@ -1036,7 +1036,7 @@ function originRef( art, user ) {
   while (isMember( parent ) && parent.kind !== 'select') {
     const nkind = normalizedKind[parent.kind];
     const name = parent.name || parent._outer.name;
-    if (name.id || !r.length)
+    if (name.id && parent.kind !== '$inline' || !r.length)
       // Return parameter is in XSN - kind: 'param', name.id: ''
       // eslint-disable-next-line no-nested-ternary, max-len
       r.push( !nkind ? name.id : name.id ? { [nkind]: name.id } : { returns: true } );
@@ -1047,17 +1047,17 @@ function originRef( art, user ) {
     return false;               // do not write, probably use $origin: {...}
   // for sub query in FROM in sub query in FROM, we could condense the info
 
-  r.push( parent.name.absolute );
+  r.push( (parent._main || parent).name.id );
   r.reverse();
   return r;
 }
 
 function kind( k, csn, node ) {
   if (k === 'annotate' || k === 'extend') {
-    // We just use `name.absolute` because it is very likely a "constructed"
+    // We just use `name.id` because it is very likely a "constructed"
     // extensions.  The CSN parser must produce name.path like for other refs.
     if (!node._main)
-      csn[k] = node.name.absolute || artifactRef( node.name, true );
+      csn[k] = node.name.id || artifactRef( node.name, true );
     else if (k === 'extend')
       csn.kind = k;
   }
@@ -1102,7 +1102,7 @@ function artifactRef( node, terse ) {
   // Works also on XSN directly coming from parser and with XSN from CDL->CSN transformation
   // Shortcut for many cases:
   if (terse && node._artifact && !node._artifact._main && terse !== '.path')
-    return node._artifact.name.absolute;
+    return node._artifact.name.id;
   let { path } = node;
   if (!path)
     return undefined;           // TODO: complain with strict
@@ -1111,25 +1111,35 @@ function artifactRef( node, terse ) {
 
   const head = path[0];
   const root = head._artifact;
-  const id = root?.name.absolute;
+  const main = root?._main || root;
+  const id = (main?.extern || main?.name)?.id;
   const scope = node.scope || path.length;
 
   if (typeof scope === 'number' && scope > 1) {
     const item = path[scope - 1];
     const name = item._artifact?.name;
-    const absolute = name?.absolute ||
+    const absolute = name?.id ||
       `${ id || head.id }.${ path.slice( 1, scope ).map( i => i.id ).join('.') }`;
     path = [ Object.assign( {}, item, { id: absolute } ), ...path.slice( scope ) ];
   }
   else if (scope === 'typeOf') {     // TYPE OF without ':' in path
-    if (root) {
-      const structs = root.name.element?.split('.').map( n => ({ id: n }) );
-      // TODO: change (follow parents) if we introduce sparse names
-      path = [ { id }, ...(structs || []), ...path.slice(1) ];
-    }
-    else if (strictMode) {
+    if (!root) {
       throw new CompilerAssertion( `Unexpected TYPE OF in ${ locationString(node.location) }`);
     }
+    else if (!root._main) {
+      path = [ { id }, ...path.slice(1) ];
+    }
+    else {
+      path = path.slice(1).reverse();
+      let parent = root;
+      while (parent._main) {
+        path.push( { id: parent.name.id } );
+        parent = parent._parent;
+        parent = parent._outer || parent; // for anonymous aspect
+      }
+      path.push( { id } );
+      path.reverse();
+    }
   }
   else if (root && id !== head.id) {
     path = [ Object.assign( {}, head, { id } ), ...path.slice( 1 ) ];

package/lib/language/antlrParser.js

@@ -50,7 +50,7 @@ class RewriteTypeTokenStream extends antlr4.CommonTokenStream {
     }
     else if (t.type === this.NEW) {
       const n = super.LT(k + 1);
-      // TODO v4: rewrite token in grammar via `this.setLocalToken`
+      // TODO v5: rewrite token in grammar via `this.setLocalToken`
       if (n?.type === this.Identifier) {
         const o = super.LT(k + 2);
         if (o?.type === this.PAREN)

package/lib/language/errorStrategy.js

@@ -180,7 +180,7 @@ function sync( recognizer ) {
 
     case ATNState.PLUS_LOOP_BACK: // 11
     case ATNState.STAR_LOOP_BACK: { // 9
-      // TODO: do not delete a '}'
+      // TODO: do not delete a '}', ')', ',', ';'
       this.reportUnwantedToken(recognizer);
       const expecting = new IntervalSet();
       expecting.addSet(recognizer.getExpectedTokens());
@@ -345,6 +345,10 @@ function recoverInline( recognizer ) {
     return this._super.recoverInline.call( this, recognizer );
 
   const token = recognizer.getCurrentToken();
+  // TODO: do not delete `)`, `}`,
+
+  // TODO: overwrite singleTokenDeletion do not delete parens etc for identifier
+  // or non-reserved keywords
   if (!keywordRegexp.test( token.text ))
     return this._super.recoverInline.call( this, recognizer );
 

package/lib/language/genericAntlrParser.js

@@ -22,7 +22,7 @@ const {
   XsnArtifact, XsnName, CsnLocation, XsnSource,
 } = require('../compiler/classes');
 const { isBetaEnabled } = require('../base/model');
-const { weakLocation } = require('../base/messages');
+const { weakLocation } = require('../base/location');
 const { normalizeNewLine } = require('./textUtils');
 
 const $location = Symbol.for('cds.$location');
@@ -370,14 +370,15 @@ function assignAnnotation( art, anno, prefix = '' ) {
     absolute = `${ prefix }${ pathname }`;
   }
   else {
-    absolute = prefix.slice( 0, -1 );
+    absolute = prefix.slice( 0, -1 ); // remove final dot
   }
+
   if ($flatten) {
     for (const a of $flatten)
       this.assignAnnotation( art, a, `${ absolute }.` );
   }
   else {
-    name.absolute = absolute;
+    name.id = absolute;
     this.addAnnotation( art, `@${ absolute }`, anno );
   }
   if (!prefix) {                // set deprecated $annotations for cds-lsp
@@ -706,6 +707,18 @@ function fragileAlias( ast, safe = false ) {
 
 // Return AST for identifier token `token`.  Also check that identifier is not empty.
 function identAst( token, category, noTokenTypeCheck = false ) {
+  if (!token) {                 // for rule identAst
+    const { start, stop } = this._ctx;   // token.tokenIndex
+    // - correct parsing: start = stop
+    // - singleTokenDeletion(), e.g. with `| Ident`: start < stop → stop
+    // - after recoverInline: start > stop (!) → stop = the previous token, if it is
+    //   ident-like and the one before not in `.@#`, → start ('') otherwise
+    token = stop;
+    if (start.tokenIndex > stop.tokenIndex &&
+        (stop.type !== this.constructor.Identifier && !/^[a-zA-Z_]+$/.test( stop.text ) ||
+         [ '.', '@', '#' ].includes( this._input.LT(-2)?.text )))
+      token = start;
+  }
   token.isIdentifier = category;
   let id = token.text;
   if (!noTokenTypeCheck &&
@@ -776,12 +789,7 @@ function valuePathAst( ref ) {
   const { path } = ref;
   if (!path || path.broken)
     return ref;
-  if (path.length !== 1) {
-    const item = path.find( i => i.args && i.$syntax !== ':' );
-    if (!item) // also covers empty paths
-      return ref;
-  }
-  else if (path.length === 1) {
+  if (path.length === 1) {
     const { args, id, location } = path[0];
     if (args
       ? path[0].$syntax === ':'
@@ -799,40 +807,46 @@ function valuePathAst( ref ) {
       : { op, func: ref, location: ref.location };
   }
 
-  // method call ---------------------------
 
-  const args = [];
-  const pathRest = [ ...path ];
-  let pathHead = pathRest.shift();
+  // $syntax === ':' => path(P: 1)
+  // $syntax !== ':' => path(P => 1) or path(1) or path()
+  const firstFunc = path.findIndex( i => i.args && i.$syntax !== ':' );
+  if (firstFunc === -1) // also covers empty paths
+    return ref;
 
-  if (pathHead.args) {
-    args.push({
-      op: { location: pathHead.location, val: 'call' },
-      func: { path: [ pathHead ] },
-      location: pathHead.location,
-      args: pathHead.args || [],
-    });
-    pathHead = pathRest.shift();
-  }
-  else {
-    const refPath = [];
-    while (pathHead && !pathHead.args) {
-      refPath.push(pathHead);
-      pathHead = pathRest.shift();
+
+  // Method Call ---------------------------
+  // Transform the path into `.`-operators.
+  // Everything after the first function is also a function, and not a reference.
+
+  for (let i = firstFunc; i < path.length; ++i) {
+    if (path[i].args && path[i].$syntax === ':') {
+      // Error for `a(P => 1).b.c(P: 1)`: no ref after function.
+      this.$messageFunctions.error('syntax-invalid-ref', path[i].args[$location], {
+        code: '=>',
+      }, 'References after function calls can\'t be resolved. Use $(CODE) in function arguments');
+      break;
     }
-    args.push({ path: refPath, location: refPath[0].location });
   }
 
-  if (pathHead?.args)
-    pathRest.unshift(pathHead);
-
-  for (const method of pathRest) {
+  const args = [];
+  if (firstFunc > 0) {
     args.push({
-      // TODO: Update parser to have proper location for `.`?
-      location: weakLocation(method.location),
-      val: '.',
-      literal: 'token',
+      path: path.slice(0, firstFunc),
+      location: locUtils.combinedLocation(path[0].location, path[path.length - 1].location),
     });
+  }
+
+  const pathRest = path.slice(firstFunc);
+  for (const method of pathRest) {
+    if (method !== pathRest[0] || firstFunc > 0) {
+      args.push({
+        // TODO: Update parser to have proper location for `.`?
+        location: weakLocation(method.location),
+        val: '.',
+        literal: 'token',
+      });
+    }
     const func = {
       op: { location: method.location, val: 'call' },
       func: { path: [ method ] },
@@ -1026,46 +1040,38 @@ function reportUnexpectedSpace( prefix = this._input.LT(-1),
 //
 // If argument `kind` is provided, set `art.kind` to that value.
 // If argument `name` is provided, set `art.name`:
-//  - if `name` is an array, the name consist of the ID of the last path item
+//  - if `name` is an array, `name.id` consist of the ID of the last array item
 //    (for elements via columns, foreign keys, table aliases)
-//  - if `name` is an object, the name consist of the IDs of all path items
-//    (for main artifact definitions)
+//  - if `name` is an object, `name.id` is either set, or the (local) name is calculated
+//    from the IDs of all items in `name.path` (for main artifact definitions).
 function addDef( art, parent, env, kind, name ) {
   if (Array.isArray(name)) {
-    // XSN TODO: clearly say: definitions have name.path, members have name.id
     const last = name.length && name[name.length - 1];
-    if (last && last.id) {       // // A.B.C -> 'C'
-      art.name = {
-        id: last.id, location: last.location, $inferred: 'as',
-      };
-    }
+    art.name = { // A.B.C -> 'C'
+      id: last?.id || '', location: last.location, $inferred: 'as',
+    };
   }
   else if (name) {
     art.name = name;
-    if (name.id == null)
-      name.id = pathName( name.path ); // A.B.C -> 'A.B.C'
-    // TODO: get rid of setting `id`, only use for named values in structs
+    if (!name.id && kind === null) // namedValue, fortunately no `variant` there
+      art.name.id = pathName( art.name?.path );
+  }
+  else {
+    art.name = { id: '' };
   }
-
   if (kind)
     art.kind = kind;
-  if (!art.name || art.name.id == null) {
-    // no id was parsed, but with error recovery: no further error
-    // TODO: add to  parent[env]['']
-    // which could be tested in name search (then no undefined-ref error)
-    // console.log( kind+': !!', art, parent, env, name )
-    return art;
-  }
-  // console.log( kind+':', art, parent, env, name )
+
+  const id = art.name?.id || pathName( art.name?.path ); // returns '' for corrupted name
 
   if (env === 'artifacts' || env === 'vocabularies') {
-    dictAddArray( parent[env], art.name.id, art );
+    dictAddArray( parent[env], id, art );
   }
-  else if (kind || this.options.parseOnly) {
-    dictAdd( parent[env], art.name.id, art );
+  else if (kind || this.options.parseOnly) { // TODO: do not check parseOnly
+    dictAdd( parent[env], id, art );
   }
   else {
-    dictAdd( parent[env], art.name.id, art, ( duplicateName, loc ) => {
+    dictAdd( parent[env], id, art, ( duplicateName, loc ) => {
       // do not use function(), otherwise `this` is wrong:
       if (kind === 0) {
         this.error( 'syntax-duplicate-argument', loc, { name: duplicateName },

package/lib/main.d.ts

@@ -248,6 +248,18 @@ declare namespace compiler {
     serviceNames?: string[]
   }
 
+  /**
+   * Options used by the `for.effective()` CSN transformation.
+   *
+   * WORK IN PROGRESS
+   *
+   * @internal
+   * @see _for.effective()
+   */
+  export interface EffectiveCsnOptions extends SqlOptions {
+    // TODO
+  }
+
   /**
    * Options used by SQL `to.sql()` backend.
    *
@@ -818,11 +830,24 @@ declare namespace compiler {
    */
   export namespace _for {
     /**
-     * Transform the given (generic) CSN into one that is used for OData.
+     * Transform the given (inferred/client) CSN into one that is used for OData.
      * Changes include flattening, type resolution and more, according to
      * the provided options.
      */
     function odata(csn: CSN, options?: ODataOptions): CSN;
+    /**
+     * Transform the given CSN into one that has these properties:
+     *  - types are resolved
+     *  - elements are flattened
+     *  - …
+     *
+     * THIS IS HIGHLY EXPERIMENTAL
+     *
+     * Beta flag `effectiveCsn` is required.
+     *
+     * @internal
+     */
+    function effective(csn: CSN, options?: EffectiveCsnOptions): CSN;
   }
 
   export { _for as for };

package/lib/main.js

@@ -115,7 +115,8 @@ module.exports = {
   },
   // SNAPI
   for: {
-    odata: (...args) => snapi.odata(...args)
+    odata: (...args) => snapi.odata(...args),
+    effective: (...args) => snapi.for_effective(...args),
   },
   to: {
     cdl: Object.assign((...args) => snapi.cdl(...args), {

package/lib/model/csnRefs.js

@@ -433,6 +433,7 @@ function csnRefs( csn, universalReady ) {
       return getOriginExplicit( $origin.$origin );
     const [ head, ...tail ] = $origin;
     const main = csn.definitions[head];
+    // if (!main) throw Error(JSON.stringify({$origin,csn}))
     initDefinition( main );
     return tail.reduce( originNavigation, main );
   }

package/lib/model/csnUtils.js

@@ -1411,6 +1411,32 @@ function functionList( functions, thisArg ) {
   };
 }
 
+/**
+ * Return true if 'arg' is an expression argument denoting "$self" || "$projection"
+ * @param {object} arg
+ * @returns {boolean}
+ */
+function isDollarSelfOrProjectionOperand( arg ) {
+  return arg.ref && arg.ref.length === 1 && (arg.ref[0] === '$self' || arg.ref[0] === '$projection');
+}
+
+/**
+ * Return true if 'arg' is an expression argument of type association or composition
+ * @param {object} arg
+ * @param {CSN.Path} path
+ * @param {function} inspectRef
+ * @returns {boolean}
+ */
+function isAssociationOperand( arg, path, inspectRef ) {
+  if (!arg.ref) {
+    // Not a path, hence not an association (literal, expression, function, whatever ...)
+    return false;
+  }
+  const { art } = inspectRef(path);
+  // If it has a target, it is an association or composition
+  return art && art.target !== undefined;
+}
+
 module.exports = {
   getUtils,
   cloneCsn: cloneCsnNonDict, // Umbrella relies on this name
@@ -1456,4 +1482,6 @@ module.exports = {
   isDeepEqual,
   functionList,
   cardinality2str,
+  isAssociationOperand,
+  isDollarSelfOrProjectionOperand,
 };

package/lib/model/revealInternalProperties.js

@@ -159,14 +159,8 @@ function revealInternalProperties( model, nameOrPath ) {
 
   function shortenName( node, parent ) {
     const name = reveal( node, parent );
-    if (name && typeof name === 'object' && name.absolute && node.kind) {
+    if (name && typeof name === 'object' && parent.kind) {
       const text = artifactIdentifier( parent );
-      delete name.absolute;
-      delete name.select;
-      delete name.action;
-      delete name.parameter;
-      delete name.alias;
-      delete name.element;
       name['-->'] = text;
     }
     return name;
@@ -193,7 +187,7 @@ function revealInternalProperties( model, nameOrPath ) {
     const { name, $flatten } = anno.value || anno;
     const value = ($flatten)
       ? { name: reveal( name ), $flatten: $flatten.map( $annotation ) }
-      : `@${ name?.absolute }`;
+      : `@${ name?.id }`;
     return { value, location: locationString( anno.location || anno.name.location ) };
   }
 
@@ -349,7 +343,7 @@ function artifactIdentifier( node, parent ) {
         ? artifactIdentifier( node._artifact )
         : JSON.stringify(node.name);
     case 'builtin':
-      return `$magicVariables/${ msg.artName(node) }`;
+      return msg.artName(node);
     case 'source':
     case 'using':
       return `source:${ quoted( node.location && node.location.file )

package/lib/optionProcessor.js

@@ -105,8 +105,9 @@ optionProcessor
        --beta <list>        Comma separated list of unsupported, incomplete (beta) features to use.
                             Valid values are:
                               ${
-  Object.keys(availableBetaFlags).sort()
+  Object.keys(availableBetaFlags)
     .filter(flag => availableBetaFlags[flag])
+    .sort()
     .join('\n' + ' '.repeat(30))
 }
        --deprecated <list>  Comma separated list of deprecated options.
@@ -151,6 +152,7 @@ optionProcessor
        manageConstraints [options] <files...>   (internal) Generate ALTER TABLE statements to
                                                            add / modify referential constraints.
        inspect [options] <files...>             (internal) Inspect the given CDS files.
+       toEffectiveCsn [options] <files...>      (internal) Get an effective CSN for SEAL; requires beta mode
 
   Environment variables
     NO_COLOR                If set, compiler messages (/output) will not be colored.
@@ -523,6 +525,20 @@ optionProcessor.command('inspect')
        --propagation <art>   Show propagation sources for <art>
 `);
 
+optionProcessor.command('toEffectiveCsn')
+  .option('-h, --help')
+  .positionalArgument('<files...>')
+  .help(`
+  Usage: cdsc toEffectiveCsn [options] <files...>
+
+  (internal): Get the effective CSN model compiled from the provided CDS files.
+  This command may change any time, including its name.
+  Beta mode is required.
+
+  Options
+   -h, --help                Show this help text
+`);
+
 module.exports = {
   optionProcessor
 };

package/lib/render/toCdl.js

@@ -593,7 +593,7 @@ function csnToCdl( csn, options ) {
     result += env.indent;
     result += element.virtual ? 'virtual ' : '';
     result += element.key ? 'key ' : '';
-    // TODO(v4): Remove once deprecated flag for `masked` is removed.
+    // TODO(v5): Remove once deprecated flag for `masked` is removed.
     result += element.masked ? 'masked ' : '';
     result += quoteNonIdentifierOrKeyword(elementName, env);
     if (element.val !== undefined) { // enum value

package/lib/transform/db/associations.js

@@ -3,6 +3,7 @@
 const {
   applyTransformationsOnNonDictionary,
   applyTransformations,
+  implicitAs,
 } = require('../../model/csnUtils');
 
 /**
@@ -15,9 +16,7 @@ const {
  * @returns {CSN.Model} Return the input csn, with the transformations applied
  */
 function attachOnConditions( csn, csnUtils, pathDelimiter ) {
-  const {
-    isManagedAssociation,
-  } = csnUtils;
+  const { isManagedAssociation } = csnUtils;
 
   const alreadyHandled = new WeakMap();
   applyTransformations(csn, {
@@ -59,7 +58,7 @@ function attachOnConditions( csn, csnUtils, pathDelimiter ) {
             elemName,
           ].concat(foreignKey.ref),
         };
-        const fkName = `${elemName}${pathDelimiter}${foreignKey.as}`;
+        const fkName = `${elemName}${pathDelimiter}${foreignKey.as || implicitAs(foreignKey.ref)}`;
         const fKeyArg = {
           ref: [
             fkName,