@sap/cds-compiler 5.7.2 → 5.8.0

package/lib/parsers/CdlGrammar.g4

@@ -45,6 +45,7 @@ tokens{                         // reserved words
 
 start returns[ source = new XsnSource( 'cdl' ) ]
   :
+    { this.afterBrace( null, 'init' ); }<always> // init sloppy semicolon handling
     (
       ( <guard=namespaceRestriction> namespaceDeclaration[ $source ]
       | usingDeclaration[ $source ]
@@ -57,7 +58,7 @@ start returns[ source = new XsnSource( 'cdl' ) ]
 
 artifactsBlock[ art, start = undefined ]
   :
-    '{'
+    '{' <prepare=afterBrace, arg=init>
     { $art.artifacts = this.createDict( $start ); $art.extensions = []; }
     (
       artifactDefOrExtend[ $art ]
@@ -235,7 +236,7 @@ aspectDef[ art, outer ]
 entityDef[ art, outer ]
 @finally{ this.attachLocation( $art ); }
   :
-    ENTITY<prepare=afterBrace>  // enable special
+    ENTITY
     name=namePath[ 'Entity' ]
     { this.addDef( $art, $outer, 'artifacts', 'entity', $name ); }
     { this.docComment( $art ); } annoAssignMid[ $art ]*
@@ -254,17 +255,12 @@ entityDef[ art, outer ]
         query=queryExpression
         { $art.query = $query; $art.$syntax = 'entity'; }
       |
+        <prepare=afterBrace, arg=sloppy> // enable special loop-exit, allow no `;`
         query=projectionSpec
         { $art.query = $query; $art.$syntax = 'projection'; }
         whereGroupByHaving[ $query ]?
         orderByLimitOffset[ $query ]?
-        { if (this.lb().type !== '}' && ![ ';', '}', 'EOF' ].includes( this.l() ) && this.la().keyword !== 'actions') {
-          // not worth to nicer location here - is standard error in v6
-          this.warning( 'syntax-missing-proj-semicolon', this.la(),
-                        { expecting: [ "';'" ], offending: this.antlrName( this.la() ) },
-                        'Missing $(EXPECTING) before $(OFFENDING)');
-        } }
-        <prepare=afterBrace> // disable special loop-exit, allow no `;`
+        {;}<prepare=afterBrace, arg=normal> // disable special loop-exit, allow no `;`
         // TODO v6: these <prepare=afterBrace>s are extremely strange
       )
     )
@@ -811,6 +807,9 @@ typeOrIncludesSpec[ art ]
   |
     ':'
     (
+      // Since cds-compiler v5.8; new parser only
+      query=projectionSpec { $art.query = $query; $art.$syntax = 'projection'; }
+    |
       typeExpression[ $art ]
     |
       <prefer>
@@ -1073,7 +1072,6 @@ projectionSpec returns[ default query = {} ]
 @finally{ this.attachLocation($query); }
   :
     PROJECTION
-    <prepare=afterBrace, arg=entity> // enable special loop-exit, TODO v6 delete
     { $query = { op: this.valueWithLocation( 'SELECT' ) }; }
     ON
     tab=fromRefWithOptAlias
@@ -1100,7 +1098,7 @@ queryExpression returns[ default expr = {} ] locals[ op, quantifier ]
       )
       query=queryExpression
       // with same op/quantifier: make left-assoc binary to nary:
-      { if ($expr.$parens || $op.val !== $expr.op.val || $quantifier?.val !== $expr.quantifier?.val) $expr = { op, args: [$expr], quantifier, location: { ...$.expr.location } }; } // TODO: ...$
+      { if ($expr.$parens || $op.val !== $expr.op?.val || $quantifier?.val !== $expr.quantifier?.val) $expr = { op, args: [$expr], quantifier, location: { ...$.expr.location } }; } // TODO: ...$
       { $quantifier = undefined; }
       { $expr.args.push( $query ); this.attachLocation( $expr ); }
     )*
@@ -1169,9 +1167,9 @@ tableExpression returns[ default expr = {} ] // TableOrJoin
     (
       join=CROSS JOIN
       { if ($expr?.join?.val !== 'cross' || $expr.$parens) $expr = { op: this.valueWithLocation(), join: this.valueWithLocation( undefined, $join ), args: [ $expr ] }; }
-      ( tab=tableOrQueryParens { $expr.args.push( this.taggedIfQuery( $tab ) ); }
+      ( tab=tableOrQueryParens { const r = this.taggedIfQuery( $tab ); if (r) $expr.args.push( r ); }
         { this.attachLocation( $expr ); }
-      | tab=fromRefWithOptAlias { $expr.args.push( $tab ); }
+      | tab=fromRefWithOptAlias { if ($tab) $expr.args.push( $tab ); }
         { this.attachLocation( $expr ); }
       )
     |
@@ -1393,11 +1391,11 @@ selectItemDef[ columns ] locals[ art = new XsnArtifact() ]
             OVER { this.pushXprToken( $expr.suffix = [] ); }
             overClause[ $expr.suffix ]
             ( e=expression[ ...{ expr: $expr } ]<atAltStart>
-              { Object.assign( $e.location, $expr.location ); $art.value = this.attachLocation( $e )}
+              { Object.assign( $e.location || {}, $expr.location ); $art.value = this.attachLocation( $e )}
             )?
           |
             e=expression[ ...{ expr: $expr } ]<atAltStart>
-            { Object.assign( $e.location, $expr.location ); $art.value = this.attachLocation( $e )}
+            { Object.assign( $e.location || {}, $expr.location ); $art.value = this.attachLocation( $e )}
           )
           ( AS Id['ItemAlias'] { $art.name = this.identAst(); }
           | Id_restricted['ItemAlias'] { $art.name = this.fragileAlias( true ); }
@@ -1533,9 +1531,8 @@ valuePath returns[ default expr = { path: [] } ] locals[ pathItem ]
     )*
   ;
 
-// TODO: ? params
 expression returns[ default expr = {} ]
-//@finally{ if (!$expr?.$parens) this.attachLocation( $expr ); }
+@finally{ if (this.s == null) this.attachLocation( $expr ); }
   :
     (
       expressionOrQueryParens[ ...$ ]
@@ -1716,7 +1713,9 @@ options{ minTokensMatched = 1 }
           (
             ','<prepare=nextFunctionArgument>
             ( expr=funcExpression { $pathStep.args.push( $expr ); }
-            | <exitLoop>          // <cond>: only before `)`
+            | DeleteStarFromSet // Workaround for missing feature, see #13485, TODO
+            | <exitLoop, guard=atRightParen>
+              // TODO: later allow ')' <exitRule>, or ')'<mock, exitLoop>, or <exitBlock=MainAlt> with ( options{ block=MainAlt }: …)
             )
           )*
           (   // ORDER BY in generic functions, e.g. `first_value(id order by name)`
@@ -1725,6 +1724,8 @@ options{ minTokensMatched = 1 }
             orderByClauseAsXpr[ $expr.args ]
             { this.attachLocation( $expr ); }
           )?
+        |
+          DeleteStarFromSet     // Workaround for missing feature, see #13485, TODO
         )?
       |
         // TODO: if we want perfect CC and error recovery, `isNamedArg` would work
@@ -1772,6 +1773,7 @@ funcExpression returns[ default expr ] locals[ args ]
       { $expr = this.applyOpToken(); $args = $expr.args; }
       e=expression { $expr.args.push( $e ); }
     )
+    // TODO: some <restrict=Id> here?
     ( options{ lookahead = lGenericSeparator; }
     :
       GenericSeparator
@@ -2011,7 +2013,6 @@ annoValue returns[ default value = {} ]
       else { $value.struct = Object.create(null); $value.literal = 'struct'; }
     }
     (
-      // TODO: complain about empty loop if top-level as before
       // TOOL TODO → allow `<guard=…> '}'` below where the condition rejects `}`
       // after `{` if top-level
       sub=annoStructValue

package/lib/parsers/XprTree.js

@@ -0,0 +1,206 @@
+// Create a hierarchical expression tree from an `xpr` array
+
+// See ./CdlGrammar.js for the operator precedences.
+
+
+'use strict';
+
+
+const prefixOperators = {     // see <prec=…,prefix> in `expression` of CdlGrammar
+  __proto__: null,
+  new: 33,                  // special in CDL (only before ref), clarify with `.`
+  exists: 33,               // special in CDL
+  '+': 30,                  // note: binary `.` and `over` have higher precedence!
+  '-': 30,
+  not: 8,
+};
+
+const binaryOperators = {
+  __proto__: null,
+  '.': 37,                      // nary
+  over: 35,                     // TODO: only after ref with arg?
+  '*': 24,                      // nary
+  '/': 24,
+  '+': 22,
+  '-': 22,
+  '||': 20,
+  '=': 10,                      // with ANY/SOME/ALL
+  '<>': 10,
+  '>': 10,
+  '>=': 10,
+  '<': 10,
+  '<=': 10,
+  '!=': 10,
+  '==': 10,                     // not supported yet in CDL or backends
+  and: 4,
+  or: 2,
+  // with second token or ternary (in the grammar, these ops have prec=10, but
+  // also assoc=none, i.e. could not be used without parens together):
+  is: 11,                       // is binary op here, not postfix
+  in: 13,
+  between: 13,
+  like: 13,
+  not: 15,                      // specially handled
+};
+
+const secondTokens = {
+  // the value is the precedence of the first token listed in `binaryOperators`
+  __proto__: null,
+  any: 10,                      // for `=` etc
+  some: 10,
+  all: 10,
+  not: 11,                      // for `is`
+  between: 15,                  // for `not`
+  in: 15,
+  like: 15,
+};
+
+const naryOperators = {
+  __proto__: null,
+  '.': true,                    // CSN-tree really as left-assoc binary?
+  '*': true,
+  '/': true,
+  '+': true,
+  '-': true,
+  '||': true,
+  and: true,
+  or: true,
+  between: 'and',
+  like: 'escape',
+};
+
+
+class XprTree {
+  nodes;                        // array value of CSN property `xpr`/`where`/…
+  nodeIdx = 0;
+  args;        // corresponding XSN array, with already tree-like sub expressions
+  location;
+
+  constructor( nodes, args, location ) {
+    this.nodes = nodes;
+    this.args = args;
+    this.location = location;
+  }
+
+  tree() {
+    const args = [];
+    const { length } = this.args;
+    while (this.nodeIdx < length) {
+      const expr = this.expression( -1 );
+      if (expr)
+        args.push( expr );
+    }
+    return (args.length === 1) ? args[0] : this.create( args );
+  }
+
+  expression( parentPrec ) {
+    let append;
+    let naryOp;
+    let args;
+
+    // Term = ref/val or unary operator with expression as operand
+    let expr = this.args[this.nodeIdx];
+    if (!expr)
+      return expr;
+    let node = this.nodes[this.nodeIdx++];
+    if (typeof node === 'string') {
+      const prec = prefixOperators[node]; // <prec=…,prefix> in CdlGrammar
+      if (prec) {
+        const right = this.expression( prec - 1 );
+        if (!right)
+          return expr;
+        expr = this.create( [ expr, right ] );
+      }
+      else if (node === 'case') {
+        expr = this.caseWhen( [ expr ] );
+      }
+      else {             // unknown token (keyword in CDL):
+        return expr;            // …from fns with irregular syntax?
+        // also handles `null` as right side of `is` in `is null`
+        // TODO: `(` from CSN v0.x ?
+        // It is important not to handle binary ops after this, because otherwise
+        // we would not properly parse functions with irregular syntax
+      }
+    }
+
+    node = this.nodes[this.nodeIdx];
+    while (typeof node === 'string') {
+      const prec = binaryOperators[node]; // <prec=…> in CdlGrammar
+      if (!prec || parentPrec >= prec)
+        return expr;
+
+      // handle n-ary operators including ternary
+      append = (typeof naryOp === 'string')
+        ? !append && naryOp     // `and` after `between`, `escape` after `like`˛
+        : naryOp && node;       // nary operators like `+`
+      if (node === append) {
+        args.push( this.args[this.nodeIdx++] );
+      }
+      else {
+        naryOp = naryOperators[node];
+        append = false;
+        args = [ expr, this.args[this.nodeIdx++] ];
+        expr = this.create( args, naryOp === true );
+      }
+
+      // handle second token of operator:
+      const second = this.nodes[this.nodeIdx];
+      if (typeof second === 'string' && secondTokens[second] === prec && !append) {
+        args.push( this.args[this.nodeIdx++] );
+        if (node === 'not')
+          naryOp = naryOperators[second];
+      }
+
+      // the right side
+      const right = this.expression( prec );
+      if (!right)                   // incomplete
+        return expr;
+      args.push( right );
+      node = this.nodes[this.nodeIdx];
+      // TODO: simplyfy between-and and like-escape with pushTokenAndExpression()
+    }
+    return expr;
+  }
+
+  caseWhen( args ) {
+    const expr = this.create( args );
+    let node = this.nodes[this.nodeIdx];
+    if (node !== 'when') {
+      const value = this.expression( -1 );
+      if (value)
+        args.push( value );
+      node = this.nodes[this.nodeIdx];
+    }
+    while (node === 'when') {
+      node = this.pushTokenAndExpression( args );
+      if (node === 'then')
+        node = this.pushTokenAndExpression( args );
+    }
+    if (node === 'else')
+      node = this.pushTokenAndExpression( args );
+    if (node === 'end')
+      args.push( this.args[this.nodeIdx++] );
+    return expr;
+  }
+
+  pushTokenAndExpression( args ) {
+    args.push( this.args[this.nodeIdx++] );
+    const value = this.expression( -1 );
+    if (value)
+      args.push( value );
+    return this.nodes[this.nodeIdx];
+  }
+
+  create( args, isNary = false ) {
+    // could be adopted for CSN expression tree
+    return {
+      op: { val: (isNary ? 'nary' : 'ixpr'), location: this.location },
+      location: this.location,
+      args,
+    };
+  }
+}
+
+module.exports = {
+  xprAsTree: ( nodes, args, location ) => (new XprTree( nodes, args, location )).tree(),
+};

package/lib/parsers/index.js

@@ -21,7 +21,7 @@ function parseCdl( source, filename = '<undefined>.cds',
                    options = {}, messageFunctions = null,
                    rule = 'cdl' ) {
   const rulespec = rules[rule];
-  if (!options.newParser)       // TODO: (options.newParser === false)
+  if (!options.newParser && !options.newparser)
     return parseWithAntlr( source, filename, options, messageFunctions, rulespec );
   const { CdlParser } = gen;
   if (CdlParser.tracingParser)  // tracing → direct console output of message

package/lib/render/toCdl.js

@@ -124,7 +124,7 @@ function csnToCdl( csn, options, msg ) {
         // This environment is passed down the call hierarchy, for dealing with
         // indentation and name resolution issues
         const env = createEnv({ path: [ 'vocabularies', name ] });
-        const sourceStr = renderTypeOrAnnotation(name, anno, env, 'annotation');
+        const sourceStr = renderArtifact(name, anno, env, 'annotation');
         result += `${sourceStr}\n`;
       }
     }
@@ -452,7 +452,7 @@ function csnToCdl( csn, options, msg ) {
       case 'entity':
         if (art.query || art.projection)
           return renderView(artifactName, art, env);
-        return renderEntity(artifactName, art, env);
+        return renderArtifact(artifactName, art, env);
       case 'aspect':
         return renderAspect(artifactName, art, env);
 
@@ -460,16 +460,16 @@ function csnToCdl( csn, options, msg ) {
       case 'service':
         return renderContextOrService(artifactName, art, env);
 
-      case 'type':
       case 'annotation': // annotation in 'csn.definitions' for compiler v1 compatibility
-        return renderTypeOrAnnotation(artifactName, art, env);
+        return renderArtifact(artifactName, art, env, 'annotation');
 
       case 'action':
       case 'function':
         return renderActionOrFunction(artifactName, art, env);
 
+      case 'type':
       case 'event':
-        return renderEvent(artifactName, art, env);
+        return renderArtifact(artifactName, art, env);
 
       default:
         throw new ModelError(`to.cdl: Unknown artifact kind: '${art.kind}' at ${JSON.stringify(env.path)}`);
@@ -477,30 +477,70 @@ function csnToCdl( csn, options, msg ) {
   }
 
   /**
+   * TODO: Also use this function for other kinds such as entities, aspects and views.
+   *
    * @param {string} artifactName
    * @param {CSN.Artifact} art
    * @param {CdlRenderEnvironment} env
+   * @param {string} [overrideKind] If set, override the artifact kind.
    */
-  function renderEvent( artifactName, art, env ) {
+  function renderArtifact( artifactName, art, env, overrideKind ) {
     let result = renderAnnotationAssignmentsAndDocComment(art, env);
+    let kind = overrideKind || art.$syntax === 'aspect' && 'aspect' || art.kind;
+    if (art.abstract)
+      kind = `abstract ${ kind }`;
     const normalizedArtifactName = renderArtifactName(artifactName, env);
-    result += `${env.indent}event ${normalizedArtifactName}`;
-    if (art.includes)
-      result += renderIncludes(art.includes, env);
-    if (art.query || art.projection) {
+    result += `${env.indent}${kind} ${normalizedArtifactName}`;
+
+    if (art.params)
+      result += renderParameters(art, env);
+
+    let isDirectStruct = false;
+    const isQuery = art.query || art.projection;
+    if (isQuery) {
       result += ' : ';
-      // events (should) only support "projections"
+      // types/events (should) only support "projections"
       result += renderQuery(getNormalizedQuery(art).query, true, 'projection',
                             env.withSubPath([ art.projection ? 'projection' : 'query' ]));
-      result += ';\n';
     }
-    else if (art.type) {
-      // Derived type or annotation with non-anonymous type
-      result += ` : ${renderTypeReferenceAndProps(art, env)};\n`;
+    else {
+      const type = renderTypeReferenceAndProps(art, env);
+      if (type) {
+        isDirectStruct = type.startsWith('{');
+
+        if (art.includes?.length && isDirectStruct) {
+          // We can only render includes, if the type is directly structured. Otherwise, we would
+          // render e.g. `type T : Include : T2;`, which is invalid.  We use `extend` in such cases.
+          result += renderIncludes(art.includes, env);
+        }
+
+        // For nicer output, no colon if unnamed structure is used.
+        result += (!art.type && art.elements) ? ` ${type}` : ` : ${type}`;
+      }
+      else {
+        msg.warning('syntax-missing-type', env.path, { '#': art.kind, name: artifactName }, {
+          std: 'Missing type for definition $(NAME); can\'t be represented in CDL',
+          entity: 'Missing elements for entity $(NAME); can\'t be represented in CDL',
+        });
+      }
     }
-    else if (art.elements) {
-      result += ` ${renderElements(art, env)};\n`;
+
+    if (art.actions) {
+      if (!isQuery && !isDirectStruct) {
+        // If there are no elements nor query, but actions, CDL syntax requires braces.
+        result += ' { }';
+      }
+      result += renderActionsAndFunctions(art, env);
     }
+
+    result += ';\n';
+
+    if (art.includes?.length && !isDirectStruct) {
+      // If we're not a directly structured type, render the `includes` as `extend`
+      // statements directly below the type definition.
+      result += renderExtendStatement(artifactName, { includes: art.includes }, env);
+    }
+
     return result;
   }
 
@@ -516,35 +556,6 @@ function csnToCdl( csn, options, msg ) {
     return `${result} {};\n`;
   }
 
-  /**
-   * Render a (non-projection, non-view) entity. Return the resulting source string.
-   *
-   * @param {string} artifactName
-   * @param {CSN.Artifact} art
-   * @param {CdlRenderEnvironment} env
-   * @return {string}
-   */
-  function renderEntity( artifactName, art, env ) {
-    let result = renderAnnotationAssignmentsAndDocComment(art, env);
-    result += env.indent + (art.abstract ? 'abstract ' : '');
-    result += `entity ${renderArtifactName(artifactName, env)}`;
-
-    if (art.params)
-      result += renderParameters(art, env);
-    if (art.includes)
-      result += renderIncludes(art.includes, env);
-
-    if (art.elements)
-      result += ` ${renderElements(art, env)}`;
-    else if (art.actions)
-      // if there are no elements, but actions, CDL syntax requires braces.
-      result += ' { }';
-
-    result += `${renderActionsAndFunctions(art, env)};\n`;
-
-    return result;
-  }
-
   /**
    * Render an aspect. Return the resulting source string.
    * Behaves very similar to renderEntity, _except_ that aspects are
@@ -938,8 +949,10 @@ function csnToCdl( csn, options, msg ) {
     // No expression to render for { * } as alias
     let result = (obj.as && obj.expand && !obj.ref) ? '' : exprRenderer.renderExpr(withoutCast(obj), env);
 
+    const isAnonymousExpand = (obj.expand && !obj.ref);
+
     // s as alias { * }
-    if (obj.as && (obj.ref || obj.xpr || obj.val !== undefined || obj.func !== undefined))
+    if (obj.as && !isAnonymousExpand)
       result += renderAlias(obj.as, env);
 
     // We found a leaf - no further drilling
@@ -971,7 +984,7 @@ function csnToCdl( csn, options, msg ) {
       result += ` excluding { ${obj.excluding.join(',')} }`;
 
     // { * } as expand
-    if (!obj.ref && obj.as)
+    if (obj.as && isAnonymousExpand)
       result += renderAlias(obj.as, env);
 
     return result;
@@ -1268,47 +1281,6 @@ function csnToCdl( csn, options, msg ) {
     return result;
   }
 
-  /**
-   * Render a type (derived or structured) or an annotation decl with name 'artifactName'.
-   * Return the resulting source string.
-   *
-   * @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.
-   * @return {string}
-   */
-  function renderTypeOrAnnotation( artifactName, art, env, artType ) {
-    let result = renderAnnotationAssignmentsAndDocComment(art, env);
-    result += `${env.indent + (artType || art.$syntax || art.kind )} ${renderArtifactName(artifactName, env)}`;
-
-    const type = renderTypeReferenceAndProps(art, env);
-    const isDirectStruct = type?.startsWith('{');
-    if (art.includes?.length && isDirectStruct)
-      // We can only render includes, if the type is directly structured. Otherwise,  we would
-      // render e.g. `type T : Include : T2;`, which is invalid.  We use `extend` in such cases.
-      result += renderIncludes(art.includes, env);
-
-    if (type) {
-      // For nicer output, no colon if unnamed structure is used.
-      result += (!art.type && art.elements) ? ` ${type}` : ` : ${type}`;
-    }
-    else {
-      msg.warning('syntax-missing-type', env.path, { name: artifactName },
-                  'Missing type for definition $(NAME); can\'t be represented in CDL');
-    }
-
-    result += ';\n';
-
-    if (art.includes?.length && !isDirectStruct) {
-      // If we're not a directly structured type, render the `includes` as `extend`
-      // statements directly below the type definition.
-      result += renderExtendStatement(artifactName, { includes: art.includes }, env);
-    }
-
-    return result;
-  }
-
   /**
    * Render a reference to a type used by 'artifact' (named or inline) and (element) properties
    * such as `not null` and `default <xpr>`.