@sap/cds-compiler 5.4.2 → 5.5.0

package/lib/parsers/CdlGrammar.g4

@@ -9,6 +9,9 @@ options {
   const { XsnSource, XsnArtifact, XsnName } = require( '../compiler/xsn-model' );
   const AstBuildingParser = require('../parsers/AstBuildingParser');
 }
+@footer{
+  module.exports = { CdlParser }; // make it work with lazyload()
+}
 
 // Content:
 //  - top-level: USING, NAMESPACE, artifactDefOrExtend (start rule: start)
@@ -213,23 +216,17 @@ aspectDef[ art, outer ]
     { this.docComment( $art ); } annoAssignMid[ $art ]*
     (
       elementsBlock[ $art ]
-      actionsBlock[ $art ]?
     |
-      ':' aspectColonSpec[ $art ]
-    )?
-  ;
-
-aspectColonSpec[ art ]
-options{ minTokensMatched = 1 }
-  :
-    (
-      incl=simplePath { $art.includes ??= []; $art.includes.push( $incl ); }
-      ( ',' | <exitLoop> )
-    )*
-    (
+      <exitRule>
+    |
+      ':'
+      (
+        incl=simplePath { $art.includes ??= []; $art.includes.push( $incl ); }
+        ( ',' | <exitLoop> | <exitRule> )
+      )*
       elementsBlock[ $art ]
-      actionsBlock[ $art ]?
-    )?                          // TODO: no rule end after ','
+    )
+    actionsBlock[ $art ]?
   ;
 
 entityDef[ art, outer ]
@@ -419,7 +416,7 @@ elementDef[ outer, art = undefined ]
     { this.docComment( $art ); } annoAssignStd[ $art ]*
     ( VIRTUAL { $art.virtual = this.valueWithLocation( true ); } )?
     ( KEY { $art.key = this.valueWithLocation( true ); } )?
-    ( MASKED { $art.masked = this.valueWithLocation( true ); }
+    ( <hide> MASKED { $art.masked = this.valueWithLocation( true ); }
       { this.message( 'syntax-unsupported-masked', this.lb(), { keyword: 'masked' } ); } )?
     ( ELEMENT { $art.$syntax = 'element'; } )?
     Id['Element'] <prepare=elementRestriction, arg=elem>
@@ -429,7 +426,7 @@ elementDef[ outer, art = undefined ]
       elementsBlock[ $art ]
       nullability[ $art ]?
     |
-      ':' typeExpression[ $art ] // was elementType, with NOT? NULL / DEFAULT
+      ':' typeExpression[ $art ] // includes DEFAULT
     )?
     (
       <cond=elementRestriction, arg=calc> '='
@@ -440,9 +437,7 @@ elementDef[ outer, art = undefined ]
       // TODO: why have `stored` as property of the value?
       { if (this.elementRestriction( true, 'anno' )) this.docComment( $art ); }
       ( <cond=elementRestriction, arg=anno> annoAssignStd[ $art ] )*
-    |
-      { this.docComment( $art, 'type' ); } // delayed from type expression
-    )
+    )?
   ;
 
 enumSymbolsBlock[ art ]
@@ -464,10 +459,10 @@ enumSymbolDef[ outer ] locals[ art = new XsnArtifact() ]
     { this.docComment( $art ); } annoAssignStd[ $art ]*
     ( '='
       (
-        <priority> String
+        <prefer> String
         { $art.value = this.quotedLiteral(); }
       |
-        <priority> Number
+        <prefer> Number
         { $art.value = this.numberLiteral(); }
       |
         sign='+'/'-' Number
@@ -803,7 +798,7 @@ typeOrIncludesSpec[ art ]
     (
       typeExpression[ $art ]
     |
-      <priority>
+      <prefer>
       ref=simplePath { $art.type = $ref; }
       (
         // <default> does not work here
@@ -830,122 +825,103 @@ typeOrIncludesSpec[ art ]
     )
   ;
 
-// Type expression (after the `:`) and “final” annotation assignment.  Type
-// expressions include `null`/`not null` and `default`, the latter is forbidden in
-// the `returns` type.
+// Type expression (after the `:`), including `null`/`not null` and `default`;
+// the latter is forbidden in the `returns` type.
+//
+// This rule also parses annotation assignments and doc comments after the
+// type/target reference and after each type property; exceptions are:
+//  - not after element and `enum` blocks (would interfere with optional `;`)
+//  - no further type property after `many …` @assignment`, because the
+//    annotations are attached to the element, the type properties to the line type
 //
 // If used in a definition with additional clauses (currently just `= expr` for
 // elements), these clauses must be guarded with <cond=…>.
 //
-// No annotation assignments are allowed after element and enum blocks, because
-// these would conflict with the optional `;` after those blocks.  To lower the
-// impact with enums, the “final” annotation assignments are actually moved before
-// the keyword `enum` (only allowed if not after `many`/`array of`).
-//
-// This rule is not used when the type expression is restricted: CDL-style cast in
-// `select` items, `cast` function, `mixin` definition.
+// This rule is for element, type, (input and `returns`) parameter and annotation
+// definitions.  It is not used when the type expression is restricted: CDL-style
+// cast in `select` items, `cast` function, `mixin` definition.
 
 typeExpression[ art ]
-// TODO: really introduce <exitRule>
   :
-    elementsBlock[ $art ] <prepare=elementRestriction, arg=calc>
-    nullability[ $art ]?
-  |
     ( typeRefOptArgs[ $art ] | typeTypeOf[ $art ] )
     (<altRuleStart>)
-    nullability[ $art ]?
-    (
-      nullabilityAndDefault[ $art ]
-      // TODO TOOL: with <exitRule>, we could move the following to the end
-      (
-        { this.elementRestriction( false, 'calc' ); }
-        // <prepare=elementRestriction, arg=calc>
-        { this.docComment( $art ); } annoAssignStd[ $art ]+
-      |
-        // We could still have the calc expression after this → delay
-        { this.docComment( $art, 'elem' ); }
-      )
-    |
-      { this.docComment( $art, 'elem' ); }
-    |
-      { this.docComment( $art ); } annoAssignStd[ $art ]+ // +!
-      ( enumSymbolsBlock[ $art ] <prepare=elementRestriction, arg=anno>
-        // TODO TOOL: written?
-        nullabilityAndDefault[ $art ]?
+    { this.docComment( $art ); } annoAssignStd[ $art ]*
+    ( <cond=elementRestriction, arg=notNull> nullability[ $art ]
+      { this.docComment( $art ); } annoAssignStd[ $art ]*
+    )?
+    ( enumSymbolsBlock[ $art ] <prepare=elementRestriction, arg=anno>
+      ( <cond=elementRestriction, arg=notNull> nullability[ $art ] )?
+      ( <cond=elementRestriction, arg=default>
+        DEFAULT expr=expression { $art.default = $expr; }
       )?
-    |
-      { this.docComment( $art ); }
-      enumSymbolsBlock[ $art ] <prepare=elementRestriction, arg=anno>
-      nullabilityAndDefault[ $art ]?
-    )
+      ( <cond=elementRestriction, arg=notNull> nullability[ $art ] )?
+    | typeProperties[ $art ]
+    )?
   |
-    LOCALIZED
-    { $art.localized = this.valueWithLocation( true ); }
-    typeRefOptArgs[ $art ]      // TODO: why no TYPE OF ?
-    nullabilityAndDefault[ $art ]?
-    // TODO TOOL: with <exitRule>, we could move the following to the end
-    (
-      { this.elementRestriction( false, 'calc' ); }
-      // <prepare=elementRestriction, arg=calc>
-      { this.docComment( $art ); } annoAssignStd[ $art ]+
-    |
-      { this.docComment( $art, 'elem' ); }
-    )
+    LOCALIZED { $art.localized = this.valueWithLocation( true ); }
+    typeRefOptArgs[ $art ]      // no TYPE OF
+    { this.docComment( $art ); }
+    typeProperties[ $art ]?
   |
     assoc=ASSOCIATION <prepare=elementRestriction, arg=calc>
     cardinality[ $art ]? TO card=ONE/MANY?
-    target=simplePath { this.setAssocAndComposition( $art, $assoc, $card, $target ); }
-    ( ON cond=condition { $art.on = $cond; }
-    | foreignKeysBlock[ $art ]?
-      nullabilityAndDefault[ $art ]?
-      // scalar default ? - hm..., what about calc expression?
-    )
-    // final anno assignments allowed also with fkeys (no auto-`;` after them):
-    // (the "TODO TOOL" code for doc/annos would also be fine)
-    { this.docComment( $art ); } annoAssignStd[ $art ]*
+    typeAssocProperties[ $art, $assoc, $card ]
   |
     assoc=COMPOSITION <prepare=elementRestriction, arg=calc>
     cardinality[ $art ]? OF card=ONE/MANY?
-    (
-      target=simplePath { this.setAssocAndComposition( $art, $assoc, $card, $target ); }
-      ( ON cond=condition { $art.on = $cond; }
-      | foreignKeysBlock[ $art ]?
-        nullabilityAndDefault[ $art ]?
-      )
-      // final anno assignments allowed also with fkeys (no auto-`;` after them):
-      // (the "TODO TOOL" code for doc/annos would also be fine)
-      { this.docComment( $art ); } annoAssignStd[ $art ]*
-    |
-      { $target = { location: this.startLocation( this.la() ) };
-        this.setAssocAndComposition( $art, $assoc, $card, $target ); }
-      elementsBlock[ $target ]
-      { $target.location = $target.elements[Symbol.for('cds.$location')]; }
+    ( typeAssocProperties[ $art, $assoc, $card ]
+    | elementsBlock[ this.setAssocAndComposition( $art, $assoc, $card ) ]
+      { $art.target.location = $art.target.elements[Symbol.for('cds.$location')]; }
     )
   |
     ( ARRAY <prepare=elementRestriction, arg=calc>
       OF  { $art.items = { location: this.locationOfPrevTokens( 2 ) }; }
     | MANY <prepare=elementRestriction, arg=calc>
       { $art.items = { location: this.lb().location }; }
-    )
+    )                      // no anno assignments, except to end type expression
     (
-      elementsBlock[ $art.items ]
-      nullability[ $art.items ]?
-    |
       ( typeRefOptArgs[ $art.items ] | typeTypeOf[ $art.items ] )
-      nullability[ $art.items ]?
-      ( enumSymbolsBlock[ $art.items ]
-        nullability[ $art.items ]?
-      |
-        // TODO TOOL: with <exitRule>, we could move the following to the end
-        { this.elementRestriction( false, 'calc' ); }
-        // <prepare=elementRestriction, arg=calc>
-        { this.docComment( $art ); } annoAssignStd[ $art ]+
-      |
-        { this.docComment( $art, 'elem' ); }
+      ( <cond=elementRestriction, arg=notNull> nullability[ $art.items ] )?
+      ( { this.docComment( $art ); } annoAssignStd[ $art ]*
+        { ; } <exitRule>         // TODO TOOL: make it work without workaround { ; }
+        // TODO TOOL: investigate why simply `{} <exitRule>` is ignored
+      | enumSymbolsBlock[ $art.items ]
       )
+    |
+      elementsBlock[ $art.items ]
     )
+    ( <cond=elementRestriction, arg=notNull> nullability[ $art.items ] )?
+  |
+    elementsBlock[ $art ] <prepare=elementRestriction, arg=calc>
+    nullability[ $art ]?
+  ;
+
+typeAssocProperties[ art, assoc, card ]
+  :
+    target=simplePath { this.setAssocAndComposition( $art, $assoc, $card, $target ); }
+    { this.docComment( $art ); } annoAssignStd[ $art ]*
+    ( ON cond=condition { $art.on = $cond; }
+      { this.docComment( $art ); } annoAssignStd[ $art ]*
+    | foreignKeysBlock[ $art ] { this.docComment( $art ); } typeProperties[ $art ]?
+      // remark: no auto-`;` after foreign keys → anno assignment after it possible
+    | typeProperties[ $art ]
+    )?
+  ;
+
+typeProperties[ art ]
+  :
+    (
+      annoAssignStd[ $art ]
+    |
+      <cond=elementRestriction, arg=notNull>
+      nullability[ $art ] { this.docComment( $art ); }
+    |
+      <cond=elementRestriction, arg=default>
+      DEFAULT expr=expression { $art.default = $expr; this.docComment( $art ); }
+    )+
   ;
 
+
 typeTypeOf[ art ] locals[ location ]
   :
     TYPE OF { location = this.locationOfPrevTokens( 2 ); }
@@ -1049,7 +1025,7 @@ targetCardinality[ card, atAlt = false ]
       '*'      { $card.targetMax = this.valueWithLocation(); }
     |
       Number   { $card.targetMax = this.unsignedIntegerLiteral(); }
-      ( <altRuleStart> )        // TODO TOOL: robust error when moved to after '('
+      (<altRuleStart>)          // TODO TOOL: robust error when moved to after '('
       (
         '..'     { $card.targetMin = $card.targetMax; }
         ( '*'    { $card.targetMax = this.valueWithLocation(); }
@@ -1059,20 +1035,6 @@ targetCardinality[ card, atAlt = false ]
     )
   ;
 
-nullabilityAndDefault[ art ]
-  :
-    nullability[ $art ]
-    ( <cond=elementRestriction, arg=default> DEFAULT expr=expression
-      { $art.default = $expr; }
-    )?
-  |
-    <cond=elementRestriction, arg=default> DEFAULT expr=expression
-    { $art.default = $expr; }
-    nullability[ $art ]?
-    // TODO TOOL: when `followUnion` does not contain `Id`, `RuleEnd_` does not
-    // need to induce prediction (here for `default`).
-  ;
-
 nullability[ art ]
   :
     NULL { this.setNullability( $art, false ); }
@@ -1209,7 +1171,7 @@ tableExpression returns[ default expr = {} ] // TableOrJoin
 tableOrQueryParens returns[ default expr ]
   :
     '(' <prepare=queryOnLeft>
-    ( <priority> tableOrQueryParens[ ...$ ]
+    ( <prefer> tableOrQueryParens[ ...$ ]
       ( tableExpression[ ...$ ]<atAltStart, prepare=queryOnLeft, arg=table>
       | <cond=queryOnLeft> queryExpression[ ...$ ]<atAltStart>
       )?
@@ -1498,8 +1460,6 @@ condition returns[ default expr ]
     expression[ ...$ ]
   ;
 
-// TODO TOOL: sort rules if a rule with <altRuleStart> uses rule with <altRuleStart>
-// at least issue error if no user-sorted
 valuePath returns[ default expr = { path: [] } ] locals[ pathItem ]
 @finally{ this.attachLocation( $expr ); }
   :
@@ -1619,7 +1579,7 @@ expression returns[ default expr = {} ]
 expressionOrQueryParens returns[ default expr ]
   :
     '(' <prepare=queryOnLeft>
-    ( <priority> expressionOrQueryParens[ ...$ ]
+    ( <prefer> expressionOrQueryParens[ ...$ ]
       ( expression[ ...$ ]<atAltStart, prepare=queryOnLeft, arg=expr>
         continueExpressionslist[ ...$ ]?
       | continueExpressionslist[ ...$ ] <prepare=queryOnLeft, arg=expr>
@@ -2000,7 +1960,8 @@ annoValue returns[ default value = {} ]
       }
       ( ',' | <exitLoop> )
     )*
-    // ( <cond=TODO> '}' )         // TODO TOOL - workaround:
+    // TODO TOOL: allow:
+    // ( <cond=arrayAnno, …> '}' | <error> )         // TODO TOOL - workaround:
     { this.ec( 'arrayAnno', 'orNotEmpty' ); } '}'
     // Do NOT use <prepare=afterBrace> here!
   |

package/lib/parsers/index.js

@@ -0,0 +1,123 @@
+// Entry point to parsers
+
+'use strict';
+
+const lazyload = require('../base/lazyload')( module );
+const { CompilerAssertion } = require( '../base/error' );
+const { createMessageFunctions } = require( '../base/messages' );
+const { XsnSource } = require('../compiler/xsn-model');
+
+const parseWithAntlr = lazyload('../language/antlrParser');
+const CdlLexer = require( './Lexer' );
+const gen = lazyload( '../gen/CdlParser' );
+
+const rules = {
+  cdl: { func: 'start', returns: 'source', $frontend: 'cdl' },
+  query: { func: 'queryEOF', returns: 'query' },
+  expr: { func: 'conditionEOF', returns: 'cond' }, // yes, condition
+};
+
+function parseCdl( source, filename = '<undefined>.cds',
+                   options = {}, messageFunctions = null,
+                   rule = 'cdl' ) {
+  const rulespec = rules[rule];
+  if (!options.newParser)
+    return parseWithAntlr( source, filename, options, messageFunctions, rulespec );
+  const { CdlParser } = gen;
+  if (CdlParser.tracingParser)  // tracing → direct console output of message
+    messageFunctions = createMessageFunctions( {}, 'parse', {} );
+
+  const lexer = new CdlLexer( filename, source );
+  const parser = new CdlParser( lexer, options, messageFunctions ).init();
+  parser.filename = filename;   // LSP compatibility
+
+  // For LSP:
+  const { parseListener, attachTokens } = options;
+  if (parseListener || attachTokens)
+    setTokenStream( parser, lexer );
+  if (parseListener)
+    setParseListener( parser, parseListener );
+
+  const result = {};
+  try {
+    parser[rulespec.func]( result );
+  }
+  catch (e) {
+    if (!(e instanceof RangeError && /Maximum.*exceeded$/i.test( e.message )))
+      throw e;
+    messageFunctions.error( 'syntax-invalid-source', { file: filename },
+                            { '#': 'cdl-stackoverflow' } );
+    result[rulespec.returns] = undefined;
+  }
+  const ast = result[rulespec?.returns] || (rule === 'cdl' ? new XsnSource( 'cdl' ) : {} );
+  ast.options = options;
+  if (attachTokens === true || attachTokens === filename)
+    ast.tokenStream = parser._input;
+  return ast;
+}
+
+function setTokenStream( parser, lexer ) {
+  const combined = [];
+  const { tokens, comments, docComments } = parser;
+  const length = tokens.length + comments.length + docComments.length;
+  let tokenIdx = 0;
+  let commentIdx = 0;
+  let docCommentIdx = 0;
+  for (let index = 0; index < length; ++index) {
+    if (tokens[tokenIdx].location.tokenIndex === index) // EOF has largest tokenIndex
+      combined.push( tokens[tokenIdx++] );
+    else if (comments[commentIdx]?.location.tokenIndex === index)
+      combined.push( comments[commentIdx++] );
+    else
+      combined.push( docComments[docCommentIdx++] );
+  }
+  if (!combined.at( -1 ))
+    throw new CompilerAssertion( 'Invalid values for `tokenIndex`' );
+  for (const tok of combined)
+    tok.start = lexer.characterPos( tok.location.line, tok.location.col );
+
+  parser._input = { tokens: combined, lexer }; // lexer for characterPos() in cdshi.js
+  parser.getTokenStream = function getTokenStream() {
+    return this._input;
+  };
+}
+
+function setParseListener( parser, parseListener ) {
+  const { CdlParser } = gen;
+  parser.rule_ = function rule_( ...args ) {
+    // TODO: can we use `super` here?
+    CdlParser.prototype.rule_.apply( this, args );
+    let state = this.s;
+    while (typeof this.table[--state] !== 'string')
+      ;
+    const $ctx = {    // ANTLR-like context, TODO LSP: more to add?
+      parser: this,   // set in generated ANTLR parser for each rule context
+      ruleName: this.table[state], // instead of ruleIndex
+      start: this.la(),       // set in Parser#enterRule
+      stop: null,
+    };
+    parser.stack.at( -1 ).$ctx = $ctx;
+    parseListener.enterEveryRule( $ctx );
+  };
+  parser.exit_ = function exit_( ...args ) {
+    const { $ctx } = parser.stack.at( -1 );
+    // TODO: what should we do in case of errors?
+    $ctx.stop = this.lb();
+    parseListener.exitEveryRule( $ctx );
+    return CdlParser.prototype.exit_.apply( this, args );
+  };
+  parser.c = function c( ...args ) { // consume
+    const symbol = this.la();
+    const result = CdlParser.prototype.c.apply( this, args );
+    if (result)
+      parseListener.visitTerminal( { symbol } );
+    return result;
+  };
+  parser.skipToken_ = function skipToken_( ...args ) { // skip token in error recovery
+    const symbol = this.la();
+    CdlParser.prototype.skipToken_.apply( this, args ); // = `++this.tokenIdx`
+    parseListener.visitErrorNode( { symbol } );
+  };
+}
+
+module.exports = { parseCdl };

package/lib/render/toSql.js

@@ -559,13 +559,19 @@ function toSqlDdl( csn, options, messageFunctions ) {
           const add = def.new.target
             ? render.addAssociations(artifactName, { [eltName]: def.new }, env)
             : render.addColumnsFromElementsObj(artifactName, { [eltName]: def.new }, env);
-          addMigration(resultObj, artifactName, true, render.concat(...drop, ...add).map(s => (def.lossy && options.src !== 'hdi' ? `-- [WARNING] this statement could be lossy\n${s}` : s)));
+          addMigration(resultObj, artifactName, true, render.concat(...drop, ...add).map(s => (def.lossy !== undefined && options.src !== 'hdi' ? `-- [WARNING] this statement could ${def.lossy ? 'be lossy' : 'fail'}: ${def.details}\n${s}` : s)));
         }
         else { // Lossless change: no associations directly affected, no size reduction.
-          addMigration(resultObj, artifactName, false, render.alterColumns(artifactName, sqlId, def, eltStrNew, eltName, activateAlterMode(env, 'migration')).map(s => (def.lossy ? `-- [WARNING] this statement could be lossy\n${s}` : s)));
+          addMigration(resultObj, artifactName, false, render.alterColumns(artifactName, sqlId, def, eltStrNew, eltName, activateAlterMode(env, 'migration')).map(s => (def.lossy !== undefined ? `-- [WARNING] this statement could ${def.lossy ? 'be lossy' : 'fail'}: ${def.details}\n${s}` : s)));
         }
       }
     }
+
+    if (render.getConsolidatedAlterColumn) {
+      const consolidated = render.getConsolidatedAlterColumn(artifactName);
+      if (consolidated)
+        addMigration(resultObj, artifactName, false, consolidated);
+    }
   }
 
   /**

package/lib/render/utils/delta.js

@@ -72,6 +72,15 @@ class DeltaRenderer {
    * Render column modifications as SQL.
    */
   alterColumns(artifactName, columnName, delta, definitionsStr, _eltName, _env) {
+    if (Array.isArray(definitionsStr)) {
+      const prefix = `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ALTER (`;
+      let padding = '';
+      for (let i = 0; i < prefix.length; i++)
+        padding += ' ';
+      const body = definitionsStr.map(s => padding + s).join(',\n').slice(padding.length); // no padding for first part
+      const postfix = ');';
+      return [ prefix + body + postfix ];
+    }
     return [ `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ALTER (${definitionsStr});` ];
   }
 
@@ -123,6 +132,29 @@ class DeltaRenderer {
 }
 
 class DeltaRendererHana extends DeltaRenderer {
+  #alters = [];
+  #details = [];
+
+  getConsolidatedAlterColumn(artifactName) {
+    if (this.#alters.length === 0)
+      return null;
+    const result = [ ...this.#details, ...super.alterColumns(artifactName, null, null, this.#alters) ];
+    this.#alters = [];
+    this.#details = [];
+    return result;
+  }
+
+  /**
+   * Render column modifications as SQL.
+   */
+  alterColumns(artifactName, columnName, delta, definitionsStr, _eltName, _env) {
+    if (delta.details)
+      this.#details.push(`-- [WARNING] this statement could ${delta.lossy ? 'be lossy' : 'fail'}: ${delta.details}`);
+
+    this.#alters.push(definitionsStr);
+    return [];
+  }
+
   /**
    * Render column additions as HANA SQL. Checks for duplicate elements.
    */
@@ -230,7 +262,7 @@ class DeltaRendererH2 extends DeltaRenderer {
   /**
    * Render column modifications as H2 SQL - no ().
    */
-  alterColumns(artifactName, columnName, delta, definitionsStr) {
+  alterColumns(artifactName, columnName, delta, definitionsStr, _eltName, _env) {
     return [ `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ALTER ${definitionsStr};` ];
   }
 }