@sap/cds-compiler 5.1.2 → 5.3.0

package/lib/inspect/inspectPropagation.js

@@ -36,7 +36,7 @@ function inspectPropagation( xsn, options, artifactName ) {
 
   if (!artifactXsn) {
     error(null, null, { name: artifactName },
-          // eslint-disable-next-line max-len
+          // eslint-disable-next-line @stylistic/js/max-len
           'Artifact $(NAME) not found, only top-level artifacts and their elements are supported for now');
     return null;
   }

package/lib/json/from-csn.js

@@ -1134,7 +1134,7 @@ function elementsDict( def, spec, xsn ) {
     return elements;
   warning( 'syntax-expecting-returns', elements[$location],
            { prop: 'elements', parentprop: 'returns' },
-           // eslint-disable-next-line max-len
+           // eslint-disable-next-line @stylistic/js/max-len
            'Expecting property $(PROP) to be put into an object for property $(PARENTPROP) when annotating action return structures' );
   xsn.returns = { kind: 'annotate', elements, location: elements[$location] };
   return undefined;
@@ -2076,8 +2076,10 @@ function toXsn( csn, filename, options, messageFunctions ) {
 
   const xsn = new XsnSource( 'json' ); // TODO: 'csn'? LSP does not use $frontend
 
-  // eslint-disable-next-line object-curly-newline
-  ({ message, error, warning, info } = messageFunctions);
+
+  ({
+    message, error, warning, info,
+  } = messageFunctions);
 
   if (csnVersionZero) {
     warning( 'syntax-deprecated-csn-version', location(true), {},

package/lib/json/to-csn.js

@@ -123,7 +123,7 @@ const transformers = {
   value: enumValueOrCalc,       // do not list for select items as elements
   query,
   elements,
-  actions,                      // TODO: just normal dictionary
+  actions: sortedDict,          // TODO: just normal dictionary
   returns,                      // storing the return type of actions
   // special: top-level, cardinality -----------------------------------------
   sources,
@@ -609,6 +609,10 @@ function addLocation( loc, csn ) {
     // is often not the reason for an error or warning.  So we gain little benefit for
     // two more properties. It is also an indication that the location is not exact.
     const val = { file: loc.file, line: loc.line, col: loc.col };
+    if (withLocations === 'withEndPosition' && loc.endLine) {
+      val.endLine = loc.endLine;
+      val.endCol = loc.endCol;
+    }
     Object.defineProperty( csn, '$location', {
       value: val, configurable: true, writable: true, enumerable: withLocations,
     } );
@@ -621,18 +625,11 @@ function insertOrderDict( dict ) {
   return dictionary( dict, keys );
 }
 
-function sortedDict( dict ) {
+function sortedDict( dict, _csn, _node, prop ) {
   const keys = Object.keys( dict );
   if (strictMode)
     keys.sort();
-  return dictionary( dict, keys );
-}
-
-function actions( dict, _csn, node ) {
-  const keys = Object.keys( dict );
-  if (strictMode && node.kind === 'annotate')
-    keys.sort();                // TODO: always sort with --test-mode ?
-  return dictionary( dict, keys, 'actions' );
+  return dictionary( dict, keys, prop );
 }
 
 function params( dict ) {

package/lib/language/antlrParser.js

@@ -17,6 +17,11 @@ 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' );
+const { CompilerAssertion } = require( '../base/error' );
+
 // 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 +134,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 +219,92 @@ 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
+
+  const { parseListener, attachTokens } = options;
+  if (parseListener || attachTokens) {
+    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;
+    };
+  }
+  // LSP feature: provide parse listener with ANTLR-like context:
+  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 );
+    };
+    parser.c = function c( ...args ) { // consume
+      CdlParser.prototype.c.apply( this, args );
+      parseListener.visitTerminal( { symbol: this.lb() } );
+    };
+    parser.skipToken_ = function skipToken_( ...args ) { // skip token in error recovery
+      CdlParser.prototype.skipToken_.apply( this, args ); // = `++this.tokenIdx`
+      parseListener.visitErrorNode( { symbol: this.lb() } );
+    };
+  }
+  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' ) : {} );
+  ast.options = options;
+  if (attachTokens === true || attachTokens === filename)
+    ast.tokenStream = parser._input;
+  return ast;
+}
+
 module.exports = parse;

package/lib/language/errorStrategy.js

@@ -337,7 +337,7 @@ function reportIgnoredWith( recognizer, t ) {
   const expecting = this.getExpectedTokensForMessage( recognizer, t );
   const m = recognizer.warning( 'syntax-unexpected-semicolon', t,
                                 { offending: "';'", expecting, keyword: 'with' },
-    // eslint-disable-next-line max-len
+    // eslint-disable-next-line @stylistic/js/max-len
                                 'Unexpected $(OFFENDING), expecting $(EXPECTING) - ignored previous $(KEYWORD)' );
   m.expectedTokens = expecting;
 }

package/lib/language/genericAntlrParser.js

@@ -101,6 +101,8 @@ Object.assign(GenericAntlrParser.prototype, {
   warnIfColonFollows,
   fragileAlias,
   identAst,
+  reportPathNamedManyOrOne,
+  reportMissingSemicolon,
   pushXprToken,
   pushOpToken,
   argsExpression,
@@ -276,8 +278,9 @@ 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
+                  // eslint-disable-next-line @stylistic/js/max-len
                   'Add a $(CODE) and/or newline before the annotation assignment to indicate that it belongs to the next statement' );
   }
 }
@@ -682,7 +685,7 @@ function warnIfColonFollows( anno ) {
   if (t.text === ':') {
     this.warning( 'syntax-missing-parens', anno.name.location,
                   { code: '@‹anno›', op: ':', newcode: '@(‹anno›…)' },
-                  // eslint-disable-next-line max-len
+                  // eslint-disable-next-line @stylistic/js/max-len
                   'When $(CODE) is followed by $(OP), use $(NEWCODE) for annotation assignments at this position' );
   }
 }
@@ -793,7 +796,7 @@ function identAst( token, category, noTokenTypeCheck = false ) {
   }
   else {
     this.message( 'syntax-deprecated-ident', token, { delimited: id },
-                  // eslint-disable-next-line max-len
+                  // eslint-disable-next-line @stylistic/js/max-len
                   'Deprecated delimited identifier syntax, use $(DELIMITED) - strings are delimited by single quotes' );
   }
   const ast = { id, $delimited: true, location: this.tokenLocation( token ) };
@@ -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( {
@@ -1021,7 +1049,7 @@ function assignAnnotationValue( anno, value ) {
                     {
                       std: 'Annotation number $(RAWVALUE) is put as $(VALUE) into the CSN',
                       rounded: 'Annotation number $(RAWVALUE) is rounded to $(VALUE)',
-                      // eslint-disable-next-line max-len
+                      // eslint-disable-next-line @stylistic/js/max-len
                       infinite: 'Annotation value $(RAWVALUE) is infinite as number and put as string into the CSN',
                     } );
     }

package/lib/language/multiLineStringParser.js

@@ -77,7 +77,7 @@ class MultiLineStringParser {
     this.str = token.text; // Copy because .text is a getter
 
     if (this.str[0] !== '`' || this.str[this.str.length - 1] !== '`')
-      // eslint-disable-next-line max-len
+      // eslint-disable-next-line @stylistic/js/max-len
       throw new CompilerAssertion('Invalid multi-line string sequence: Require string to be surrounded by back-ticks!');
 
     this.output = [];

package/lib/main.d.ts

@@ -154,6 +154,29 @@ declare namespace compiler {
      * @since v2.12.1
      */
     $xsnObjects?: boolean
+    /**
+     * If `true`, the CSN will have an enumerable property `$locations`.
+     * with values for `line` and `col`, i.e. there is only a start position,
+     * but no end position.
+     *
+     * If `false`, the property will be non-enumerable, i.e. it won't be
+     * serialized when using `JSON.stringify()`.
+     *
+     * With value `"withEndPosition"`, the property will be enumerable and
+     * will contain values for the end-position.  Other string values
+     * are not allowed.  This value was introduced in v5.3.0.
+     *
+     * $location is not set on all artifacts, and it only indicates the position
+     * of the _name_ of the artifact.
+     */
+    withLocations?: boolean|string
+    /**
+     * Use the new non-ANTLR based parser for compilation.
+     * Experimental flag!
+     *
+     * @since v5.2.0
+     */
+    newParser?: boolean
     /**
      * Internal option for LSP only!
      * If set, each AST gets a `tokenStream` property containing all lexed tokens.

package/lib/model/cloneCsn.js

@@ -5,16 +5,23 @@ const { ModelError } = require('../base/error');
 const { setHidden } = require('../utils/objectUtils');
 const { isAnnotationExpression } = require('../base/builtins');
 
-const csnDictionaries = [
-  'args',
-  'params',
-  'enum',
-  'mixin',
-  'elements',
-  'actions',
-  'definitions',
-  'vocabularies',
-];
+const csnDictionaries = {
+  __proto__: null,
+  args: 1,
+  params: 1,
+  enum: 1,
+  mixin: 1,
+  elements: 1,
+  actions: 1,
+  definitions: 1,
+  vocabularies: 1,
+};
+
+const sortedCsnDictionaries = {
+  __proto__: null,
+  definitions: 1,
+  actions: 1,
+};
 
 function shallowCopy( val, _options, _sort ) {
   return val;
@@ -74,9 +81,9 @@ function cloneCsn( csn, options, sort ) {
     else if (!val || typeof val !== 'object') {
       r[n] = val;
     }
-    else if (csnDictionaries.includes(n) && !Array.isArray(val)) {
-      const sortDict = n === 'definitions' &&
-        (!options || options.testMode || options.testSortCsn);
+    else if (csnDictionaries[n] && !Array.isArray(val)) {
+      const sortDict = (!options || options.testMode || options.testSortCsn) &&
+        sortedCsnDictionaries[n];
       // Array check for property `args` which may either be a dictionary or an array.
       r[n] = cloneCsnDict(val, options, sort, sortDict);
     }
@@ -122,6 +129,8 @@ function hasNonEnumerable( object, property ) {
  * @param {object} csn
  * @param {CSN.Options} options Only cloneOptions.dictionaryPrototype is
  *                              used and cloneOptions are passed to sortCsn().
+ * @param {boolean} sortProps   Whether to sort CSN properties.
+ * @param {boolean} sortDict    Whether to sort CSN dictionary entries.
  */
 function cloneCsnDict( csn, options, sortProps, sortDict ) {
   const proto = options?.dictionaryPrototype;

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;
+    }
+  };
+}