@sap/cds-compiler 4.9.6 → 5.1.0

package/lib/json/csnVersion.js

@@ -32,7 +32,7 @@ function isNewCSN( csn, options ) {
 function checkCSNVersion( csn, options ) {
   if (!isNewCSN(csn, options)) {
     // the new transformer works only with new CSN
-    // eslint-disable-next-line global-require
+
     const { makeMessageFunction } = require('../base/messages');
     const { error, throwWithAnyError } = makeMessageFunction(csn, options);
 

package/lib/json/from-csn.js

@@ -650,7 +650,7 @@ const schema = compileSchema( {
     prop: '@‹anno›',            // which property name do messages use for annotation assignments?
     type: annotation,
     // allowed in all definitions except mixins (including columns and extensions)
-    inKind: _kind => true, // TODO(v5): (kind !== 'mixin')
+    inKind: kind => (kind !== 'mixin'),
     schema: {
       '-expr': { // '-expr' and '-' must not exist top-level
         prop: '@‹anno›',
@@ -1495,9 +1495,6 @@ function annotation( val, spec, xsn, csn, name ) {
   if (!id)              // `"@": …` is already syntax-unknown-property
     message( 'syntax-invalid-name', location(true), { '#': '{}' } );
 
-  if (xsn && xsn.kind === 'mixin') // TODO(v5): Remove, adapt spec['@'].inKind
-    message('anno-unexpected-mixin', location(true));
-
   const n = { id, location: location() };
   const r = annoValue( val, spec );
   r.name = n;
@@ -1784,7 +1781,8 @@ function getSpec( parentSpec, csn, prop, xor, expected, kind ) {
         return { prop, type: ignore };
       return { prop, type: extra };
     }
-    // TODO v5: No warning with --sloppy
+    // TODO v6: No warning with --sloppy (does not exist, yet)
+    //          Intention: Ignore unknown properties.
     warning( 'syntax-unknown-property', location(true), { prop },
              'Unknown CSN property $(PROP)' );
     return { type: ignore };
@@ -2076,8 +2074,7 @@ function toXsn( csn, filename, options, messageFunctions ) {
   inExtensions = null;
   vocabInDefinitions = null;
 
-  const xsn = new XsnSource();
-  xsn.$frontend = 'json';
+  const xsn = new XsnSource( 'json' ); // TODO: 'csn'? LSP does not use $frontend
 
   // eslint-disable-next-line object-curly-newline
   ({ message, error, warning, info } = messageFunctions);

package/lib/json/to-csn.js

@@ -93,8 +93,7 @@ const transformers = {
   cardinality,                 // also in pathItem: after 'id', before 'where'
   targetAspect,
   target,
-  $filtered: value,            // assoc+filter v4
-  $enclosed: value,            // comp+filter v5
+  $enclosed: value,            // comp+filter since v5
   foreignKeys,
   enum: enumDict,
   items,
@@ -120,7 +119,7 @@ const transformers = {
   // definitions, extensions, members ----------------------------------------
   notNull: value,
   default: expression,
-  // targetElement: ignore,     // special display of foreign key, renameTo: select
+  targetElement,                // special display of foreign key
   value: enumValueOrCalc,       // do not list for select items as elements
   query,
   elements,
@@ -344,18 +343,24 @@ function sources( srcDict, csn, model ) {
   let names = model._sources || Object.keys( srcDict );
   const $sources = names.length && srcDict[names[0]].$sources;
   if ($sources) {
-    setHidden( csn, '$sources', $sources );
+    setHidden( csn, '$sources', normalize$sources( $sources ) );
     return undefined;
   }
   if (model._sortedSources)
     names = model._sortedSources.map( s => s.realname );
-  setHidden( csn, '$sources', (!strictMode) ? names : names.map( relativeName ) );
+  names = (!strictMode) ? names : normalize$sources( names.map( relativeName ) );
+  setHidden( csn, '$sources', names );
   return undefined;
 
   function relativeName( name ) {
     const loc = srcDict[name].location;
     return loc && loc.file || name;
   }
+  function normalize$sources( src ) {
+    return strictMode
+      ? src.map( name => locationString( name, true ) )
+      : src;
+  }
 }
 
 function attachAnnotations( annotate, prop, dict, inferred, insideReturns = false ) {
@@ -379,6 +384,8 @@ function attachAnnotations( annotate, prop, dict, inferred, insideReturns = fals
         attachAnnotations( sub, 'elements', elems, inf, entry.returns );
       else if (many.enum)       // make 'enum' annotations appear in 'elements' annotate
         attachAnnotations( sub, 'elements', many.enum, inf, entry.returns );
+      else if (entry.foreignKeys) // make 'foreignKeys' annotations appear in 'elements' annotate
+        attachAnnotations( sub, 'elements', entry.foreignKeys, inf );
     }
     if (Object.keys( sub ).length)
       annoDict[name] = sub;
@@ -666,19 +673,19 @@ function returns( art, csn, node, prop ) {
   return definition( art, csn, node, prop );
 }
 
-function definition( art, _csn, _node, prop ) {
+function definition( art, csn, _node, prop ) {
   if (!art || typeof art !== 'object' || art.builtin)
     return undefined;           // TODO: complain with strict
   // Do not include namespace definitions or inferred construct (in gensrc):
   if (art.kind === 'namespace' || art.$inferred && gensrcFlavor)
     return undefined;
-  if (art.kind === 'key') {      // foreignkey
-    const key = addExplicitAs( { ref: art.targetElement.path.map( pathItem ) },
-                               art.name, neqPath( art.targetElement ) );
-    if (!art.$inferred)
+  if (art.kind === 'key') { // foreign key
+    const key = standard( art );
+    if (!art.$inferred) // override location; otherwise only alias would be used
       addLocation( art.targetElement.location, key );
     return extra( key, art );
   }
+
   const c = standard( art );
   // The XSN of actions in extensions do not contain a returns yet - TODO?
   const elems = c.elements;
@@ -946,7 +953,7 @@ function originRef( art, user ) {
     const name = parent.name || parent._outer.name;
     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
+      // eslint-disable-next-line no-nested-ternary
       r.push( !nkind ? name.id : name.id ? { [nkind]: name.id } : { returns: true } );
     parent = parent._parent;
   }
@@ -1142,10 +1149,16 @@ function value( node ) {
   return r;
 }
 
+function targetElement( val, csn, node ) {
+  const key = addExplicitAs( { ref: val.path.map( pathItem ) },
+                             node.name, neqPath( val ) );
+  Object.assign(csn, key);
+}
+
 function enumValueOrCalc( v, csn, node ) {
   if (v.$inferred && (universalCsn || gensrcFlavor))
     return undefined;
-  // Enums values in CSN are without outer `value: { … }`:
+  // Enum values in CSN are without outer `value: { … }`:
   if (node.kind === 'enum') {
     Object.assign( csn, expression( v ) );
   }

package/lib/language/antlrParser.js

@@ -20,7 +20,6 @@ const Lexer = require('../gen/languageLexer').default;
 // Error listener used for ANTLR4-generated parser
 class ErrorListener extends antlr4.error.ErrorListener {
   // method which is called by generated parser with --trace-parser[-amg]:
-  // eslint-disable-next-line class-methods-use-this
   syntaxError( recognizer, offendingSymbol, line, column, msg, e ) {
     if (!(e instanceof CompileMessage)) // not already reported
       // Ignore warning, because only relevant for --trace-parser
@@ -50,7 +49,7 @@ class RewriteTypeTokenStream extends antlr4.CommonTokenStream {
     }
     else if (t.type === this.NEW) {
       const n = super.LT(k + 1);
-      // TODO v5: rewrite token in grammar via `this.setLocalToken`
+      // TODO: rewrite token in grammar via `this.setLocalToken`
       if (n?.type === this.Identifier) {
         const o = super.LT(k + 2);
         if (o?.type === this.PAREN)
@@ -84,6 +83,7 @@ function initTokenRewrite( recognizer, ts ) { // ts = tokenStream
   ts.AT = tokenTypeOf( recognizer, "'@'" );
   ts.SEMICOLON = tokenTypeOf( recognizer, "';'" );
   ts.NEW = Parser.NEW;
+  ts.RETURNS = Parser.RETURNS;
   ts.Identifier = Parser.Identifier;
   ts.PAREN = tokenTypeOf( recognizer, "'('" );
 

package/lib/language/errorStrategy.js

@@ -29,7 +29,6 @@
 'use strict';
 
 const antlr4 = require('antlr4');
-// eslint-disable-next-line camelcase
 const Antlr4LL1Analyzer = require('antlr4/src/antlr4/LL1Analyzer');
 const { DefaultErrorStrategy } = require('antlr4/src/antlr4/error/ErrorStrategy');
 const { InputMismatchException } = require('antlr4/src/antlr4/error/Errors');

package/lib/language/genericAntlrParser.js

@@ -447,6 +447,7 @@ function checkExtensionDict( dict ) {
       for (const prop of Object.keys( dup )) {
         if (prop.charAt(0) === '@') {
           this.addAnnotation( def, prop, dup[prop] );
+          delete dup[prop]; // we want to keep $duplicates, but not have duplicate props
         }
         else if (prop === 'doc') {
           // With explicit docComment:false, we don't emit a warning.
@@ -455,11 +456,13 @@ function checkExtensionDict( dict ) {
                           'Doc comment is overwritten by another one below' );
           }
           def.doc = dup.doc;
+          delete dup[prop]; // we want to keep $duplicates for LSP, but not have duplicate props
         }
         else if (extensionDicts[prop]) {
           if (def[prop])
             this.message( 'syntax-duplicate-annotate', [ def.name.location ], { name, prop } );
           def[prop] = dup[prop]; // continuation semantics: last wins
+          delete dup[prop]; // we want to keep $duplicates for LSP, but not have duplicate props
         }
       }
       if (dup.$annotations) {   // update deprecated $annotations for cds-lsp / annotation modeler
@@ -469,7 +472,9 @@ function checkExtensionDict( dict ) {
           def.$annotations = dup.$annotations;
       }
     }
-    def.$duplicates = null;
+
+    // We keep duplicate statements for LSP, as it needs to traverse all identifiers;
+    // annotations were removed above to avoid traversing annotations twice.
   }
 }
 
@@ -709,14 +714,26 @@ function docComment( node ) {
   node.doc = this.valueWithTokenLocation( val, token );
 }
 
-// Classify token (identifier category) for implicit names,
-// to be used in the empty alternative to AS <explicitName>.
-function classifyImplicitName( category, ref, tokpos = 1 ) {
-  if (!ref || ref.path && this.getCurrentToken().text !== '.') {
-    const implicit = this._input.LT( tokpos - 1 || -1 );
-    if (implicit.isIdentifier)
+/**
+ * Classify token (identifier category) for implicit names. To be used in the
+ * empty alternative to AS <explicitName>.  If `ref` is given, uses the last
+ * path segment's `tokenIndex`.  The return value can be used to reset the
+ * token's category, e.g. for inline select items.
+ *
+ * @param {string} category
+ * @param [ref]
+ */
+function classifyImplicitName( category, ref ) {
+  if (!ref || ref.path) {
+    const tokenIndex = ref?.path[ref.path.length - 1]?.location.tokenIndex;
+    const implicit = (tokenIndex === undefined) ? this._input.LT(-1) : this._input.get(tokenIndex);
+    if (implicit.isIdentifier) {
+      const previous = implicit.isIdentifier;
       implicit.isIdentifier = category;
+      return { token: implicit, previous };
+    }
   }
+  return null;
 }
 
 function fragileAlias( ast, safe = false ) {
@@ -942,8 +959,7 @@ function numberLiteral( sign, text = this._input.LT(-1).text ) {
       token.stop + 1 === nextToken.start &&
       (nextToken.type === this.constructor.Identifier ||
        nextToken.type < this.constructor.Identifier && /^[a-z]+$/i.test( nextToken.text ))) {
-    // TODO: Make it an error in v5
-    this.warning('syntax-expecting-space', nextToken, {},
+    this.message('syntax-expecting-space', nextToken, {},
                  'Expecting a space between a number and a keyword/identifier');
   }
 
@@ -1111,7 +1127,8 @@ function pushItem( array, val ) {
 
 // For :param, #variant, #symbol, @(…) and @Begin and `@` inside annotation paths
 function reportUnexpectedSpace( prefix = this._input.LT(-1),
-                                location = this.tokenLocation( this._input.LT(1) ) ) {
+                                location = this.tokenLocation( this._input.LT(1) ),
+                                isError = false ) {
   const prefixLoc = this.tokenLocation( prefix );
   if (prefixLoc.endLine !== location.line ||
       prefixLoc.endCol !== location.col) {
@@ -1122,8 +1139,14 @@ function reportUnexpectedSpace( prefix = this._input.LT(-1),
       endLine: location.line,
       endCol: location.col,
     };
-    this.warning( 'syntax-unexpected-space', wsLocation, { op: prefix.text },
-                  'Delete the whitespace after $(OP)' );
+    if (isError) {
+      this.message( 'syntax-invalid-space', wsLocation, { op: prefix.text },
+                    'Delete the whitespace after $(OP)' );
+    }
+    else {
+      this.warning( 'syntax-unexpected-space', wsLocation, { op: prefix.text },
+                    'Delete the whitespace after $(OP)' );
+    }
   }
   return prefixLoc;
 }

package/lib/language/multiLineStringParser.js

@@ -256,7 +256,7 @@ class MultiLineStringParser {
     try {
       this.output.push(String.fromCodePoint(n));
     }
-    catch (e) {
+    catch {
       // RangeError is thrown if number isn't a valid code point
       reportInvalidCodePoint();
     }
@@ -484,7 +484,7 @@ class MultiLineStringParser {
    * @param {string} code
    * @private
    */
-  _makeCode(code) { // eslint-disable-line class-methods-use-this
+  _makeCode(code) {
     // For characters that may be rendered as newline,
     // see <https://www.unicode.org/reports/tr14/tr14-32.html>.
     //
@@ -500,6 +500,7 @@ class MultiLineStringParser {
     //
     // For Visualization, see <https://en.wikipedia.org/wiki/Newline#Unicode>
     //   U+23CE: ⏎
+    // eslint-disable-next-line no-control-regex
     const allNewLineCharacters = /[\u{000A}\u{000B}\u{000C}\u{000D}\u{0085}\u{2028}\u{2029}]/ug;
     return code.replace(allNewLineCharacters, '\u{23CE}');
   }

package/lib/language/textUtils.js

@@ -1,6 +1,7 @@
 'use strict';
 
 /** Whitespace characters without line-breaks. */
+// eslint-disable-next-line no-control-regex
 const whitespaceRegEx = /[\t\u{000B}\u{000C} \u{00A0}\u{FEFF}\p{Zs}]/u;
 const cdlNewLineRegEx = /\r\n?|\n|\u2028|\u2029/u;
 

package/lib/main.d.ts

@@ -68,18 +68,22 @@ declare namespace compiler {
      *                additional "extend" or "annotate" statements, but not suitable
      *                for consumption by clients or backends.
      *  - universal : In development (BETA)
+     *
+     * @default 'client'
      */
     csnFlavor?: string | 'client' | 'gensrc' | 'universal'
     /**
-     * If set, backends will not create localized convenience views for those views,
-     * that only have an association to a localized entity/view.  Views will only get
-     * a convenience view, if they themselves contain localized elements (i.e. either
+     * If set to false, backends will create localized convenience views for those views,
+     * that only have an association to a localized entity/view.  If set to true, views will
+     * only get a convenience view, if they themselves contain localized elements (i.e. either
      * have simple projection on localized elements and CDL-casts to a localized element).
      *
-     * The OData backend will not set `$localized: true` markers for such cases.
+     * If true, the OData backend will not set `$localized: true` markers for such cases.
      *
      * Does not work for backends to.hdi(), to.hdbcds() or to.sql() with `sqlDialect: 'hana'`,
      * since in all those dialects, associations still exist in generated artifacts.
+     *
+     * @default true
      */
     fewerLocalizedViews?: boolean
   }
@@ -698,10 +702,6 @@ declare namespace compiler {
    * @param config.noMessageId
    *     If true, will _not_ show the message ID (+ explanation hint) in the output.
    *
-   * @param config.idInBrackets
-   *     If true, the message ID (if there is one and noMessageId is falsey) will be put in brackets.
-   *     This will be the default in cds-compiler v5.
-   *
    * @param config.noHome
    *     If true, will _not_ show message's semantic location.
    *
@@ -714,7 +714,6 @@ declare namespace compiler {
   export function messageString(msg: CompileMessage, config?: {
     normalizeFilename?: boolean
     noMessageId?: boolean
-    idInBrackets?: boolean
     noHome?: boolean
     module?: string
   }): string;
@@ -1379,6 +1378,26 @@ declare namespace compiler {
      * @private
      */
     function getArtifactName(artifact: object): object;
+
+    type LspSemanticTokenEvent = {
+      event: 'reference' | 'definition',
+      semanticToken: object,
+      hint?: string
+      node?: object
+    }
+    /**
+     * Traverse the given XSN model and yield all _semantic tokens_ that are required by
+     * the LSP.  These semantic tokens mostly include _identifiers_, that is, references
+     * or definitions.  They also include the `returns` structure, as it is an annotation
+     * target as well.
+     */
+    function traverseSemanticTokens(xsn: object, options: CompileOptions): Generator<LspSemanticTokenEvent>;
+    /**
+     * Given an XSN reference object, e.g. the `semanticToken` value of a `traverseSemanticTokens`
+     * event, return a generator that yields the reference's target and their origins until the
+     * base definition is reached.
+     */
+    function getSemanticTokenOrigin(obj: LspSemanticTokenEvent): Generator<object>;
   }
 
   /**

package/lib/main.js

@@ -29,11 +29,9 @@ const define = lazyload('./compiler/define');
 const builtins = lazyload('./base/builtins');
 const base = lazyload('./compiler/base');
 const finalizeParseCdl = lazyload('./compiler/finalize-parse-cdl');
+const lsp = lazyload('./compiler/lsp-api');
+const meta = lazyload('./base/meta');
 
-// The compiler version (taken from package.json)
-function version() {
-  return require('../package.json').version;
-}
 
 const toCsn = lazyload('./json/to-csn')
 
@@ -75,7 +73,7 @@ function parseExpr( cdlSource, filename = '<expr>.cds', options = {} ) {
 // ATTENTION: Keep in sync with main.d.ts!
 module.exports = {
   // Compiler
-  version,
+  version: () => meta.version(),
   compile: (filenames, dir, options, fileCache) => { // main function
     traceApi( 'compile', options );
     return compiler.compileX(filenames, dir, options, fileCache).then(toCsn.compactModel);
@@ -94,7 +92,7 @@ module.exports = {
       value: messages.CompilationError,
       writable: false,
       configurable: false,
-      enumerable: false
+      enumerable: true
     });
     return messages.CompilationError;
   },
@@ -183,7 +181,9 @@ module.exports = {
   $lsp: {
     parse: (...args) => compiler.parseX(...args),
     compile: (...args) => compiler.compileX(...args),
-    getArtifactName: (...args) => base.getArtifactName(...args),
+    getArtifactName: (art) => base.getArtifactName(art),
+    traverseSemanticTokens: (xsn, options) => lsp.traverseSemanticTokens(xsn, options),
+    getSemanticTokenOrigin: (obj) => lsp.getSemanticTokenOrigin(obj),
   },
 
   // CSN Model related functionality
@@ -201,7 +201,7 @@ module.exports = {
 function lazyload(moduleName) {
   let module;
   return new Proxy(((...args) => {
-    if (!module) // eslint-disable-next-line global-require
+    if (!module)
       module = require(moduleName);
 
     if (module.apply && typeof module.apply === 'function')
@@ -209,7 +209,7 @@ function lazyload(moduleName) {
     return module; // for destructured calls
   }), {
     get(target, name) {
-      if (!module) // eslint-disable-next-line global-require
+      if (!module)
         module = require(moduleName);
 
       return module[name];

package/lib/model/cloneCsn.js

@@ -30,6 +30,7 @@ const internalCsnProps = {
   $tableConstraints: shallowCopy,
   $default: shallowCopy, // used for HANA CSN migrations
   $notNull: shallowCopy, // used for HANA CSN migrations
+  $sqlService: shallowCopy,
 };
 const internalEnumerableCsnProps = {
   __proto__: null,

package/lib/model/csnRefs.js

@@ -448,7 +448,7 @@ function csnRefs( csn, universalReady ) {
     if (!step)
       return null;
     if (!effectiveType( art ))
-      throw new TypeError( 'Cyclic type definition' );
+      throw new ModelError( 'Cyclic type definition' );
     if (typeof step === 'string')
       return navigationEnv( art, true ).elements[step];
 
@@ -511,6 +511,8 @@ function csnRefs( csn, universalReady ) {
 
   function initNode( art, parent, kind, name ) {
     setCache( art, '_parent', parent );
+    if (art.keys)
+      setCache(art, '_keys', getKeysDict( art ));
     if (kind === 'target') {
       // Prevent re-initialization of anonymous aspect with initDefinition():
       // (that would be with parent: null which would be wrong)
@@ -650,9 +652,12 @@ function csnRefs( csn, universalReady ) {
           return resolvePath( path, elemParent.elements[head], null, 'query' );
       }
       if (!query) {                // outside queries - TODO: items?
-        let art = parent.elements[head];
-        // Ref to up_ in anonymous aspect
-        if (!art && head === 'up_') {
+        let art = parent.elements?.[head];
+        if (parent.keys) {
+          const keysDict = getCache( parent, '_keys' );
+          art = keysDict[head];
+        } // Ref to up_ in anonymous aspect
+        else if (!art && head === 'up_') {
           const up = getCache( parent, '_parent' );
           const target = up && typeof up.target === 'string' && csn.definitions[up.target];
           if (target && target.elements) {
@@ -989,6 +994,17 @@ function csnRefs( csn, universalReady ) {
   }
 }
 
+/**
+ * Foreign keys are stored in an array; for easier name resolution, create
+ * a dictionary of them.
+ */
+function getKeysDict( art ) {
+  const dict = Object.create(null);
+  for (const key of art.keys)
+    dict[key.as || implicitAs( key.ref )] = key;
+  return dict;
+}
+
 /**
  * Return value of a query SELECT for the query node, or the main artifact,
  * i.e. a value with an `elements` property.
@@ -1180,7 +1196,7 @@ function analyseCsnPath( csnPath, csn, resolve ) {
 
     const prop = csnPath[index];
     if (refCtx === 'annotation' && typeof obj === 'object') {
-      // we do not know yet whether the annotation value is a expression or not →
+      // we do not know yet whether the annotation value is an expression or not →
       // loop over outer array and records (structure values):
       if (Array.isArray( obj ) || !isAnnotationExpression( obj )) {
         obj = obj[prop];
@@ -1308,6 +1324,7 @@ module.exports = {
   traverseQuery,
   artifactProperties,
   implicitAs,
+  getKeysDict,
   analyseCsnPath,
   pathId,
   columnAlias,

package/lib/model/csnUtils.js

@@ -12,7 +12,6 @@ const { isBuiltinType, isAnnotationExpression } = require('../base/builtins');
 const { ModelError, CompilerAssertion } = require('../base/error');
 const { typeParameters } = require('../compiler/builtins');
 const { forEach } = require('../utils/objectUtils');
-const { version } = require('../../package.json');
 const { cloneAnnotationValue } = require('./cloneCsn');
 
 // Low-level utility functions to work with compact CSN.
@@ -706,7 +705,6 @@ function isEdmPropertyRendered( elementCsn, options ) {
  * @param {('sqlite'|'hana'|'plain'|string)} [sqlDialect='plain'] The SQL dialect to use
  * @returns {string} The resulting database name for (absolute) 'artifactName', depending on the current naming mode.
  */
-// eslint-disable-next-line no-unused-vars
 function getArtifactDatabaseNameOf( artifactName, sqlMapping, csn, sqlDialect = 'plain' ) {
   if (csn && typeof csn === 'object' && csn.definitions) {
     isValidMappingDialectCombi(sqlDialect, sqlMapping);
@@ -826,7 +824,6 @@ function isValidMappingDialectCombi( sqlDialect, sqlMapping ) {
  * @param {('sqlite'|'hana'|'plain'|string)} [sqlDialect='plain'] The SQL dialect to use
  * @returns {string} The resulting database element name for 'elemName', depending on the current naming mode.
  */
-// eslint-disable-next-line no-unused-vars
 function getElementDatabaseNameOf( elemName, sqlMapping, sqlDialect = 'plain' ) {
   isValidMappingDialectCombi(sqlDialect, sqlMapping);
   if (sqlMapping === 'hdbcds')
@@ -948,16 +945,6 @@ function isPersistedAsTable( artifact ) {
       !hasAnnotationValue(artifact, '@cds.persistence.exists');
 }
 
-/**
- * Central generated by cds-compiler string generator function without further decoration
- *  for unified tagging of generated content
- *
- * @returns {string} String containing compiler version that was used to generate content
- */
-function generatedByCompilerVersion() {
-  return `generated by cds-compiler version ${ version }`;
-}
-
 /**
  * Return the projection to look like a query.
  *
@@ -1440,7 +1427,6 @@ module.exports = {
   isPersistedOnDatabase,
   isPersistedAsView,
   isPersistedAsTable,
-  generatedByCompilerVersion,
   getNormalizedQuery,
   getRootArtifactName,
   getLastPartOfRef,

package/lib/model/revealInternalProperties.js

@@ -73,7 +73,6 @@ function revealInternalProperties( model, nameOrPath ) {
     artifacts: artifactDictionary,
     definitions: artifactDictionary,
     vocabularies: dictionary,
-    $lateExtensions: dictionary,
     elements,
     columns,
     expand: columns,
@@ -385,7 +384,7 @@ function quoted( name, undef = '‹undefined›' ) {
 // To be used for tracing, e.g. by
 // require('../model/revealInternalProperties').log(model, 'E_purposes')
 function logXsnModel( model, name ) {
-  // eslint-disable-next-line no-console, global-require
+  // eslint-disable-next-line no-console
   console.log( require('util').inspect( revealInternalProperties( model, name ), false, null ) );
 }
 

package/lib/modelCompare/compare.js

@@ -67,7 +67,7 @@ function validateCsnVersions(beforeModel, afterModel, options) {
   }
   if (beforeVersionParts[0] > afterVersionParts[0] && !(options && options.allowCsnDowngrade)) {
     const { error, throwWithAnyError } = makeMessageFunction(afterModel, options, 'modelCompare');
-    // eslint-disable-next-line global-require
+
     const { version } = require('../../package.json');
     error(null, null, { value: afterVersion, othervalue: beforeVersion, version },
           'Incompatible CSN versions: $(VALUE) is a major downgrade from $(OTHERVALUE). Is @sap/cds-compiler version $(VERSION) outdated?');
@@ -257,17 +257,19 @@ function getExtensionAndMigrations(beforeModel, options, {
 function getDeletions(afterModel, options, { deletions }) {
   return function compareArtifacts(artifact, name) {
     const otherArtifact = afterModel.definitions[name];
-    const isPersisted = isPersistedAsTable(artifact);
-    const isPersistedOther = otherArtifact && isPersistedAsTable(otherArtifact);
-
-    // Looking for deleted entities only.
-    if (isPersisted && !isPersistedOther) {
+    const isPersistedTable = isPersistedAsTable(artifact);
+    const isPersistedView = isPersistedAsView(artifact);
+    const isPersistedTableOther = otherArtifact && isPersistedAsTable(otherArtifact);
+    const isPersistedViewOther = otherArtifact && isPersistedAsView(otherArtifact);
+
+    // Looking for deleted entities or table -> view / view -> table
+    if (
+      (isPersistedTable && isPersistedViewOther) || // table -> view
+      (isPersistedView && isPersistedTableOther) || // view -> table
+      ((isPersistedTable || isPersistedView) && // deleted
+        !(isPersistedTableOther || isPersistedViewOther))
+    ) // view turned into table - need to render a drop for the view
       deletions[name] = artifact;
-    }
-    // eslint-disable-next-line sonarjs/no-duplicated-branches
-    else if (isPersistedAsView(artifact) && isPersistedOther) { // view turned into table - need to render a drop for the view
-      deletions[name] = artifact;
-    }
   };
 }