@sap/cds-compiler 4.7.4 → 4.8.0

package/lib/checks/validator.js

@@ -75,7 +75,7 @@ const forRelationalDBArtifactValidators = [
   // sql.prepend/append
   checkSqlAnnotationOnArtifact,
   // strip down CSN to reduce it's size by removing non-sql relevant parts
-  stripNonDbRelevant,
+  deleteBoundActions,
 ];
 
 const forRelationalDBCsnValidators = [
@@ -282,33 +282,17 @@ function forOdata( csn, that ) {
                    });
 }
 
-const dbRelevantKinds = {
-  entity: true,
-  type: true,
-  aspect: true,
-  service: true,
-  context: true,
-};
-
 /**
  * Shrink the CSN by
  * - deleting bound actions
- * - turning all non-entity/type/aspect/service/context entities into dummies
+ *
+ * Artifacts can only be shrunk later, when types are resolved
  *
  * @param {CSN.Artifact} artifact
- * @param {string} artifactName
  */
-function stripNonDbRelevant( artifact, artifactName ) {
-  if (this.options.transformation !== 'effective') {
-    if ( !dbRelevantKinds[artifact.kind] ) {
-      this.csn.definitions[artifactName] = {
-        kind: 'action',
-      };
-    }
-    else if (artifact.actions) {
-      delete artifact.actions;
-    }
-  }
+function deleteBoundActions( artifact ) {
+  if (this.options.transformation !== 'effective')
+    delete artifact.actions;
 }
 
 module.exports = { forRelationalDB, forOdata };

package/lib/compiler/assert-consistency.js

@@ -66,10 +66,9 @@
 
 'use strict';
 
+const { Location } = require('../base/location');
 const { locationString, hasErrors } = require('../base/messages');
-const {
-  XsnSource, XsnName, XsnArtifact, CsnLocation,
-} = require('./classes');
+const { XsnSource, XsnName, XsnArtifact } = require('./xsn-model');
 
 
 // Properties that can appear where a type can have type arguments.
@@ -135,7 +134,7 @@ function assertConsistency( model, stage ) {
       // with syntax errors (currently even internal artifacts like $using):
       isRequired: parent => noSyntaxErrors() || parent && parent.kind,
       kind: true,
-      instanceOf: CsnLocation,
+      instanceOf: Location,
       requires: [ 'file' ],     // line is optional in top-level location
       optional: [ 'line', 'col', 'endLine', 'endCol', '$notFound' ],
       schema: {
@@ -317,7 +316,6 @@ function assertConsistency( model, stage ) {
           'kind', 'name', '_block', '_parent', '_main', 'elements',
           '_effectiveType', '$effectiveSeqNo', '_origin', '_joinParent', '$joinArgsIndex',
           '$duplicates', // duplicate query in FROM clause
-          '$inferred', // table alias with $inferred: '$internal'
         ],
       },
       none: { optional: () => true }, // parse error

package/lib/compiler/builtins.js

@@ -64,18 +64,6 @@ const typeParameters = {
 // a.k.a "typeProperties"
 typeParameters.list = Object.keys( typeParameters.expectedLiteralsFor );
 
-/**
- * Properties that are required next to `=` to make an annotation value an actual expression
- * and not some foreign structure.
- *
- * @type {string[]}
- */
-const xprInAnnoProperties = [
-  'ref', 'xpr', 'list', 'literal', 'val',
-  '#', 'func', 'args', 'SELECT', 'SET',
-  'cast',
-];
-
 
 // const hana = {
 //   BinaryFloat: {},
@@ -87,15 +75,6 @@ const xprInAnnoProperties = [
 //   hana: { kind: 'context' },
 // };
 
-/**
- * Functions without parentheses in CDL (common standard SQL-92 functions)
- * (do not add more - make it part of the SQL renderer to remove parentheses for
- * other funny SQL functions like CURRENT_UTCTIMESTAMP).
- */
-const functionsWithoutParens = [
-  'CURRENT_DATE', 'CURRENT_TIME', 'CURRENT_TIMESTAMP',
-  'CURRENT_USER', 'SESSION_USER', 'SYSTEM_USER',
-];
 
 const specialFunctions = compileFunctions( {
   '': [                         // the default
@@ -317,13 +296,6 @@ function checkDate( year, month, day ) {
   return !Number.isNaN( year ) && month > 0 && month < 13 && day > 0 && day < 32;
 }
 
-/**
- * Return whether JSON object `val` is a representation for an annotation expression
- */
-function isAnnotationExpression( val ) {
-  return val?.['='] !== undefined && xprInAnnoProperties.some( prop => val[prop] !== undefined );
-}
-
 /**
  * Check that the given time is within boundaries.
  * Checks according to ISO 8601.
@@ -371,44 +343,6 @@ function isGeoTypeName( typeName ) {
   return typeCategories.geo.includes( typeName );
 }
 
-/**
- * Checks whether the given absolute path is inside a reserved namespace.
- *
- * @param {string} absolute
- * @returns {boolean}
- */
-function isInReservedNamespace( absolute ) {
-  return absolute === 'cds' || absolute.startsWith( 'cds.' ) &&
-    !absolute.match( /^cds\.foundation(\.|$)/ ) &&
-    !absolute.match( /^cds\.outbox(\.|$)/ ) && // Requested by Node runtime
-    !absolute.match( /^cds\.xt(\.|$)/ ); // Requested by Mtx
-}
-
-/**
- * Tell if a type is (directly) a builtin type
- * Note that in CSN builtins are not in the definition of the model, so we can only
- * check against their absolute names.  Builtin types are "cds.<something>", i.e. they
- * are directly in 'cds', but not for example in 'cds.foundation'.
- *
- * TODO: Handle `{ ref: [ "cds.Integer" ] }`
- *
- * @param {string} type
- * @returns {boolean}
- */
-function isBuiltinType( type ) {
-  return typeof type === 'string' && isInReservedNamespace( type );
-}
-
-/**
- * Tell if a name is a magic variable
- *
- * @param {string} name
- * @returns {boolean}
- */
-function isMagicVariable( name ) {
-  return typeof name === 'string' && Object.prototype.hasOwnProperty.call(magicVariables, name);
-}
-
 /**
  * Add CDS builtins like the `cds` namespace with types like `cds.Integer` to
  * `definitions` of the XSN model as well as to `$builtins`.
@@ -424,8 +358,6 @@ function initBuiltins( model ) {
 
   // Also add the core artifacts to model.definitions`
   const c = { ...core };
-  if (!isBetaEnabled( model.options, 'vectorType' ))
-    delete c.Vector;
   model.$builtins = env( c, 'cds.', cds );
   model.$builtins.cds = cds;
 
@@ -541,14 +473,8 @@ function initBuiltins( model ) {
 
 module.exports = {
   typeParameters,
-  xprInAnnoProperties,
-  functionsWithoutParens,
   specialFunctions,
   quotedLiteralPatterns,
   initBuiltins,
-  isAnnotationExpression,
-  isInReservedNamespace,
-  isBuiltinType,
-  isMagicVariable,
   isGeoTypeName,
 };

package/lib/compiler/checks.js

@@ -29,7 +29,7 @@ const $location = Symbol.for( 'cds.$location' );
  */
 function check( model ) {
   const {
-    error, warning, info,
+    error, warning, info, message,
   } = model.$messageFunctions;
 
   checkSapCommonLocale( model );
@@ -41,6 +41,7 @@ function check( model ) {
   return;
 
   function checkDefinition( def ) {
+    checkEvent( def );
     checkGenericConstruct( def );
     if (def.includes && def.elements)
       checkElementIncludeOverride( def );
@@ -49,6 +50,16 @@ function check( model ) {
       def.$queries.forEach( checkQuery );
   }
 
+  function checkEvent( def ) {
+    // Ensure that events are structured. Up to compiler v4, we allowed non-structured events,
+    // because when we introduced them, it was not fully specified what they are.
+    // TODO(v5):
+    //  - Make this a (configurable) error; move to acceptTypeOrElement
+    //  - require type/elements to be set in parser
+    if (def.kind === 'event' && !def._effectiveType?.elements && !def._effectiveType?.projection)
+      message( 'def-expected-structured', [ (def.type || def.name).location, def ] );
+  }
+
   function checkAnnotationDefinition( art ) {
     // TODO: Should we check elements similar to definition-elements as well?
     checkEnumType( art );
@@ -61,6 +72,10 @@ function check( model ) {
   function checkGenericConstruct( art ) {
     checkName( art );
     checkTypeArguments( art );
+
+    if (art.value && !art.$calcDepElement && art.type)
+      checkTypeCast( art.value, art );
+
     if (model.vocabularies) {
       Object.keys( art )
         .filter( a => a.startsWith( '@' ) )
@@ -202,13 +217,38 @@ function check( model ) {
     }
   }
 
-  function requireExplicitTypeInSqlCast( art, user ) {
-    if (!art.type) {
-      error( 'expr-missing-type', [ art.location, user ], { },
+  /**
+   * Check the type in an SQL cast expression.
+   *
+   * @param xpr
+   * @param {XSN.Artifact} user
+   */
+  function requireExplicitTypeInSqlCast( xpr, user ) {
+    if (!xpr.type) {
+      error( 'expr-missing-type', [ xpr.location, user ], { },
              'Missing type in SQL cast function' );
     }
   }
 
+  function checkTypeCast( xpr, user ) {
+    const isCast = (xpr.op?.val === 'cast');
+    const elem = isCast
+      ? xpr.args[0]?._artifact
+      : xpr._artifact;
+    const type = isCast ? xpr.type : user.type;
+    if (elem && type) { // has explicit type
+      if (type._artifact?.elements)
+        error( 'type-invalid-cast', [ type.location, user ], { '#': 'to-structure' } );
+      else if (elem.elements) // TODO: calc elements
+        error( 'type-invalid-cast', [ type.location, user ], { '#': 'from-structure' } );
+      else if (elem.target && !type._artifact?.target)
+        error( 'type-invalid-cast', [ type.location, user ], { '#': 'from-assoc' } );
+      else if (!elem.target && type._artifact?.target && !user.type?.$inferred)
+        // $inferred already reported in resolve.js
+        error( 'type-invalid-cast', [ type.location, user ], { '#': 'assoc' } );
+    }
+  }
+
   function checkLocalizedElement( elem ) {
     if (elem.localized?.val) {
       const type = elem._effectiveType;
@@ -340,11 +380,8 @@ function check( model ) {
         .find( name => !enumNode.enum[name].value );
       if (emptyValue) {
         const failedEnum = enumNode.enum[emptyValue];
-        warning( 'type-missing-value', [ failedEnum.location, failedEnum ], {
+        message( 'type-missing-enum-value', [ failedEnum.location, failedEnum ], {
           '#': isNumeric ? 'numeric' : 'std', name: emptyValue,
-        }, {
-          std: 'Missing value for non-string enum element $(NAME)',
-          numeric: 'Missing value for numeric enum element $(NAME)',
         } );
       }
     }
@@ -551,15 +588,26 @@ function check( model ) {
       if (xorElements) {
         // one of the two elements is not structured
         const prop = !elem.elements ? 'new-not-structured' : 'old-not-structured';
-        const name = elem.name.id;
         // Position at type/struct, not name
         const loc = elem.type?.location || elem.elements?.[$location] || elem.location;
         error( 'ref-invalid-override', [ loc, elem ],
-               { '#': prop, art: original._main, name } );
+               { '#': prop, art: original._main, name: elem.name.id } );
         return false;
       }
       else if (original.elements &&
-               !checkSubStructureOverride( elem, elem.elements, original.elements )) {
+        !checkSubStructureOverride( elem, elem.elements, original.elements )) {
+        return false;
+      }
+
+      const xorTarget = !(elem.target || elem.targetAspect) !==
+        !(original.target || original.targetAspect);
+      if (xorTarget) {
+        // one of the two elements is not an association
+        const prop = !elem.target ? 'new-not-target' : 'old-not-target';
+        // Position at type/assoc, not name
+        const loc = elem.target?.location || elem.type?.location || elem.location;
+        error( 'ref-invalid-override', [ loc, elem ],
+               { '#': prop, art: original._main, name: elem.name.id } );
         return false;
       }
       return true;
@@ -599,6 +647,7 @@ function check( model ) {
     checkExpressionAssociationUsage( xpr, user, false );
     if (xpr.op?.val === 'cast') {
       requireExplicitTypeInSqlCast( xpr, user );
+      checkTypeCast( xpr, user );
       checkTypeArguments( xpr, user );
     }
   }
@@ -631,6 +680,7 @@ function check( model ) {
     // the cast, as otherwise we will check it twice (once here, once via element).
     if (elem.value?.op?.val === 'cast' && elem.type?.$inferred !== 'cast') {
       requireExplicitTypeInSqlCast( elem.value, elem );
+      checkTypeCast( elem.value, elem );
       checkTypeArguments( elem.value, elem );
     }
     visitSubExpression( elem.value, elem, (xpr) => {

package/lib/compiler/define.js

@@ -140,7 +140,8 @@ const {
   targetCantBeAspect,
 } = require('./utils');
 const { compareLayer } = require('./moduleLayers');
-const { initBuiltins, isInReservedNamespace } = require('./builtins');
+const { initBuiltins } = require('./builtins');
+const { isInReservedNamespace } = require('../base/builtins');
 
 const $location = Symbol.for( 'cds.$location' );
 const $inferred = Symbol.for( 'cds.$inferred' );
@@ -747,7 +748,6 @@ function define( model ) {
         // We don't worry about duplicate names here.
         const id = `$_select_${ query._main.$queries.length + 1 }__`;
         table.name = { id, location: table.location, $inferred: '$internal' };
-        table.$inferred = '$internal';
       }
       addAsAlias();
       // Store _origin to leading query of table.query for name resolution
@@ -796,7 +796,7 @@ function define( model ) {
       setMemberParent( table, table.name.id, query );
       setLink( table, '_block', query._block );
       dictAdd( query.$tableAliases, table.name.id, table, ( name, loc, tableAlias ) => {
-        if (tableAlias.$inferred === '$internal') {
+        if (tableAlias.name.$inferred === '$internal') {
           const semanticLoc = tableAlias.query?.name ? tableAlias.query : tableAlias;
           // TODO: the semanticLoc query is not initialized yet, and thus cannot
           // be used here

package/lib/compiler/extend.js

@@ -25,12 +25,12 @@ const {
 } = require('./utils');
 const layers = require('./moduleLayers');
 const { CompilerAssertion } = require('../base/error');
-const { CsnLocation } = require('./classes');
+const { Location } = require('../base/location');
 
 const $location = Symbol.for( 'cds.$location' );
 
 // attach stupid location - TODO: remove in v5
-const genLocation = new CsnLocation( '' );
+const genLocation = new Location( '' );
 
 const draftElements = [
   'IsActiveEntity',

package/lib/compiler/index.js

@@ -30,7 +30,7 @@ const tweakAssocs = require('./tweak-assocs');
 const propagator = require('./propagator');
 const check = require('./checks');
 
-const { emptyWeakLocation } = require('../base/location');
+const { Location, emptyWeakLocation } = require('../base/location');
 const { createMessageFunctions, deduplicateMessages } = require('../base/messages');
 const { checkRemovedDeprecatedFlags } = require('../base/model');
 const { promiseAllDoNotRejectImmediately } = require('../base/node-helpers');
@@ -38,7 +38,7 @@ const { cdsFs } = require('../utils/file');
 
 const fs = require('fs');
 const path = require('path');
-const { CsnLocation, XsnSource } = require('./classes');
+const { XsnSource } = require('./xsn-model');
 
 const extensionParsers = {
   csn: parseCsn.parse,
@@ -93,7 +93,7 @@ function parseX( source, filename, options = {}, messageFunctions = null ) {
     return parser( source, filename, options, messageFunctions );
 
   const model = new XsnSource();
-  model.location = new CsnLocation( filename );
+  model.location = new Location( filename );
   messageFunctions.error( 'file-unknown-ext', emptyWeakLocation( filename ),
                           { file: ext, '#': !ext && 'none' }, {
                             std: 'Unknown file extension $(FILE)',
@@ -174,12 +174,12 @@ function compileX( filenames, dir = '', options = {}, fileCache = Object.create(
       return [];                 // no further dependency processing
     // no parallel readAndParse with same resolved filename should read the file,
     // also ensure deterministic sequence in sources:
-    sources[filename] = { location: new CsnLocation( rel ) };
+    sources[filename] = { location: new Location( rel ) };
 
     const source = await cdsFs( fileCache, options.traceFs ).readFileAsync( filename, 'utf8' );
     const ast = parseX( source, rel, options, model.$messageFunctions );
     sources[filename] = ast;
-    ast.location = new CsnLocation( rel );
+    ast.location = new Location( rel );
     ast.dirname = path.dirname( filename );
     assertConsistency( ast, options );
 
@@ -293,7 +293,7 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
     }
     // no parallel readAndParse with same resolved filename should read the file,
     // also ensure deterministic sequence in a.sources:
-    a.sources[filename] = { location: new CsnLocation( rel ) };
+    a.sources[filename] = { location: new Location( rel ) };
 
     cdsFs( fileCache, options.traceFs ).readFileSync( filename, 'utf8', (err, source) => {
       if (err) {
@@ -303,7 +303,7 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
         try {
           const ast = parseX( source, rel, options, model.$messageFunctions );
           a.sources[filename] = ast;
-          ast.location = new CsnLocation( rel );
+          ast.location = new Location( rel );
           ast.dirname = path.dirname( filename );
           assertConsistency( ast, options );
           cb( null, ast );
@@ -374,7 +374,7 @@ function compileSourcesX( sourcesDict, options = {} ) {
     if (typeof source === 'string') {
       const ast = parseX( source, filename, options, model.$messageFunctions );
       sources[filename] = ast;
-      ast.location = new CsnLocation( filename );
+      ast.location = new Location( filename );
       assertConsistency( ast, options );
     }
     else if (options.$xsnObjects) { // source is a XSN object with option $xsnObjects
@@ -383,7 +383,7 @@ function compileSourcesX( sourcesDict, options = {} ) {
     else {                      // source is a CSN object
       const ast = parseCsn.augment( source, filename, options, model.$messageFunctions );
       sources[filename] = ast;
-      ast.location = new CsnLocation( filename );
+      ast.location = new Location( filename );
       assertConsistency( ast, options );
     }
 

package/lib/compiler/populate.js

@@ -633,8 +633,14 @@ function populate( model ) {
   }
 
   function resolveExcluding( name, env, excludingDict, user ) {
-    if (env[name])
+    const found = env[name];
+    if (found) { // set links for LSP; if Array, then via multiple query sources ($navElement)
+      const art = (Array.isArray(found) && found.map(f => f._origin)) ||
+        (found.kind === '$navElement' && found._origin) ||
+        found;
+      setArtifactLink( excludingDict[name].name, art );
       return;
+    }
     /** @type {object} */
     // console.log(name,Object.keys(env),Object.keys(excludingDict))
     const compileMessageRef = info(
@@ -745,7 +751,6 @@ function populate( model ) {
         location: col.value.location || col.location,
         $inferred: '$internal',
       };
-      col.$inferred = '$internal';
       return col.name.id;
     }
     // invent a name for code completion in expression, see also #10596
@@ -880,9 +885,12 @@ function populate( model ) {
     if (envParent || query.kind !== 'select') {
       // already done in populateQuery (TODO: change that and check whether
       // `*` is allowed at all in definer)
-      const user = colParent || query;
-      for (const name in user.excludingDict)
-        resolveExcluding( name, env, excludingDict, query );
+      if (!colParent || colParent.value._artifact) {
+        // avoid "not found" messages if pathHead can't be found
+        const user = colParent || query;
+        for (const name in user.excludingDict)
+          resolveExcluding( name, env, excludingDict, query );
+      }
     }
   }
 

package/lib/compiler/propagator.js

@@ -13,6 +13,7 @@ const {
   forEachMember,
   forEachGeneric,
   isDeprecatedEnabled,
+  isBetaEnabled,
 } = require( '../base/model');
 const {
   setLink,
@@ -77,6 +78,8 @@ function propagate( model ) {
   const { warning, throwWithError } = model.$messageFunctions;
 
   forEachDefinition( model, run );
+  if (isBetaEnabled( model.options, 'v5preview' ))
+    forEachGeneric( model, 'vocabularies', run );
 
   // TODO: move 'virtual' handling/checks to resolver if
   //       'deprecated.oldVirtualNotNullPropagation' is gone

package/lib/compiler/resolve.js

@@ -519,8 +519,6 @@ function resolve( model ) {
     if (art.value) {
       if (art.$syntax === 'calc')
         checkCalculatedElement( art );
-      else if (art.type && !art.$inferred)
-        checkColumnTypeCast( art );
     }
 
     resolveExprInAnnotations( art );
@@ -849,21 +847,6 @@ function resolve( model ) {
     }
   }
 
-  function checkColumnTypeCast( art ) {
-    const elem = (art.value.op?.val === 'cast')
-      ? art.value.args[0]?._artifact
-      : art.value._artifact;
-    if (elem && art.type) { // has explicit type
-      if (art.type._artifact?.elements)
-        error( 'type-invalid-cast', [ art.type.location, art ], { '#': 'to-structure' } );
-      else if (elem.elements) // TODO: calc elements
-        error( 'type-invalid-cast', [ art.type.location, art ], { '#': 'from-structure' } );
-      else if (elem.target && !art.type._artifact?.target)
-        // allow cast to association -> that is already checked and denied elsewhere
-        error( 'type-invalid-cast', [ art.type.location, art ], { '#': 'from-assoc' } );
-    }
-  }
-
   /**
    * Return type containing the assoc spec (keys, on); note that no
    * propagation/rewrite has been done yet, cyclic dependency must have been
@@ -1223,8 +1206,9 @@ function resolve( model ) {
              'Only an association can be redirected' );
       return;
     }
-    else if ((elem.value || elem.expand) && elem.type && !elem.type.$inferred) {
-      error( 'ref-unexpected-assoc', [ elem.type.location, elem ], { '#': 'cast' } );
+    else if ((elem.value || elem.expand) && elem.type &&
+        (!elem.type.$inferred || elem.type.$inferred === 'cast')) {
+      error( 'type-invalid-cast', [ elem.type.location, elem ], { '#': 'assoc' } );
       return;
     }
     // console.log(message( null, elem.location, elem, {target,art:assoc}, 'Info','RE')
@@ -1399,7 +1383,9 @@ function resolve( model ) {
     const alreadyReported = model.$messageFunctions.messages
       .find(msg => msg.messageId === 'anno-experimental-expressions');
     if (!alreadyReported) {
-      info( 'anno-experimental-expressions', [ expr.location ], {
+      // due to test mode and shuffling, we would get a different location on each compilation.
+      const loc = model.options.testMode ? null : [ expr.location ];
+      info( 'anno-experimental-expressions', loc, {
         option: 'annotationExpressions',
         // eslint-disable-next-line max-len
       }, 'Expressions in annotation values are a beta feature. Use at your own risk. (This message can be suppressed with beta flag $(OPTION))' );

package/lib/compiler/shared.js

@@ -710,7 +710,7 @@ function fns( model ) {
     // duplicate table aliases, only mention non-ambiguous source elems
     const uniqueNames = arr.filter( e => !e.$duplicates );
     if (uniqueNames.length) {
-      const names = uniqueNames.filter( e => e._parent.$inferred !== '$internal' )
+      const names = uniqueNames.filter( e => e._parent.name?.$inferred !== '$internal' )
         .map( e => `${ e._parent.name.id }.${ e.name.id }` );
       let variant = names.length === uniqueNames.length ? 'std' : 'few';
       if (names.length === 0)

package/lib/compiler/tweak-assocs.js

@@ -20,7 +20,7 @@ const {
   traverseQueryExtra,
   setExpandStatus,
 } = require('./utils');
-const { CsnLocation } = require('./classes');
+const { Location } = require('../base/location');
 const { CompilerAssertion } = require('../base/error');
 
 const $location = Symbol.for( 'cds.$location' );
@@ -287,7 +287,7 @@ function tweakAssocs( model ) {
       const loc = otherAssoc.foreignKeys[$location] || dictLocation( otherAssoc.foreignKeys );
       const location = loc && (!loc.endCol
         ? loc
-        : new CsnLocation( loc.file, loc.endLine, loc.endCol - 1, loc.endLine, loc.endCol ));
+        : new Location( loc.file, loc.endLine, loc.endCol - 1, loc.endLine, loc.endCol ));
       const baseAssoc = assocWithExplicitSpec( thisAssoc );
       if (inferredForeignKeys( baseAssoc.foreignKeys )) { // still inferred = via target keys
         error( 'rewrite-key-not-covered-implicit', [ location, otherAssoc ],

package/lib/compiler/utils.js

@@ -11,8 +11,8 @@
 'use strict';
 
 const { dictAdd, pushToDict, dictFirst } = require('../base/dictionaries');
-const { weakLocation } = require('../base/location');
-const { XsnName, XsnArtifact, CsnLocation } = require('./classes');
+const { Location, weakLocation } = require('../base/location');
+const { XsnName, XsnArtifact } = require('./xsn-model');
 
 const $inferred = Symbol.for( 'cds.$inferred' );
 
@@ -262,7 +262,7 @@ function copyExpr( expr, location ) {
   const proto = Object.getPrototypeOf( expr );
   if (proto && proto !== Object.prototype && proto !== XsnName.prototype &&
       // do not copy object from special classes outside the compiler domain&&
-      proto !== XsnArtifact.prototype && proto !== CsnLocation.prototype)
+      proto !== XsnArtifact.prototype && proto !== Location.prototype)
     return expr;
   const r = Object.create( proto );
   for (const prop of Object.getOwnPropertyNames( expr )) {

package/lib/compiler/{classes.js → xsn-model.js}

@@ -39,24 +39,8 @@ class XsnName {
   location;
 }
 
-class CsnLocation {
-  file;
-  line;
-  col;
-  endLine;
-  endCol;
-  constructor(file, line, col, endLine, endCol) {
-    this.file = file;
-    this.line = line;
-    this.col = col;
-    this.endLine = endLine;
-    this.endCol = endCol;
-  }
-}
-
 module.exports = {
   XsnSource,
   XsnArtifact,
   XsnName,
-  CsnLocation,
 };