@sap/cds-compiler 5.1.0 → 5.2.0

package/lib/language/antlrParser.js

@@ -17,6 +17,10 @@ const { XsnSource } = require('../compiler/xsn-model');
 const Parser = require('../gen/languageParser').default;
 const Lexer = require('../gen/languageLexer').default;
 
+const CdlLexer = require( '../parsers/Lexer' );
+const CdlParser = require( '../gen/CdlParser' );
+const { createMessageFunctions } = require( '../base/messages' );
+
 // Error listener used for ANTLR4-generated parser
 class ErrorListener extends antlr4.error.ErrorListener {
   // method which is called by generated parser with --trace-parser[-amg]:
@@ -129,6 +133,9 @@ const rules = {
 function parse( source, filename = '<undefined>.cds',
                 options = {}, messageFunctions = null,
                 rule = 'cdl' ) {
+  if (options.newParser)
+    return parseWithNewParser( source, filename, options, messageFunctions, rule );
+
   const lexer = new Lexer( new antlr4.InputStream(source) );
   const tokenStream = new RewriteTypeTokenStream(lexer);
   /** @type {object} */
@@ -211,4 +218,59 @@ function parse( source, filename = '<undefined>.cds',
   return ast;
 }
 
+function parseWithNewParser( source, filename, options, messageFunctions, rule ) {
+  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
+  parser.tokenStream = parser;  // LSP compatibility: object with property `tokens`
+
+  // LSP feature: provide parse listener with ANTLR-like context:
+  const { parseListener } = options;
+  if (parseListener) {
+    // TODO LSP: we could also call different listener methods: then LSP could
+    // have dedicated methods for ANTLR-based and new parser
+    parser.rule_ = function rule_( ...args ) {
+      CdlParser.prototype.rule_.apply( this, args );
+      let state = this.s;
+      while (typeof this.table[--state] !== 'string')
+        ;
+      const $ctx = {    // 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 );
+      CdlParser.prototype.exit_.apply( this, args );
+    };
+  }
+  const result = {};
+  const rulespec = rules[rule];
+  if (rulespec) {
+    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' ) : {} );
+  if (options.attachTokens === true || options.attachTokens === filename)
+    ast.tokenStream = parser;   // with property tokens
+  return ast;
+}
+
 module.exports = parse;

package/lib/language/genericAntlrParser.js

@@ -101,6 +101,8 @@ Object.assign(GenericAntlrParser.prototype, {
   warnIfColonFollows,
   fragileAlias,
   identAst,
+  reportPathNamedManyOrOne,
+  reportMissingSemicolon,
   pushXprToken,
   pushOpToken,
   argsExpression,
@@ -276,6 +278,7 @@ function markAsSkippedUntilEOF() {
 function noAssignmentInSameLine() {
   const t = this.getCurrentToken();
   if (t.text === '@' && t.line <= this._input.LT(-1).line) {
+    // TODO: use 'syntax-missing-newline'
     this.warning( 'syntax-missing-semicolon', t, { code: ';' },
                   // eslint-disable-next-line max-len
                   'Add a $(CODE) and/or newline before the annotation assignment to indicate that it belongs to the next statement' );
@@ -801,6 +804,31 @@ function identAst( token, category, noTokenTypeCheck = false ) {
   return ast;
 }
 
+function reportPathNamedManyOrOne( { path } ) {
+  if (path.length === 1 && !path[0].$delimited &&
+      [ 'many', 'one' ].includes( path[0].id.toLowerCase() )) {
+    this.message( 'syntax-unexpected-many-one', path[0].location,
+                  { code: path[0].id, delimited: path[0].id } );
+  }
+}
+
+function reportMissingSemicolon() {
+  const next = this._input.LT(1);
+  if (next.text !== ';' && next.text !== '' && // ';' by insertSemicolon()
+      next.text !== '}' && next.type !== antlr4.Token.EOF &&
+      this._input.LT(-1).text !== '}') {
+    const offending = this.literalNames[next.type] || this.symbolicNames[next.type];
+    const loc = this.tokenLocation( this._input.LT(-1) );
+    // better location after the previous token:
+    const location = new Location( loc.file, loc.endLine, loc.endCol );
+    // it would be nicer to mention the doc comment if present, but not worth the
+    // effort; 'syntax-missing-semicolon' already used
+    this.warning( 'syntax-missing-proj-semicolon', location,
+                  { expecting: [ "';'" ], offending },
+                  'Missing $(EXPECTING) before $(OFFENDING)');
+  }
+}
+
 function pushXprToken( args ) {
   const token = this._input.LT(-1);
   args.push( {

package/lib/model/csnUtils.js

@@ -3,6 +3,7 @@
 const { csnRefs, implicitAs, pathId } = require('./csnRefs');
 const {
   transformExpression,
+  transformAnnotationExpression,
   applyTransformations,
   applyTransformationsOnNonDictionary,
   applyTransformationsOnDictionary,
@@ -1419,6 +1420,7 @@ module.exports = {
   getUnderscoredName,
   getElementDatabaseNameOf,
   transformExpression,
+  transformAnnotationExpression,
   applyTransformations,
   applyTransformationsOnNonDictionary,
   applyTransformationsOnDictionary,

package/lib/model/revealInternalProperties.js

@@ -306,6 +306,8 @@ function revealInternalProperties( model, nameOrPath ) {
 }
 
 function array( node, fn ) {
+  if (!Array.isArray( node ))
+    return node;
   const r = node.map( n => fn( n, node ) );
   if (node[$location])
     r.push( { '[$location]': locationString( node[$location] ) } );

package/lib/modelCompare/utils/filter.js

@@ -10,46 +10,57 @@ function isKey( element ) {
   return element.key;
 }
 
-module.exports = {
-  sqlite: getFilterObject(
-    'sqlite',
-    function forEachExtension(extend, name, elementOrConstraint, { error, warning }) {
-      if (isKey(elementOrConstraint)) { // Key must not be extended
-        error('type-unsupported-key-sqlite', [ 'definitions', extend, 'elements', name ], { id: name, name: 'sqlite', '#': 'std' } );
-        return false;
-      }
-      else if (elementOrConstraint.parentTable) { // constraints have a .parentTable
-        warning('def-unsupported-constraint-add', [ 'definitions', elementOrConstraint.parentTable, 'elements', elementOrConstraint.paths ? name : name.slice(elementOrConstraint.parentTable.length + 1) ], { id: elementOrConstraint.identifier || name, name: 'sqlite' },
-                'Ignoring add of constraint $(ID), as this is not supported for dialect $(NAME); you need to manually resolve this via shadow tables and data copy');
+function getFilter(options) {
+  const filters = {
+    sqlite: getFilterObject(
+      options,
+      'sqlite',
+      function forEachExtension(extend, name, elementOrConstraint, { error, warning }) {
+        if (isKey(elementOrConstraint)) { // Key must not be extended
+          error('type-unsupported-key-sqlite', [ 'definitions', extend, 'elements', name ], { id: name, name: 'sqlite', '#': 'std' } );
+          return false;
+        }
+        else if (elementOrConstraint.parentTable) { // constraints have a .parentTable
+          warning('def-unsupported-constraint-add', [ 'definitions', elementOrConstraint.parentTable, 'elements', elementOrConstraint.paths ? name : name.slice(elementOrConstraint.parentTable.length + 1) ], { id: elementOrConstraint.identifier || name, name: 'sqlite' },
+                  'Ignoring add of constraint $(ID), as this is not supported for dialect $(NAME); you need to manually resolve this via shadow tables and data copy');
+          return false;
+        }
+
+        return true;
+      },
+      function forEachMigration(migrate, name, migration, change, error) {
+        const newIsKey = isKey(migration.new);
+        const oldIsKey = isKey(migration.old);
+        if ((newIsKey || oldIsKey) && oldIsKey !== newIsKey) // Turned into key or key was removed
+          error('type-unsupported-key-sqlite', [ 'definitions', migrate, 'elements', name ], { id: name, name: 'sqlite', '#': 'changed' } );
+        else
+          delete change[name];
+      },
+      function forEachConstraintRemoval(constraintRemovals, name, constraint, warning) {
+        warning('def-unsupported-constraint-drop', [ 'definitions', constraint.parentTable, 'elements', constraint.paths ? name : name.slice(constraint.parentTable.length + 1) ], { id: constraint.identifier || name, name: 'sqlite' },
+                'Ignoring drop of constraint $(ID), as this is not supported for dialect $(NAME); you need to manually resolve this via shadow tables and data copy');
+        delete constraintRemovals[name];
+      },
+      function primaryKey() {
         return false;
       }
+    ),
+    postgres: getFilterObject(options, 'postgres'),
+    h2: getFilterObject(options, 'h2'),
+    hana: getFilterObject(options, 'hana'),
+  };
 
-      return true;
-    },
-    function forEachMigration(migrate, name, migration, change, error) {
-      const newIsKey = isKey(migration.new);
-      const oldIsKey = isKey(migration.old);
-      if ((newIsKey || oldIsKey) && oldIsKey !== newIsKey) // Turned into key or key was removed
-        error('type-unsupported-key-sqlite', [ 'definitions', migrate, 'elements', name ], { id: name, name: 'sqlite', '#': 'changed' } );
-      else
-        delete change[name];
-    },
-    function forEachConstraintRemoval(constraintRemovals, name, constraint, warning) {
-      warning('def-unsupported-constraint-drop', [ 'definitions', constraint.parentTable, 'elements', constraint.paths ? name : name.slice(constraint.parentTable.length + 1) ], { id: constraint.identifier || name, name: 'sqlite' },
-              'Ignoring drop of constraint $(ID), as this is not supported for dialect $(NAME); you need to manually resolve this via shadow tables and data copy');
-      delete constraintRemovals[name];
-    },
-    function primaryKey() {
-      return false;
-    }
-  ),
-  postgres: getFilterObject('postgres'),
-  h2: getFilterObject('h2'),
-  hana: getFilterObject('hana'),
+  return filters[options.sqlDialect];
+}
+
+module.exports = {
   csn: filterCsn,
+  getFilter,
 };
 
-function getFilterObject( dialect, extensionCallback, migrationCallback, removeConstraintsCallback, primaryKeyCallback ) {
+function getFilterObject( options, dialect, extensionCallback, migrationCallback, removeConstraintsCallback, primaryKeyCallback ) {
+  const context = { hasLossyChanges: false };
+  const raiseErrorOrMarkAsLossy = getSafeguardManager(context, options);
   return {
     // will be called with a simple Array.filter, as we need to filter constraint `ADD` for SQLite
     extension: ({
@@ -70,24 +81,28 @@ function getFilterObject( dialect, extensionCallback, migrationCallback, removeC
     },
     // will be called with a Array.forEach
     migration: (migrations, { error, warning, message }) => {
-      forEach(migrations.remove, (name) => {
-        error('def-unsupported-element-drop', [ 'definitions', migrations.migrate, 'elements', name ], {}, 'Dropping elements is not supported');
+      forEach(migrations.remove, (name, migration) => {
+        raiseErrorOrMarkAsLossy(migration, () => error('def-unsupported-element-drop', [ 'definitions', migrations.migrate, 'elements', name ], {}, 'Dropping elements is not supported'));
       });
+
       forEach(migrations.change, (name, migration) => {
         const loc = [ 'definitions', migrations.migrate, 'elements', name ];
         if (migration.new.type === migration.old.type && migration.new.length < migration.old.length)
-          error('type-unsupported-length-change', loc, { id: name }, 'Changed element $(ID) is a length reduction and is not supported');
+          raiseErrorOrMarkAsLossy(migration, () => error('type-unsupported-length-change', loc, { id: name }, 'Changed element $(ID) is a length reduction and is not supported'));
         else if (migration.new.type === migration.old.type && migration.new.scale !== migration.old.scale)
-          error('type-unsupported-scale-change', loc, { id: name }, 'Changed element $(ID) is a scale change and is not supported');
+          raiseErrorOrMarkAsLossy(migration, () => error('type-unsupported-scale-change', loc, { id: name }, 'Changed element $(ID) is a scale change and is not supported'));
         else if (migration.new.type === migration.old.type && migration.new.precision !== migration.old.scale)
-          error('type-unsupported-precision-change', loc, { id: name }, 'Changed element $(ID) is a precision change and is not supported');
+          raiseErrorOrMarkAsLossy(migration, () => error('type-unsupported-precision-change', loc, { id: name }, 'Changed element $(ID) is a precision change and is not supported'));
         else if (migration.new.type !== migration.old.type && typeChangeIsNotCompatible(dialect, migration.old.type, migration.new.type))
-          error('type-unsupported-change', loc, { id: name, name: migration.old.type, type: migration.new.type }, 'Changed element $(ID) is a lossy type change from $(NAME) to $(TYPE) and is not supported');
+          raiseErrorOrMarkAsLossy(migration, () => error('type-unsupported-change', loc, { id: name, name: migration.old.type, type: migration.new.type }, 'Changed element $(ID) is a lossy type change from $(NAME) to $(TYPE) and is not supported'));
         else if (dialect !== 'sqlite' && isKey(migration.new) && !isKey(migration.old)) // key added/changed - pg, hana and sqlite do not support it, h2 probably also - issues when data is in the table already
-          message('type-unsupported-key-change', [ 'definitions', migrations.migrate, 'elements', name ], { id: name, '#': 'changed' } );
+          raiseErrorOrMarkAsLossy(migration, () => message('type-unsupported-key-change', [ 'definitions', migrations.migrate, 'elements', name ], { id: name, '#': 'changed' } ));
         else if (migrationCallback)
           migrationCallback(migrations.migrate, name, migration, migrations.change, error);
 
+        if (options.script && migration.lossy && migrationCallback)
+          migrationCallback(migrations.migrate, name, migration, migrations.change, error);
+
         // TODO: precision/scale growth
       });
 
@@ -102,7 +117,7 @@ function getFilterObject( dialect, extensionCallback, migrationCallback, removeC
     },
     deletion: ([ artifactName, artifact ], error) => {
       if (isPersistedAsTable(artifact))
-        error('def-unsupported-table-drop', [ 'definitions', artifactName ], 'Dropping tables is not supported');
+        raiseErrorOrMarkAsLossy(artifact, () => error('def-unsupported-table-drop', [ 'definitions', artifactName ], 'Dropping tables is not supported'));
     },
     changedPrimaryKeys: (changedPrimaryKeyArtifactName) => {
       if (primaryKeyCallback)
@@ -110,6 +125,7 @@ function getFilterObject( dialect, extensionCallback, migrationCallback, removeC
 
       return true;
     },
+    hasLossyChanges: () => context.hasLossyChanges,
   };
 }
 
@@ -173,3 +189,15 @@ function filterCsn( csn ) {
 
   return csn;
 }
+
+function getSafeguardManager( context, options ) {
+  return function raiseErrorOrMarkAsLossy(migration, raiseError) {
+    if (!options.script) {
+      raiseError();
+    }
+    else {
+      migration.lossy = true;
+      context.hasLossyChanges = true;
+    }
+  };
+}

package/lib/optionProcessor.js

@@ -38,6 +38,7 @@ optionProcessor
   .option('    --debug <id-list>')
   .option('-E, --enrich-csn')
   .option('-R, --raw-output <name>')
+  .option('    --new-parser')
   .option('    --internal-msg')
   .option('    --beta-mode')
   .option('    --beta <list>')
@@ -54,6 +55,7 @@ optionProcessor
   .option('    --default-binary-length <length>')
   .option('    --default-string-length <length>')
   .option('    --no-recompile')
+  .option('    --skip-name-check', { optionName: '$skipNameCheck' })
   .positionalArgument('<files...>')
   .help(`
   Usage: cdsc <command> [options] <files...>
@@ -113,6 +115,7 @@ optionProcessor
                             with name = "+", write complete XSN, long!
        --tenant-discriminator  Add tenant fields to entities
        --internal-msg       Write raw messages with call stack to <stdout>/<stderr>
+       --new-parser         Use the new CDL parser
        --beta-mode          Enable all unsupported, incomplete (beta) features
        --beta <list>        Comma separated list of unsupported, incomplete (beta) features to use.
                             Valid values are:
@@ -150,6 +153,7 @@ optionProcessor
                                     to "sap.common.Languages" if it exists
        --localized-without-coalesce Omit coalesce in localized convenience views
        --no-recompile       Don't recompile in case of internal errors
+       --skip-name-check    Skip certain name checks, e.g. that there must be no '.' in element names.
 
   Commands
     H, toHana [options] <files...>              Generate HANA CDS source files
@@ -166,7 +170,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; requires beta mode
+       forEffective [options] <files...>        (internal) Get an effective CSN; requires beta mode
        forSeal [options] <files...>             (internal) Get a SEAL CSN
 
   Environment variables
@@ -245,6 +249,7 @@ optionProcessor.command('O, toOdata')
   .option('    --odata-foreign-keys')
   .option('    --odata-v2-partial-constr')
   .option('    --odata-vocabularies <list>')
+  .option('    --odata-no-creator')
   .option('-c, --csn')
   .option('-f, --odata-format <format>', { valid: ['flat', 'structured'] })
   .option('-n, --sql-mapping <style>', { valid: ['plain', 'quoted', 'hdbcds'], aliases: [ '--names' ] })
@@ -278,6 +283,7 @@ optionProcessor.command('O, toOdata')
                                    (Not spec compliant and V2 only)
        --odata-vocabularies <list> JSON array of adhoc vocabulary definitions
                                    { prefix: { alias, ns, uri }, ... }
+       --odata-no-creator          Omit creator identification in API
    -n, --sql-mapping <style> Annotate artifacts and elements with "@cds.persistence.name", which is
                              the corresponding database name (see "--sql-mapping" for "toHana or "toSql")
                                plain   : (default) Names in uppercase and flattened with underscores
@@ -564,7 +570,7 @@ optionProcessor.command('inspect')
        --propagation <art>   Show propagation sources for <art>
 `);
 
-optionProcessor.command('toEffectiveCsn')
+optionProcessor.command('forEffective')
   .option('-h, --help')
   .option('--resolve-simple-types <val>', { valid: ['true', 'false'] } )
   .option('--resolve-projections <val>', { valid: ['true', 'false'] } )
@@ -572,7 +578,7 @@ optionProcessor.command('toEffectiveCsn')
   .option('--keep-localized <val>', { valid: ['true', 'false'] } )
   .positionalArgument('<files...>')
   .help(`
-  Usage: cdsc toEffectiveCsn [options] <files...>
+  Usage: cdsc forEffective [options] <files...>
 
   (internal): Get the effective CSN model compiled from the provided CDS files.
   This command may change any time, including its name.