@sap/cds-compiler 2.11.2 → 2.11.4

package/CHANGELOG.md

@@ -7,6 +7,27 @@
 Note: `beta` fixes, changes and features are usually not listed in this ChangeLog but [here](doc/CHANGELOG_BETA.md).
 The compiler behavior concerning `beta` features can change at any time without notice.
 
+## Version 2.11.4 - 2021-12-21
+
+### Fixed
+
+- CDL parser: in many situations, improve message when people use reserved keywords as identifier
+- Improve error text and error location for ambiguious auto-redirection target
+- to.sql/hdi/hdbcds:
+  + Correctly detect `exists` in projections
+  + Correctly handle elements starting with `$` in the on-condition of associations
+  + Correctly handle sub queries in an entity defined with `projection on`
+  + Correctly handle associations in sub queries in a `from` of a sub query
+  + foreign key constraints: respect @assert.integrity: false for compositions
+- to.hdbcds: Correctly quote elements named `$self` and `$projection`
+- to.cdl: `when` was added to the keyword list for smart quoting
+- Compiler support for code completion for `$user` and `$session` now respect user
+  provided variables in `options.variableReplacements`.
+- API: `deduplicateMessages()` no longer removes messages for `duplicate` artifact/annotation errors.
+  Prior to this version, only one of the duplicated artifacts had a message, leaving the user to
+  guess where the other duplicates were.
+
+
 ## Version 2.11.2 - 2021-12-06
 
 ### Fixed
@@ -25,8 +46,8 @@ The compiler behavior concerning `beta` features can change at any time without
   if it can't be assigned to an artifact.  For example for two subsequent doc-comments, the first doc-comment
   is ignored.  To suppress these info messages, explicitly set option `docComment` to `false`.
 - `cdsc`:
-  - `cdsc explain list` can now be used to get a list of message IDs with explanation texts.
-  - `cdsc` now respects the environment variable `NO_COLOR`. If set, no ANSI escape codes will be used.
+  + `cdsc explain list` can now be used to get a list of message IDs with explanation texts.
+  + `cdsc` now respects the environment variable `NO_COLOR`. If set, no ANSI escape codes will be used.
     Can be overwritten by `cdsc --color always`.
 - to.sql/hdi: Support SQL Window Functions
 - to.sql/hdi/hdbcds:

package/bin/.eslintrc.json

@@ -11,7 +11,6 @@
     "no-process-exit": "off",
     "camelcase": "off",
     "radix": "off",
-    // should probably be on
-    "no-shadow": "off"
+    "no-shadow": "warn"
   }
 }

package/bin/cds_update_identifiers.js

@@ -24,6 +24,7 @@
 'use strict';
 
 const parseLanguage = require('../lib/language/antlrParser');
+const { createMessageFunctions } = require('../lib/base/messages');
 
 const fs = require('fs');
 const path = require('path');
@@ -51,10 +52,11 @@ process.exit(0); // success
 
 function modernizeIdentifierStyle(source, filename) {
   const options = { messages: [], attachTokens: true };
+  const messageFunctions = createMessageFunctions( options, 'parse', null );
 
   // parseLanguage does not throw on CompilationError, so
   // we do not need a try...catch block.
-  const ast = parseLanguage(source, filename, options);
+  const ast = parseLanguage(source, filename, options, messageFunctions);
 
   // To avoid spam, only report errors.
   // Users should use the compiler to get all messages.

package/bin/cdsc.js

@@ -161,7 +161,14 @@ try {
       cmdLine.options.assertIntegrity === 'true' ||
       cmdLine.options.assertIntegrity === 'false'
   )
-    cmdLine.options.assertIntegrity = Boolean(cmdLine.options.assertIntegrity);
+    cmdLine.options.assertIntegrity = cmdLine.options.assertIntegrity === 'true';
+
+  // remap string values for `constraintsAsAlter` option to boolean
+  if (cmdLine.options.constraintsAsAlter &&
+    cmdLine.options.constraintsAsAlter === 'true' ||
+    cmdLine.options.constraintsAsAlter === 'false'
+  )
+    cmdLine.options.constraintsAsAlter = cmdLine.options.constraintsAsAlter === 'true';
 
 
   // Enable all beta-flags if betaMode is set to true

package/bin/cdsv2m.js

@@ -34,10 +34,11 @@ function usage( err ) {
 function ria() {
   const annotates = Object.create( null );
   const msgs = options.messages.filter( m => m.messageId === 'redirected-implicitly-ambiguous' );
-  // regex match on message text not for productive code!
+  // 'Choose via $(ANNO) one of $(SORTED_ARTS) as redirection target for $(TARGET) in … $(ART) otherwise'
+  // NOTE: regex match on message text not for productive code!
   for (const msgObj of msgs) {
     const matches = msgObj.message.match( /["“][^"”]+["”]/g );
-    matches.slice(2).forEach( (name) => {
+    matches.slice( 1, -2 ).forEach( (name) => {
       annotates[name.slice( 1, -1 )] = true;
     } );
   }

package/lib/api/main.js

@@ -159,7 +159,7 @@ function cdl(csn, externalOptions = {}) {
  * Transform a CSN like to.sql
  *
  * @param {CSN.Model} csn Plain input CSN
- * @param {sqlOptions} [options={}] Options
+ * @param {SqlOptions} [options={}] Options
  * @returns {CSN.Model} CSN transformed like to.sql
  * @private
  */
@@ -202,7 +202,7 @@ function forHdbcds(csn, options = {}) {
  * Process the given CSN into SQL.
  *
  * @param {CSN.Model} csn A clean input CSN
- * @param {sqlOptions} [options={}] Options
+ * @param {SqlOptions} [options={}] Options
  * @returns {SQL[]} Array of SQL statements, tables first, views second
  */
 function sql(csn, options = {}) {
@@ -733,20 +733,6 @@ function publishCsnProcessor( processor, _name ) {
  * @property {Array} [messages] Allows collecting all messages in the options instead of printing them to stderr.
  */
 
-/**
- * Options available for to.sql
- *
- * @typedef {object} sqlOptions
- * @property {NamingMode} [sqlMapping='plain'] Naming mode to use
- * @property {SQLDialect} [sqlDialect='sqlite'] SQL dialect to use
- * @property {object} [variableReplacements] Object containing values for magic variables like "$user"
- * @property {string} [variableReplacements.$user.locale] Value for the "$user.locale" variable
- * @property {string} [variableReplacements.$user.id] Value for the "$userid" variable
- * @property {object} [beta] Enable experimental features - not for productive use!
- * @property {boolean} [longAutoexposed=false] Deprecated: Produce long names (with underscores) for autoexposed entities
- * @property {Map<string, number>} [severities={}] Map of message-id and severity that allows setting the severity for the given message
- * @property {Array} [messages] Allows collecting all messages in the options instead of printing them to stderr.
- */
 
 /**
  * A fresh (just compiled, not transformed) CSN

package/lib/api/options.js

@@ -49,6 +49,7 @@ const privateOptions = [
   'traceParserAmb',
   'testMode',
   'testSortCsn',
+  'constraintsAsAlter',
   'integrityNotEnforced',
   'integrityNotValidated',
   'assertIntegrity',
@@ -157,7 +158,7 @@ module.exports = {
     sql: (options) => {
       const hardOptions = { src: 'sql' };
       const defaultOptions = { sqlMapping: 'plain', sqlDialect: 'plain' };
-      const processed = translateOptions(options, defaultOptions, hardOptions, undefined, [ 'sql-dialect-and-naming' ], 'to.sql');
+      const processed = translateOptions(options, defaultOptions, hardOptions, undefined, [ 'sql-dialect-and-naming', 'constraints-as-alter-sqlite' ], 'to.sql');
 
       const result = Object.assign({}, processed);
       result.toSql = Object.assign({}, processed);
@@ -165,7 +166,7 @@ module.exports = {
       return result;
     },
     hdi: (options) => {
-      const hardOptions = { src: 'hdi' };
+      const hardOptions = { src: 'hdi', constraintsAsAlter: false };
       const defaultOptions = { sqlMapping: 'plain', sqlDialect: 'hana' };
       const processed = translateOptions(options, defaultOptions, hardOptions, { sqlDialect: generateStringValidator([ 'hana' ]) }, undefined, 'to.hdi');
 

package/lib/api/validate.js

@@ -25,13 +25,14 @@ const booleanValidator = {
 /**
  * Generate a Validator that validates that the
  * input is a string and one of the available options.
+ * The validation of the option values is case-insensitive.
  *
  * @param {any} availableValues Available values
  * @returns {Validator} Return a validator for a string in an expected range
  */
 function generateStringValidator(availableValues) {
   return {
-    validate: val => typeof val === 'string' && availableValues.indexOf(val) !== -1,
+    validate: val => typeof val === 'string' && availableValues.some( av => av.toLowerCase() === val.toLowerCase() ),
     expected: (val) => {
       return typeof val !== 'string' ? 'type string' : availableValues.join(', ');
     },
@@ -141,6 +142,11 @@ const allCombinationValidators = {
     severity: 'warning',
     getMessage: () => 'Option "beta" was used. This option should not be used in productive scenarios!',
   },
+  'constraints-as-alter-sqlite': {
+    validate: options => options.constraintsAsAlter && options.sqlDialect && options.sqlDialect === 'sqlite',
+    severity: 'warning',
+    getMessage: options => `Option 'constraintsAsAlter' is ignored for sqlDialect '${ options.sqlDialect }'`,
+  },
 };
 /* eslint-disable jsdoc/no-undefined-types */
 /**

package/lib/backends.js

@@ -303,9 +303,9 @@ function transformSQLOptions(model, options) {
     }
     // move the locale option(if provided) under user.locale
     if (options.locale) {
-      options.user
+      options.user = options.user
         ? Object.assign(options.user, { locale: options.locale })
-        : options.user = { locale: options.locale };
+        : { locale: options.locale };
       delete options.locale;
     }
   }
@@ -395,12 +395,10 @@ function toRenameWithCsn(csn, options) {
   });
 
   // Assemble result
-  let result = {
+  return {
     rename : toRenameDdl(forHanaCsn, options),
     options
   };
-
-  return result;
 }
 
 function alterConstraintsWithCsn(csn, options) {

package/lib/base/keywords.js

@@ -11,7 +11,7 @@ module.exports = {
     'DISTINCT',
     'EXISTS',
     'EXTRACT',
-    'FALSE',
+    'FALSE', // boolean
     'FROM',
     'IN',
     'KEY',
@@ -22,8 +22,9 @@ module.exports = {
     'ON',
     'SELECT',
     'SOME',
+    'WHEN',
     'TRIM',
-    'TRUE',
+    'TRUE', // boolean
     'WHERE',
     'WITH',
   ],

package/lib/base/message-registry.js

@@ -47,6 +47,7 @@ const centralMessages = {
   'anno-undefined-def':     { severity: 'Info' }, // for annotate statement (for CSN or CDL path cont)
   'anno-undefined-element': { severity: 'Info' },
   'anno-undefined-param':   { severity: 'Info' },
+  'anno-unstable-hdbcds':   { severity: 'Warning' },
 
   'args-expected-named':  { severity: 'Error', configurableFor: 'deprecated' }, // future --sloppy
   'args-no-params':       { severity: 'Error', configurableFor: 'deprecated' }, // future --sloppy
@@ -60,7 +61,6 @@ const centralMessages = {
 
   'expr-no-filter': { severity: 'Error', configurableFor: 'deprecated' },
 
-  'empty-entity': { severity: 'Info', errorFor: [ 'to.hdbcds', 'to.sql', 'to.rename' ] },
   'empty-type':   { severity: 'Info' }, // only still an error in old transformers
 
   // Structured types were warned about but made CSN un-recompilable.
@@ -69,7 +69,7 @@ const centralMessages = {
   // TODO: rename to ref-expected-XYZ
   'expected-type': { severity: 'Error' },
   'ref-sloppy-type': { severity: 'Error' },
-  'ref-invalid-typeof': { severity: 'Error', configurableFor: 'deprecated' }, // TODO: make it non-config
+  'type-unexpected-typeof': { severity: 'Error', configurableFor: 'deprecated' }, // TODO: make it non-config
   'expected-actionparam-type': { severity: 'Error' },
   'ref-sloppy-actionparam-type': { severity: 'Error' },
   'expected-event-type': { severity: 'Error' },
@@ -89,6 +89,7 @@ const centralMessages = {
   'query-undefined-element': { severity: 'Error' },
   'query-unexpected-assoc-hdbcds': { severity: 'Error' },
   'query-unexpected-structure-hdbcds': { severity: 'Error' },
+  'query-ignoring-param-nullability': { severity: 'Info' },
 
   'recalculated-localized': { severity: 'Info' }, // KEEP: Downgrade in lib/transform/translateAssocsToJoins.js
   'redirected-implicitly-ambiguous': { severity: 'Error', configurableFor: true }, // does not hurt us - TODO: ref-ambiguous-target
@@ -99,6 +100,7 @@ const centralMessages = {
   'ref-undefined-def':    { severity: 'Error' },
   'ref-undefined-var':    { severity: 'Error' },
   'ref-undefined-element': { severity: 'Error' },
+  'ref-unknown-var': { severity: 'Info' },
   'ref-obsolete-parameters': { severity: 'Error', configurableFor: true }, // does not hurt us
   'ref-undefined-param': { severity: 'Error' },
   'ref-rejected-on': { severity: 'Error' },
@@ -128,6 +130,8 @@ const centralMessages = {
 
   'type-managed-composition': { severity: 'Error', configurableFor: 'deprecated' }, // TODO: non-config
 
+  'def-missing-element': { severity: 'Error' },
+
   'unexpected-keys-for-composition': { severity: 'Error' }, // TODO: more than 30 chars
   'unmanaged-as-key': { severity: 'Error', configurableFor: 'deprecated' }, // is confusing
   'composition-as-key': { severity: 'Error', configurableFor: 'deprecated' }, // is confusing and not supported
@@ -178,17 +182,20 @@ const centralMessageTexts = {
     std: 'Element $(ART) has not been found',
     element: 'Artifact $(ART) has no element $(MEMBER)'
   },
+  'ref-unknown-var': {
+    std: 'Replacement $(ID) not found'
+  },
   'ref-rejected-on': {
     std: 'Do not refer to a artefact like $(ID) in the explicit ON of a redirection', // Not used
     mixin: 'Do not refer to a mixin like $(ID) in the explicit ON of a redirection',
     alias: 'Do not refer to a source element (via table alias $(ID)) in the explicit ON of a redirection',
   },
-  'ref-invalid-typeof': {
-    std: 'Do not use $(KEYWORD) for the type reference here',
-    type: 'Do not use $(KEYWORD) for the type of a type',
-    event: 'Do not use $(KEYWORD) for the type of an event',
-    param: 'Do not use $(KEYWORD) for the type of a parameter',
-    select: 'Do not use $(KEYWORD) for type references in queries',
+  'type-unexpected-typeof': {
+    std: 'Unexpected $(KEYWORD) for the type reference here',
+    type: 'Unexpected $(KEYWORD) in type of a type definition',
+    event: 'Unexpected $(KEYWORD) for the type of an event',
+    param: 'Unexpected $(KEYWORD) for the type of a parameter definition',
+    select: 'Unexpected $(KEYWORD) for type references in queries',
   },
   'anno-builtin': 'Builtin types should not be annotated. Use custom type instead',
   'anno-undefined-def': 'Artifact $(ART) has not been found',
@@ -207,6 +214,11 @@ const centralMessageTexts = {
     param: 'Artifact $(ART) has no parameter $(MEMBER)'
   },
 
+  'def-missing-element': {
+    std: 'Expecting entity to have at least one non-virtual element',
+    view: 'Expecting view to have at least one non-virtual element'
+  },
+
   'duplicate-definition': {
     std: 'Duplicate definition of $(NAME)',
     absolute: 'Duplicate definition of artifact $(NAME)',
@@ -235,6 +247,10 @@ const centralMessageTexts = {
 
   'query-unexpected-assoc-hdbcds': 'Publishing a managed association in a view is not possible for “hdbcds” naming mode',
   'query-unexpected-structure-hdbcds': 'Publishing a structured element in a view is not possible for “hdbcds” naming mode',
+  'query-ignoring-param-nullability': {
+    std: 'Ignoring nullability constraint on parameter when generating SAP HANA CDS view',
+    sql: 'Ignoring nullability constraint on parameter when generating SQL view'
+  },
 
   'ref-sloppy-type': 'A type or an element is expected here',
   'ref-sloppy-actionparam-type': 'A type, an element, or a service entity is expected here',

package/lib/base/messages.js

@@ -672,13 +672,16 @@ function ignoreTextTransform() {
 
 function transformManyWith( t, sorted ) {
   return function transformMany( many, r, args, texts ) {
-    const prop = ['none','one'][ many.length ];
-    if (!prop || !texts[prop] || args['#'] ) {
-      const names = many.map(t);
-      return (sorted ? names.sort() : names).join(', ');
-    }
+    const prop = ['none','one','two'][ many.length ];
+    const names = many.map(t);
+    if (sorted)
+      names.sort();
+    if (!prop || !texts[prop] || args['#'] )
+      return names.join(', ');
     r['#'] = prop;              // text variant
-    return many.length && t( many[0] );
+    if (many.length === 2)
+      r.second = names[1];
+    return many.length && names[0];
   };
 }
 
@@ -793,7 +796,7 @@ function replaceInString( text, params ) {
     start = pattern.lastIndex;
   }
   parts.push( text.substring( start ) );
-  let remain = ('#' in params) ? [] : Object.keys( params ).filter( n => params[n] );
+  let remain = (params['#']) ? [] : Object.keys( params ).filter( n => params[n] );
   return (remain.length)
          ? parts.join('') + '; ' +
            remain.map( n => n.toUpperCase() + ' = ' + params[n] ).join(', ')
@@ -845,7 +848,10 @@ function messageHash(msg) {
   if(!msg.home)
     return messageString(msg);
   const copy = {...msg};
-  copy.$location = undefined;
+  // Note: This is a hack. deduplicateMessages() would otherwise remove
+  //       all but one message about duplicated artifacts.
+  if (!msg.messageId || !msg.messageId.includes('duplicate'))
+    copy.$location = undefined;
   return messageString(copy);
 }
 
@@ -1082,7 +1088,7 @@ function deduplicateMessages( messages ) {
 
 function shortArtName( art ) {
   const { name } = art;
-  if ([ 'select', 'action', 'alias', 'param' ].every( n => name[n] == null ) &&
+  if ([ 'select', 'action', 'alias', 'param' ].every( n => name[n] == null || name[n] === 1 ) &&
       !name.absolute.includes(':'))
     return quote.name( name.element ? `${ name.absolute }:${ name.element }` : name.absolute );
   return artName( art );

package/lib/base/optionProcessorHelper.js

@@ -484,7 +484,7 @@ function createOptionProcessor() {
             }
           } else {
             result.options[opt.camelName] = value;
-            if (opt.validValues && !opt.validValues.includes(value)) {
+            if (opt.validValues && !opt.validValues.some( validValue => validValue.toLowerCase() === value.toLowerCase() ) ) {
               result.errors.push(`Invalid value "${value}" for option "${shortOption}${opt.longName}" - use one of [${opt.validValues}]`);
             }
           }

package/lib/checks/emptyOrOnlyVirtual.js

@@ -12,9 +12,9 @@ const { isPersistedOnDatabase } = require('../model/csnUtils.js');
  * @param {CSN.Path} path Path to the artifact
  */
 function validateEmptyOrOnlyVirtual(artifact, artifactName, prop, path) {
-  if (artifact.kind === 'entity' && !artifact.query && isPersistedOnDatabase(artifact)) {
+  if (artifact.kind === 'entity' && isPersistedOnDatabase(artifact)) {
     if (!artifact.elements || !hasRealElements(artifact.elements))
-      this.error(null, path, "Artifacts containing only virtual or empty elements can't be deployed");
+      this.error('def-missing-element', path, { '#': artifact.query ? 'view' : 'std' });
   }
 }
 

package/lib/checks/unknownMagic.js

@@ -32,7 +32,7 @@ function unknownMagicVariable(parent, name, ref) {
     const magicVariable = magicVariables[head];
     if (magicVariable && magicVariable.indexOf(tail) === -1 &&
           getVariableReplacement(ref, this.options) === null)
-      this.error(null, parent.$location, { id: tail, elemref: parent }, 'No configuration for magic variable was provided - path $(ELEMREF), step $(ID)');
+      this.error('ref-missing-replacement', parent.$location, { elemref: parent }, 'Missing replacement for variable $(ELEMREF)');
   }
 }
 

package/lib/compiler/assert-consistency.js

@@ -249,7 +249,7 @@ function assertConsistency( model, stage ) {
           'name', '$parens', 'quantifier', 'mixin', 'excludingDict', 'columns', 'elements', '_deps',
           'where', 'groupBy', 'having', 'orderBy', '$orderBy', 'limit',
           '_projections', '_block', '_parent', '_main', '_effectiveType', '$expand',
-          '$tableAliases', 'kind', '_$next', '_combined', '$inlines',
+          '$tableAliases', 'kind', '_$next', '_combined', '$inlines', '_status',
         ],
       },
       none: { optional: () => true }, // parse error
@@ -542,7 +542,7 @@ function assertConsistency( model, stage ) {
         // query specific
         'where', 'columns', 'mixin', 'quantifier', 'offset',
         'orderBy', '$orderBy', 'groupBy', 'excludingDict', 'having',
-        'limit',
+        'limit', '_status',
       ],
     },
     _leadingQuery: { kind: true, test: TODO },

package/lib/compiler/builtins.js

@@ -2,7 +2,6 @@
 
 'use strict';
 
-const { forEachInDict } = require('../base/dictionaries');
 const { builtinLocation } = require('../base/location');
 const { setProp } = require('./utils');
 
@@ -82,18 +81,19 @@ const specialFunctions = {
  */
 const magicVariables = {
   $user: {
+    // id and locale are always available
     elements: { id: {}, locale: {} },
     // Allow $user.<any>
     $uncheckedElements: true,
     // Allow shortcut in CDL: `$user` becomes `$user.id` in CSN.
     $autoElement: 'id',
-  },                  // CDS-specific, not part of SQL
-  $at: {
+  },
+  $at: { // CDS-specific, not part of SQL
     elements: {
       from: {}, to: {},
     },
   },
-  $now: {},                   // Dito
+  $now: {}, // Dito
   $session: {
     // In ABAP CDS session variables are accessed in a generic way via
     // the pseudo variable $session.
@@ -199,6 +199,7 @@ function isBuiltinType(type) {
  * @param {XSN.Model} model XSN model without CDS builtins
  */
 function initBuiltins( model ) {
+  const { options } = model;
   setMagicVariables( magicVariables );
   // namespace:"cds" stores the builtins ---
   const cds = createNamespace( 'cds', 'reserved' );
@@ -266,27 +267,45 @@ function initBuiltins( model ) {
     for (const name in builtins) {
       const magic = builtins[name];
       // TODO: rename to $builtinFunction
-      const art = { kind: 'builtin', name: { id: name, element: name } };
+      const art = { kind: 'builtin', name: { element: name, id: name } };
       artifacts[name] = art;
-      if (magic.elements)
-        art.elements = forEachInDict( magic.elements, (e, n) => magicElement( e, n, art ));
+
       if (magic.$autoElement)
         art.$autoElement = magic.$autoElement;
       if (magic.$uncheckedElements)
         art.$uncheckedElements = magic.$uncheckedElements;
+
+      createMagicElements( art, magic.elements );
+      if (options.variableReplacements)
+        createMagicElements( art, options.variableReplacements[name] );
       // setProp( art, '_effectiveType', art );
     }
     model.$magicVariables = { kind: '$magicVariables', artifacts };
   }
 
-  function magicElement( spec, name, parent ) {
-    const magic = {
-      kind: 'builtin',
-      name: { id: name, element: `${ parent.name.element }.${ name }` },
-    };
-    setProp( magic, '_parent', parent );
-    // setProp( magic, '_effectiveType', magic );
-    return magic;
+  function createMagicElements( art, elements ) {
+    if (!elements)
+      return;
+
+    const names = Object.keys(elements);
+    if (names.length > 0 && !art.elements)
+      art.elements = Object.create(null);
+
+    for (const n of names) {
+      const magic = {
+        kind: 'builtin',
+        name: { id: n, element: `${ art.name.element }.${ n }` },
+      };
+      // Propagate this property so that it is available for sub-elements.
+      if (art.$uncheckedElements)
+        magic.$uncheckedElements = art.$uncheckedElements;
+      setProp( magic, '_parent', art );
+      // setProp( magic, '_effectiveType', magic );
+      if (elements[n] && typeof elements[n] === 'object')
+        createMagicElements(magic, elements[n]);
+
+      art.elements[n] = magic;
+    }
   }
 }
 

package/lib/compiler/definer.js

@@ -131,6 +131,7 @@ const {
   setMemberParent,
   storeExtension,
   dependsOnSilent,
+  pathName,
   augmentPath,
   splitIntoPath,
 } = require('./utils');
@@ -802,8 +803,8 @@ function define( model ) {
 
   // art is:
   // - entity for top-level queries (including UNION args)
-  // - $tableAlias for sub query in FROM
-  // - $query for real sub query (in columns, WHERE, ...)
+  // - $tableAlias for sub query in FROM - TODO: what about UNION there?
+  // - $query for real sub query (in columns, WHERE, ...), again: what about UNION there?
   function initQueryExpression( query, art ) {
     if (!query)                 // parse error
       return query;
@@ -855,7 +856,7 @@ function define( model ) {
       query.kind = 'select';
       query.name = { location: query.location };
       setMemberParent( query, main.$queries.length + 1, main );
-      // console.log(JSON.stringify(query.name))
+      // console.log(art.kind,art.name,query.name,query._$next.name)
       // if (query.name.query === 1 && query.name.absolute === 'S') throw Error();
       main.$queries.push( query );
       setProp( query, '_parent', art ); // _parent should point to alias/main/query
@@ -1340,7 +1341,7 @@ function define( model ) {
       name: { path: splitIntoPath( location, entityName ), absolute: entityName, location },
       location,
       elements,
-      $inferred: 'aspect-composition',
+      $inferred: 'composition-entity',
     };
     if (target.name) {          // named target aspect
       setLink( art, '_origin', target );
@@ -2103,7 +2104,7 @@ function define( model ) {
       name: { path: splitIntoPath( location, absolute ), absolute, location },
       location: base.location,
       elements,
-      $inferred: 'localized',
+      $inferred: 'localized-entity',
     };
     const locale = {
       name: { location, id: 'locale' },
@@ -2204,7 +2205,7 @@ function define( model ) {
       name: { location, id: 'texts' },
       kind: 'element',
       location,
-      $inferred: 'localized-texts',
+      $inferred: 'localized',
       type: augmentPath( location, 'cds.Composition' ),
       cardinality: { targetMax: { literal: 'string', val: '*', location }, location },
       target: augmentPath( location, textsName ),
@@ -2219,7 +2220,7 @@ function define( model ) {
       name: { location, id: 'localized' },
       kind: 'element',
       location,
-      $inferred: 'localized-texts',
+      $inferred: 'localized',
       type: augmentPath( location, 'cds.Association' ),
       target: augmentPath( location, textsName ),
       on: augmentEqual( location, 'localized', keys ),
@@ -2308,16 +2309,6 @@ function mergeI18nBlocks( model ) {
   }
 }
 
-/**
- * Return string 'A.B.C' for parsed source `A.B.C` (is vector of ids with
- * locations).
- *
- * @param {XSN.Path} path
- */
-function pathName(path) {
-  return path.map( id => id.id ).join('.');
-}
-
 function augmentEqual( location, assocname, relations, prefix = '' ) {
   const args = relations.map( eq );
   return (args.length === 1)