@sap/cds-compiler 2.12.0 → 2.15.2

package/lib/compiler/define.js

@@ -0,0 +1,1151 @@
+// Compiler phase "define": transform dictionary of AST-like CSNs into augmented CSN
+
+// AST-like CSN looks as follows:
+//   { kind: 'source', env: <dictionary of artifact defs>, namespace: {}, ... }
+//
+// The property `artifacts` of a source contains the top-level definitions.
+// Definitions inside a context are not listed here (as opposed to
+// `definitions`, see below), but inside the property `artifacts` of that context.
+
+// The define phase (function 'define' below) enriches a dictionary of
+// (file names to) AST-like CSNs and restructure them a little bit, the result
+// is called "augmented CSN":
+//   { sources: <dictionary of ASTs>, definitions: <dictionary of artifact defs> }
+//
+// The property `sources` is the input argument (dictionary of source ASTs).
+//
+// The property `definitions` is set by this compiler phase.  It contains the
+// definitions of all main artifacts (i.e. not elements) from all sources, the
+// key is the absolute name of that artifact.  These definitions are the same
+// objects as the definitions accessible via `sources` and `artifacts` of the
+// corresponding source/context.
+//
+// Because different sources could define artifacts with the same absolute
+// name, this compiler phase also put a property `messages` to the resulting
+// model, which is a vector of messages for the redefinitions.  (Using the same
+// name for different definitions in one source is already recognized during
+// parsing.)
+//
+// You get the compact "official" CSN format by applying the function exported
+// by "../json/to-csn.js" to the augmented CSN.
+
+// Example 'file.cds':
+//   namespace A;
+//   context B {
+//     type C { elem: String(4); }
+//   }
+// Check the augmented CSN by compiling it with
+//   cdsc --raw-output + file.cds
+//
+// ┌───────────────┐           ┌───────────────────────────────────────────┐
+// │    sources    │           │                 definitions               │
+// └──┬────────────┘           └──┬────────────────────────────┬───────────┘
+//    │                           │                            │
+//    │ ['file.cds']              │ ['A.B']                    │ ['A.B.C']
+//    ↓                           ↓                            ↓
+// ┌───────────────┐  _parent  ┌────────────────┐  _parent  ┌──────────────┐
+// │ kind:'source' │←──────────┤ kind:'context' │←──────────┤ kind: 'type' │
+// │ artifacts: ───┼──────────→│ artifacts: ────┼──────────→│ ...          │
+// └───────────────┘   ['B']   └────────────────┘   ['C']   └──────────────┘
+//
+// The _parent properties are not shown in the JSON - they are used for name
+// resolution, see file './resolver.js'.
+
+// An artifact definition looks as follows (example: context "A.B" above):
+//   {
+//     kind: 'context',
+//     name: { id: 'B', absolute: 'A.B', location: { <for the id "B"> } },
+//     artifacts: <for contexts, a dictionary of artifacts defined within>,
+//     location: { <of the complete artifact definition> } },
+//     _parent: <the parent artifact, here the source 'file.cds'>
+//   }
+// The properties `name.absolute`, `name.component` and `_parent` are set
+// during this compiler phase.
+
+// The definition of an entity or a structured type would contain an `elements`
+// property instead of an `artifacts` property.
+
+// An element definition looks as follows (example: "elem" above):
+//   {
+//     kind: 'element',
+//     name: { id: 'elem', component: 'elem', location: { <for the id "elem"> } }
+//     type: { path: [ { id: 'String', location: ... } ] },
+//     $typeArgs: [ { number: '4', location: ... } ]
+//     location: { <of the complete element definition> } },
+//     _parent: <the parent artifact, here the type "A.B.C">
+//   }
+// References are resolved in the "resolve" phase of the compiler, see
+// './resolver.js'.  We then get the properties `type.absolute` and `length`.
+
+// Sub phase 1 (addXYZ) - only for main artifacts
+//  - set _block links
+//  - store definitions (including context extensions), NO duplicate check
+//  - artifact name check
+//  - Note: the only allow name resolving is resolveUncheckedPath(),
+//    TODO: make sure that _no_ _artifact link is set
+//  - POST: all user-written definitions are in model.definitions
+
+// Sub Phase 2 (initXYZ)
+//  - set _parent, _main (later: _service?) links, and _block links of members
+//  - add _subArtifacts dictionary and "namespace artifacts" for name resolution
+//  - duplicate checks
+//  - structure checks ?
+//  - annotation assignments
+//  - POST: resolvePath() can be called for artifact references (if complete model)
+
+// More sub phases...
+
+// The main difficulty is the correct behavior concerning duplicate definitions
+//  - We need a unique object for the _subArtifacts dictionary.
+//  - We must have a property at the artifact whether there are duplicates in order
+//    to avoid consequential or repeated errors.
+//  - But: The same artifact is added to multiple dictionaries.
+//  - Solution part 1: $duplicates as property of the artifact or member
+//    for `definitions`, `_artifacts`, member dictionaries, `vocabulary`
+//    dictionary of the whole model, `$tableAliases` dictionary of queries.
+//  - Solution part 2: array value in dictionary for duplicates in CDL `artifacts`
+//    dictionary, `_combined` dictionary for query search, `$tableAliases`
+//    of JOIN restrictions, `vocabulary` dictionary of a CDL input source.
+
+'use strict';
+
+const { isDeprecatedEnabled, forEachGeneric, forEachInOrder } = require('../base/model');
+const {
+  dictAdd, dictAddArray, dictForEach, pushToDict,
+} = require('../base/dictionaries');
+const { kindProperties, dictKinds } = require('./base');
+const {
+  setLink,
+  setMemberParent,
+  storeExtension,
+  dependsOnSilent,
+  pathName,
+  splitIntoPath,
+} = require('./utils');
+const { compareLayer } = require('./moduleLayers');
+const { initBuiltins, isInReservedNamespace } = require('./builtins');
+
+const $location = Symbol.for('cds.$location');
+
+/**
+ * Export function of this file.  Transform argument `sources` = dictionary of
+ * AST-like CSNs into augmented CSN.  If a vector is provided for argument
+ * `messages` (usually the combined messages from `parse` for all sources), do
+ * not throw an exception in case of an error, but push the corresponding error
+ * object to that vector.  If at least one AST does not exist due to a parse
+ * error, set property `lintMode` of `options` to `true`.  Then, the resolver
+ * does not report errors for using directives pointing to non-existing
+ * artifacts.
+ *
+ * @param {XSN.Model} model Model with `sources` property that contain AST-like CSNs.
+ */
+function define( model ) {
+  const { options } = model;
+  // Get simplified "resolve" functionality and the message function:
+  const {
+    error, warning, info, messages,
+  } = model.$messageFunctions;
+  const {
+    resolveUncheckedPath,
+    defineAnnotations,
+  } = model.$functions;
+
+  const extensionsDict = Object.create(null);
+  Object.assign( model.$functions, {
+    initArtifact,
+    initMembers,
+    extensionsDict,             // a dictionary - TODO: remove
+    checkDefinitions,
+  } );
+  // During the definer, we can only resolve artifact references, i.e,
+  // after a `.`, we only search in the `_subArtifacts` dictionary:
+  model.$volatileFunctions.environment = function artifactsEnv( art ) {
+    return art._subArtifacts || Object.create(null);
+  };
+
+  return doDefine();
+
+  /**
+   * Main function of the definer.
+   */
+  function doDefine() {
+    if (options.deprecated &&
+        messages.every( m => m.messageId !== 'api-deprecated-option' )) {
+      warning( 'api-deprecated-option', {},
+               { prop: 'deprecated', '#': (options.beta ? 'beta' : 'std') }, {
+               // TODO: make the text scarier in future versions
+                 std: 'With option $(PROP), many newer features are disabled',
+                 // eslint-disable-next-line max-len
+                 beta: 'With option $(PROP), beta features and many other newer features are disabled',
+               } );
+    }
+    model.definitions = Object.create(null);
+    setLink( model, '_entities', [] ); // for entities with includes
+    model.$entity = 0;
+    model.$compositionTargets = Object.create(null);
+    model.$lateExtensions = Object.create(null); // for generated artifacts
+
+    initBuiltins( model );
+    for (const name in model.sources)
+      addSource( model.sources[name] );
+    for (const name in model.sources)
+      initNamespaceAndUsing( model.sources[name] );
+    dictForEach( model.definitions, initArtifact );
+    dictForEach( model.vocabularies, initVocabulary );
+
+    mergeI18nBlocks( model );
+  }
+
+  // Phase 1: ----------------------------------------------------------------
+
+  /**
+   * Add definitions of the given source AST, both CDL and CSN
+   *
+   * @param {XSN.AST} src
+   */
+  function addSource( src ) {
+    // handle sub model from parser
+    if (!src.kind)
+      src.kind = 'source';
+
+    let namespace = src.namespace && src.namespace.path;
+    let prefix = namespace ? `${ pathName( namespace ) }.` : '';
+    if (isInReservedNamespace(prefix)) {
+      error( 'reserved-namespace-cds', [ src.namespace.location, src.namespace ], {},
+             // TODO: use $(NAME)
+             'The namespace "cds" is reserved for CDS builtins' );
+      namespace = null;
+    }
+    if (src.$frontend !== 'json') { // CDL input
+      // TODO: set _block to builtin
+      if (src.artifacts)
+        addPathPrefixes( src.artifacts, prefix ); // before addUsing
+      else if (src.usings || src.namespace)
+        src.artifacts = Object.create(null);
+      if (src.usings)
+        src.usings.forEach( u => addUsing( u, src ) );
+      if (namespace)
+        addNamespace( namespace, src );
+      if (src.artifacts)     // addArtifact needs usings for context extensions
+        dictForEach( src.artifacts, a => addArtifact( a, src, prefix ) );
+    }
+    else if (src.definitions) {      // CSN input
+      prefix = '';
+      dictForEach( src.definitions, v => addDefinition( v, src ) );
+    }
+    if (src.vocabularies) {
+      if (!model.vocabularies)
+        model.vocabularies = Object.create(null);
+      dictForEach( src.vocabularies, v => addVocabulary( v, src, prefix ) );
+    }
+    if (src.extensions) {       // requires using to be known!
+      src.extensions.forEach( e => addExtension( e, src ) );
+    }
+  }
+
+  function addDefinition( art, block ) {
+    const { absolute } = art.name;
+    // TODO: check reserved, see checkName()/checkLocalizedObjects() of checks.js
+    if (absolute === 'cds' || isInReservedNamespace(absolute)) {
+      error( 'reserved-namespace-cds', [ art.name.location, art ], {},
+             // TODO: use $(NAME)
+             'The namespace "cds" is reserved for CDS builtins' );
+      const builtin = model.definitions[absolute];
+      if (builtin && builtin.builtin) // if already a builtin...
+        return;
+      // otherwise we just define it...
+    }
+    else if (art.query && (absolute === 'localized' || absolute.startsWith( 'localized.' ))) {
+      // Due to recompilation, we don't emit this info message for JSON frontend.
+      // TODO: generalize this for $generated (definitions starting with
+      // "localized" just have `$generated: true` as default)
+      if (block.$frontend !== 'json') {
+        info( 'ignored-localized-definition', [ art.name.location, art ], {},
+              'This definition in the namespace "localized" is ignored' );
+      }
+      return;
+    }
+    setLink( art, '_block', block );
+    // dictAdd might set $duplicates to true
+    dictAdd( model.definitions, absolute, art );
+  }
+
+  // If 'A.B.C' is in 'artifacts', also add 'A' for name resolution
+  function addPathPrefixes( artifacts, prefix ) {
+    for (const name in artifacts) {
+      const d = artifacts[name];
+      const a = Array.isArray(d) ? d[0] : d;
+      if (!a.name.absolute)
+        a.name.absolute = prefix + name;
+      const index = name.indexOf( '.' );
+      if (index < 0)
+        continue; // also for newly added (i.e. does not matter whether visited or not)
+      const id = name.substring( 0, index );
+      if (artifacts[id])
+        continue;
+      // TODO: enable optional locations
+      const location = a.name.path && a.name.path[0].location || a.location;
+      const absolute = prefix + id;
+      artifacts[id] = {
+        kind: 'using',          // !, not namespace - we do not know artifact yet
+        name: {
+          id, absolute, location, $inferred: 'as',
+        },
+        // TODO: use global ref (in general - all uses of splitIntoPath)
+        extern: { path: splitIntoPath( location, absolute ), location },
+        location,
+        $inferred: 'path-prefix',
+      };
+    }
+  }
+
+
+  /**
+   * Add the names of a USING declaration to the top-level search environment
+   * of the source, and set the absolute name referred by the USING
+   * declaration.
+   *
+   * @param {XSN.Using} decl Node to be expanded and added to `src`
+   * @param {XSN.AST} src
+   */
+  function addUsing( decl, src ) {
+    if (decl.usings) {
+      // e.g. `using {a,b} from 'file.cds'` -> recursive
+      decl.usings.forEach( u => addUsing( u, src ) );
+      return;
+    }
+    const { path } = decl.extern;
+    if (path.broken || !path[0]) // syntax error
+      return;
+    if (!decl.name)
+      decl.name = { ...path[path.length - 1], $inferred: 'as' };
+    decl.name.absolute = pathName( path );
+    const name = decl.name.id;
+    // TODO: check name: no "."
+    const found = src.artifacts[name];
+    if (found && found.$inferred === 'path-prefix' &&
+        found.name.absolute === decl.name.absolute)
+      src.artifacts[name] = decl;
+    else
+      dictAddArray( src.artifacts, name, decl );
+  }
+
+  function addNamespace( path, src ) {
+    const absolute = pathName( path );
+    if (path.broken) // parsing may have failed
+      return;
+    // create using for own namespace:
+    const last = path[path.length - 1];
+    const { id } = last;
+    if (src.artifacts[id] || last.id.includes('.'))
+      // not used as we have a definition/using with that name, or dotted last path id
+      return;
+    src.artifacts[id] = {
+      kind: 'using',
+      name: {
+        id, absolute, location: last.location, $inferred: 'as',
+      },
+      extern: src.namespace,
+      location: src.namespace.location,
+      $inferred: 'namespace',
+    };
+  }
+  function addArtifact( art, block, prefix ) {
+    if (art.kind === 'using')
+      return;
+    art.name.absolute = prefix + pathName( art.name.path );
+    addDefinition( art, block );
+    if (art.artifacts) {
+      const p = `${ art.name.absolute }.`;
+      // path prefixes (usings) must be added before extensions in artifacts:
+      addPathPrefixes( art.artifacts, p );
+      dictForEach( art.artifacts, a => addArtifact( a, art, p ) );
+    }
+    if (art.extensions) {       // requires using to be known!
+      art.extensions.forEach( e => e.name && addExtension( e, art ) );
+    }
+  }
+
+  function addExtension( ext, block ) {
+    setLink( ext, '_block', block );
+    const absolute = ext.name && resolveUncheckedPath( ext.name, 'extend', ext );
+    if (!absolute)                    // broken path
+      return;
+    delete ext.name.path[0]._artifact; // might point to wrong JS object in phase 1
+    ext.name.absolute = absolute; // definition might not be there yet, no _artifact link
+    pushToDict( extensionsDict, absolute, ext );
+    if (!ext.artifacts)
+      return;
+    // Directly add the artifacts of context and service extension:
+    if (!model.$blocks)
+      model.$blocks = Object.create( null );
+    // Set block number for debugging (--raw-output):
+    // eslint-disable-next-line no-multi-assign
+    ext.name.select = model.$blocks[absolute] = (model.$blocks[absolute] || 0) + 1;
+    const prefix = `${ absolute }.`;
+    dictForEach( ext.artifacts, a => addArtifact( a, ext, prefix ) );
+  }
+
+  function addVocabulary( vocab, block, prefix ) {
+    setLink( vocab, '_block', block );
+    const { name } = vocab;
+    if (!name.absolute)
+      name.absolute = prefix + name.path.map( id => id.id ).join('.');
+    dictAdd( model.vocabularies, name.absolute, vocab );
+  }
+
+  // Phase 2 ("init") --------------------------------------------------------
+
+  function checkRedefinition( art ) {
+    if (!art.$duplicates)
+      return;
+    if (art._main) {
+      error( 'duplicate-definition', [ art.name.location, art ], {
+        name: art.name.id,
+        '#': kindProperties[art.kind].normalized || art.kind,
+      } );
+    }
+    else {
+      error( 'duplicate-definition', [ art.name.location, art ], {
+        name: art.name.absolute,
+        '#': (art.kind === 'annotation' ? 'annotation' : 'absolute' ),
+      } );
+    }
+  }
+
+  function initNamespaceAndUsing( src ) {
+    if (src.namespace) {
+      const decl = src.namespace;
+      const { path } = decl;
+      if (path.broken) // parsing may have failed
+        return;
+      const { id } = path[path.length - 1];
+      const absolute = pathName( path );
+      if (!model.definitions[absolute]) {
+        // TODO: do we really need this namespace entry - try without (msg change)
+        const location = path.location || decl.location;
+        // TODO: make it possible to have no location
+        const ns = { kind: 'namespace', name: { absolute, location }, location };
+        model.definitions[absolute] = ns;
+        initParentLink( ns, model.definitions );
+      }
+      const builtin = model.$builtins[id];
+      if (builtin && !builtin.internal &&
+          src.artifacts[id] && src.artifacts[id].extern === decl) {
+        warning( 'ref-shadowed-builtin', [ decl.location, null ], // no home artifact
+                 { id, art: absolute, code: `using ${ builtin.name.absolute };` },
+                 '$(ID) now refers to $(ART) - consider $(CODE)' );
+      }
+      // setArtifactLink( decl, model.definitions[absolute] ); // TODO: necessary?
+    }
+    if (!src.usings)
+      return;
+    for (const name in src.artifacts) {
+      const entry = src.artifacts[name];
+      if (!Array.isArray(entry)) // no local name duplicate
+        continue;
+      for (const decl of entry) {
+        if (!decl.$duplicates) { // do not have two duplicate messages
+          error( 'duplicate-using', [ decl.name.location, null ], { name }, // TODO: semantic
+                 'Duplicate definition of top-level name $(NAME)' );
+        }
+      }
+    }
+  }
+
+  function initArtifact( art, reInit = false ) {
+    if (!reInit)
+      initParentLink( art, model.definitions );
+    const block = art._block;
+    checkRedefinition( art );
+    defineAnnotations( art, art, block );
+    initMembers( art, art, block );
+    initDollarSelf( art );      // $self
+    if (art.params)
+      initParams( art );        // $parameters
+    if (art.includes && !(art.name.absolute in extensionsDict)) // TODO: in next phase?
+      extensionsDict[art.name.absolute] = []; // structure with includes must be "extended"
+
+    if (!art.query)
+      return;
+    art.$queries = [];
+    setLink( art, '_from', [] ); // for sequence of resolve steps
+    if (!setLink( art, '_leadingQuery', initQueryExpression( art.query, art ) ) )
+      return;                   // null or undefined in case of parse error
+    setLink( art._leadingQuery, '_$next', art );
+    // the following we be removed soon if we have:
+    // view elements as proxies to elements of leading query
+    if (art.elements) { // specified element via compilation of client-style CSN
+      setLink( art, 'elements$', art.elements );
+      delete art.elements;
+    }
+  }
+
+  function initVocabulary( art ) {
+    initParentLink( art, model.vocabularies );
+    checkRedefinition( art );
+    const block = art._block;
+    defineAnnotations( art, art, block );
+    initMembers( art, art, block );
+  }
+
+  function initParentLink( art, definitions ) {
+    setLink( art, '_parent', null );
+    const { absolute } = art.name;
+    const dot = absolute.lastIndexOf('.');
+    if (dot < 0)
+      return;
+    art.name.id = absolute.substring( dot + 1 ); // XSN TODO: remove name.id for artifacts
+    const prefix = absolute.substring( 0, dot );
+    let parent = definitions[prefix];
+    if (!parent) {
+      const { location } = art.name; // TODO: make it possible to have no location
+      parent = { kind: 'namespace', name: { absolute: prefix, location }, location };
+      definitions[prefix] = parent;
+      initParentLink( parent, definitions );
+    }
+    if (art.kind !== 'namespace' &&
+        isDeprecatedEnabled( options, 'generatedEntityNameWithUnderscore' )) {
+      let p = parent;
+      while (p && kindProperties[p.kind].artifacts)
+        p = p._parent;
+      if (p) {
+        error( 'subartifacts-not-supported', [ art.name.location, art ],
+               { art: p, prop: 'deprecated.generatedEntityNameWithUnderscore' },
+               // eslint-disable-next-line max-len
+               'With the option $(PROP), no sub artifact can be defined for a non-context/service $(ART)' );
+      }
+    }
+    setLink( art, '_parent', parent );
+    if (!parent._subArtifacts)
+      setLink( parent, '_subArtifacts', Object.create(null) );
+    if (art.$duplicates !== true) // no redef or "first def"
+      parent._subArtifacts[absolute.substring( dot + 1 )] = art; // not dictAdd()
+  }
+
+  // From here til EOF, reexamine code ---------------------------------------
+  // See populate:
+  // - userQuery() or _query property?
+  // - initFromColumns()
+  // - ensureColumnName()
+
+  function initDollarSelf( art ) {
+    const selfname = '$self';
+    // TODO: use setMemberParent() ?
+    const name = art.name || art._outer.name;
+    const self = {
+      name: { id: selfname, alias: selfname, absolute: name.absolute },
+      kind: '$self',
+      location: art.location,
+    };
+    if (name.element)          // $self for anonymous aspect
+      self.name.element = name.element;
+    setLink( self, '_parent', art );
+    setLink( self, '_main', art ); // used on main artifact
+    setLink( self, '_origin', art );
+    art.$tableAliases = Object.create(null);
+    art.$tableAliases[selfname] = self;
+    setLink( art, '_$next', model.$magicVariables );
+  }
+
+  function initParams( art ) {
+    // TODO: use setMemberParent() ?
+    const parameters = {
+      name: { id: '$parameters', param: '$parameters', absolute: art.name.absolute },
+      kind: '$parameters',
+      location: art.location,
+    };
+    setLink( parameters, '_parent', art );
+    setLink( parameters, '_main', art );
+    // Search for :const after :param.  If there will be a possibility in the
+    // future that we can extend <query>.columns, we must be sure to use
+    // _block of that new column after :param (or just allow $parameters there).
+    setLink( parameters, '_block', art._block );
+    if (art.params) {
+      parameters.elements = art.params;
+      parameters.$tableAliases = art.params; // TODO: find better name - $lexical?
+    }
+    art.$tableAliases.$parameters = parameters;
+  }
+
+  function initSubQuery( query ) {
+    if (query.on)
+      initExprForQuery( query.on, query );
+    // TODO: MIXIN with name = ...subquery (not yet supported anyway)
+    initSelectItems( query, query.columns, query );
+    if (query.where)
+      initExprForQuery( query.where, query );
+    if (query.having)
+      initExprForQuery( query.having, query );
+    initMembers( query, query, query._block );
+  }
+
+  function initSelectItems( parent, columns, user ) {
+    // TODO: forbid expand/inline with :param, global:true, in ref-where, outside queries (CSN), ...
+    let wildcard = null;
+    let hasItems = false;
+    for (const col of columns || parent.expand || parent.inline || []) {
+      if (!col)                 // parse error
+        continue;
+      hasItems = true;
+      if (!columns) {
+        if (parent.value)
+          setLink( col, '_pathHead', parent ); // also set for '*' in expand/inline
+        else if (parent._pathHead)
+          setLink( col, '_pathHead', parent._pathHead );
+      }
+      if (col.val === '*') {
+        if (!wildcard) {
+          wildcard = col;
+        }
+        else {
+          // a late syntax error (this code also runs with parse-cdl), i.e.
+          // no semantic loc (wouldn't be available for expand/inline anyway)
+          error( 'syntax-duplicate-clause', [ col.location, null ],
+                 { prop: '*', line: wildcard.location.line, col: wildcard.location.col },
+                 'You have provided a $(PROP) already at line $(LINE), column $(COL)' );
+          // TODO: extra text variants for expand/inline? - probably not
+          col.val = null;       // do not consider it for expandWildcard()
+        }
+      }
+      // Either expression (value), expand or new association (target && type)
+      else if (col.value || col.expand || (col.target && col.type)) {
+        setLink( col, '_block', parent._block );
+        defineAnnotations( col, col, parent._block ); // TODO: complain with inline
+        // TODO: allow sub queries? at least in top-level expand without parallel ref
+        if (columns)
+          initExprForQuery( col.value, parent );
+        initSelectItems( col, null, user );
+      }
+    }
+
+    if (hasItems && !wildcard && parent.excludingDict) {
+      // TODO: Better way to get source file?
+      let block = parent;
+      while (block._block)
+        block = block._block;
+
+      if (block.$frontend === 'cdl') {
+        warning('query-ignoring-exclude', [ parent.excludingDict[$location], user ],
+                { prop: '*' },
+                'Excluding elements without wildcard $(PROP) has no effect');
+      }
+    }
+  }
+
+  function initExprForQuery( expr, query ) {
+    if (Array.isArray(expr)) { // TODO: old-style $parens ?
+      expr.forEach( e => initExprForQuery( e, query ) );
+    }
+    else if (!expr) {
+      return;
+    }
+    else if (expr.query) {
+      initQueryExpression( expr.query, query );
+    }
+    else if (expr.args) {
+      const args = Array.isArray(expr.args) ? expr.args : Object.values( expr.args );
+      args.forEach( e => initExprForQuery( e, query ) );
+    }
+    else if (expr.path && expr.$expected === 'exists') {
+      expr.$expected = 'approved-exists';
+      approveExistsInChildren(expr);
+    }
+  }
+
+  /**
+   * If we have a valid top-level exists, exists in filters of sub-expressions can be translated,
+   * since we will have a top-level subquery after exists-processing in the forHanaNew.
+   *
+   * Recursively drill down into:
+   * - the .path
+   * - the .args
+   * - the .where.args
+   *
+   * Any $expected === 'exists' encountered along the way are turned into 'approved-exists'
+   *
+   * working:     exists toE[exists toE] -> select from E where exists toE
+   * not working: toE[exists toE] -> we don't support subqueries in filters
+   *
+   * @param {object} exprOrPathElement starts w/ an expr but then subelem from .path or .where.args
+   */
+  function approveExistsInChildren(exprOrPathElement) {
+    if (exprOrPathElement.$expected === 'exists')
+      exprOrPathElement.$expected = 'approved-exists';
+    // Drill down
+    if (exprOrPathElement.args)
+      exprOrPathElement.args.forEach(elem => approveExistsInChildren(elem));
+    else if (exprOrPathElement.where && exprOrPathElement.where.args)
+      exprOrPathElement.where.args.forEach(elem => approveExistsInChildren(elem));
+    else if (exprOrPathElement.path)
+      exprOrPathElement.path.forEach(elem => approveExistsInChildren(elem));
+  }
+
+  // table is table expression in FROM, becomes an alias
+  function initTableExpression( table, query, joinParents ) {
+    if (!table)                 // parse error
+      return;
+    if (table.path) {           // path in FROM
+      if (!table.path.length || table.path.broken)
+        // parse error (e.g. final ',' in FROM), projection on <eof>
+        return;
+      if (!table.name) {
+        const last = table.path[table.path.length - 1];
+        const dot = last.id.lastIndexOf('.');
+        const id = (dot < 0) ? last.id : last.id.substring( dot + 1 );
+        // TODO: if we have too much time, we can calculate the real location with '.'
+        table.name = { $inferred: 'as', id, location: last.location };
+      }
+      addAsAlias();
+      // _origin is set when we resolve the ref
+      if (query._parent.kind !== 'select')
+        query._main._from.push( table ); // store tabref if outside "real" subquery
+    }
+    else if (table.query) {
+      if (!table.name || !table.name.id) {
+        error( 'query-req-alias', [ table.location, query ], {}, // TODO: not subquery.location ?
+               'Table alias is required for this subquery' );
+        return;
+      }
+      addAsAlias();
+      setLink( table, '_effectiveType', table.query ); // TODO: remove!
+      // Store _origin to leading query of table.query for name resolution
+      setLink( table, '_origin', initQueryExpression( table.query, table ) );
+    }
+    else if (table.join) {
+      if (table.on) {
+        setLink( table, '_$next', query ); // or query._$next?
+        setLink( table, '_block', query._block );
+        table.kind = '$join';
+        table.name = { location: query.location }; // param comes later
+        table.$tableAliases = Object.create( null ); // table aliases and mixin definitions
+        joinParents = [ ...joinParents, table ];
+      }
+      if (table.args) {
+        table.args.forEach( (tab, index) => {
+          // set for A2J such that for every table alias `ta`:
+          // ta === (ta._joinParent
+          //        ? ta._joinParent.args[ta.$joinArgsIndex] // in JOIN
+          //        : ta._parent.from )                      // directly in FROM
+          // Note for --raw-output: _joinParent pointing to CROSS JOIN node has not name
+          if (!tab)             // parse error; time for #6241
+            return;             // (parser method to only add non-null to array)
+          setLink( tab, '_joinParent', table );
+          tab.$joinArgsIndex = index;
+          initTableExpression( tab, query, joinParents );
+        } );
+      }
+      if (table.on) {         // after processing args to get the $tableAliases
+        setMemberParent( table, query.name.select, query ); // sets _parent,_main
+        initSubQuery( table );  // init sub queries in ON
+        const aliases = Object.keys( table.$tableAliases || {} );
+        // Use first tabalias name on the right side of the join to name the
+        // (internal) query, should only be relevant for --raw-output, not for
+        // user messages or references - TODO: correct if join on left?
+        table.name.param = aliases[1] || aliases[0] || '<unknown>';
+        setLink( table, '_$next', query._$next );
+        // TODO: probably set this to query if we switch to name restriction in JOIN
+      }
+    }
+    return;
+
+    function addAsAlias() {
+      table.kind = '$tableAlias';
+      setMemberParent( table, table.name.id, query );
+      setLink( table, '_block', query._block );
+      dictAdd( query.$tableAliases, table.name.id, table, ( name, loc ) => {
+        error( 'duplicate-definition', [ loc, table ], { name, '#': 'alias' } );
+      } );
+      // also add to JOIN nodes for name restrictions:
+      for (const p of joinParents) {
+        // for JOIN alias restriction, we cannot use $duplicates, as it is
+        // already used for duplicate aliases of queries:
+        dictAddArray( p.$tableAliases, table.name.id, table );
+      }
+      if (table.name.id[0] === '$') {
+        warning( 'syntax-dollar-ident', [ table.name.location, table ], {
+          '#': (table.name.$inferred ? '$tableImplicit' : '$tableAlias'),
+          name: '$',
+          keyword: 'as',
+        } );
+      }
+    }
+  }
+
+  // art is:
+  // - entity for top-level queries (including UNION args)
+  // - $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;
+    if (query.from) {      // select
+      initQuery();
+      initTableExpression( query.from, query, [] );
+      if (query.mixin)
+        addMixin();
+      if (!query.$tableAliases.$self) { // same as $projection
+        const self = {
+          name: { alias: '$self', query: query.name.select, absolute: art.name.absolute },
+          kind: '$self',
+          location: query.location,
+        };
+        setLink( self, '_origin', query );
+        setLink( self, '_parent', query );
+        setLink( self, '_main', query._main );
+        setLink( self, '_effectiveType', query ); // TODO: remove
+        query.$tableAliases.$self = self;
+        query.$tableAliases.$projection = self;
+      }
+      initSubQuery( query );    // check for SELECT clauses after from / mixin
+    }
+    else if (query.args) {      // UNION, INTERSECT, ..., query in parens
+      const leading = initQueryExpression( query.args[0], art );
+      for (const q of query.args.slice(1))
+        initQueryExpression( q, art );
+      setLink( query, '_leadingQuery', leading );
+      if (leading && query.orderBy) {
+        if (leading.$orderBy)
+          leading.$orderBy.push( ...query.orderBy );
+        else
+          leading.$orderBy = [ ...query.orderBy ];
+      }
+      // ORDER BY to be evaluated in leading query (LIMIT is literal)
+    }
+    else { // with parse error (`select from <EOF>`, `select from E { *, ( select }`)
+      return undefined;
+    }
+    return query._leadingQuery || query;
+
+    function initQuery() {
+      const main = art._main || art;
+      setLink( query, '_$next',
+               // if art is $tableAlias, set to embedding query
+               (!art._main || art.kind === 'select' || art.kind === '$join')
+                 ? art : art._parent ); // TODO: check with name resolution change
+      setLink( query, '_block', art._block );
+      query.kind = 'select';
+      query.name = { location: query.location };
+      setMemberParent( query, main.$queries.length + 1, main );
+      // 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 );
+      setLink( query, '_parent', art ); // _parent should point to alias/main/query
+      query.$tableAliases = Object.create( null ); // table aliases and mixin definitions
+      dependsOnSilent( main, query );
+    }
+
+    function addMixin() {
+      // TODO: re-check if mixins have already duplicates
+      for (const name in query.mixin) {
+        const mixin = query.mixin[name];
+        if (!(mixin.$duplicates)) {
+          setMemberParent( mixin, name, query );
+          mixin.name.alias = mixin.name.id;
+          setLink( mixin, '_block', art._block );
+          // TODO: do some initMembers() ?  If people had annotation
+          // assignments on the mixin... (also for future mixin definitions
+          // with generated values)
+          dictAdd( query.$tableAliases, name, query.mixin[name], ( dupName, loc ) => {
+            error( 'duplicate-definition', [ loc, query ], { name: dupName, '#': 'alias' } );
+          } );
+          if (mixin.name.id[0] === '$') {
+            warning( 'syntax-dollar-ident', [ mixin.name.location, mixin ],
+                     { '#': 'mixin', name: '$' } );
+          }
+        }
+      }
+    }
+  }
+
+  function isDirectComposition( art ) {
+    const type = art.type && art.type.path;
+    return type && type[0] && type[0].id === 'cds.Composition';
+  }
+
+  // Return whether the `target` is actually a `targetAspect`
+  // TODO: really do that here and not in kick-start.js?
+  function targetIsTargetAspect( elem ) {
+    const { target } = elem;
+    if (target.elements) {
+      // TODO: error if CSN has both target.elements and targetAspect.elements -> delete target
+      return true;
+    }
+    if (elem.targetAspect || options.parseCdl || !isDirectComposition( elem ))
+      return false;
+    const name = resolveUncheckedPath( target, 'compositionTarget', elem );
+    const aspect = name && model.definitions[name];
+    return aspect && (aspect.kind === 'aspect' || aspect.kind === 'type'); // type is sloppy
+  }
+
+  /**
+   * Set property `_parent` for all elements in `parent` to `parent` and do so
+   * recursively for all sub elements.  Also set the property
+   * `name.component` of the element with the help of argument `prefix`
+   * (which is basically the component name of the `parent` element plus a dot).
+   */
+  // If not for extensions: construct === parent
+  function initMembers( construct, parent, block, initExtensions = false ) {
+    // TODO: split extend from init
+    const isQueryExtension = kindProperties[construct.kind].isExtension &&
+          (parent._main || parent).query;
+    let obj = construct;
+    if (obj.items) {            // TODO: while
+      setLink( obj.items, '_outer', obj );
+      obj = obj.items;          // TODO: probably set parent = obj (is so in csnRefs)
+      setLink( obj, '_block', block );
+    }
+    if (obj.target && targetIsTargetAspect( obj )) {
+      obj.targetAspect = obj.target;
+      delete obj.target;
+    }
+    const { targetAspect } = obj;
+    if (targetAspect) {
+      if (obj.foreignKeys) {
+        error( 'unexpected-keys-for-composition', [ obj.foreignKeys[$location], construct ],
+               {},
+               'A managed aspect composition can\'t have a foreign keys specification' );
+        delete obj.foreignKeys; // continuation semantics: not specified
+      }
+      if (obj.on && !obj.target) {
+        error( 'unexpected-on-for-composition', [ obj.on.location, construct ],
+               {},
+               'A managed aspect composition can\'t have a specified ON condition' );
+        delete obj.on;          // continuation semantics: not specified
+      }
+      if (targetAspect.elements) {
+        const inEntity = parent._main && parent._main.kind === 'entity';
+        // TODO: also allow indirectly (component in component in entity)?
+        setLink( targetAspect, '_outer', obj );
+        setLink( targetAspect, '_parent', parent._parent );
+        setLink( targetAspect, '_main', null ); // for name resolution
+
+        parent = targetAspect;
+        construct = parent;     // avoid extension behavior
+        targetAspect.kind = 'aspect';   // TODO: probably '$aspect' to detect
+        setLink( targetAspect, '_block', block );
+        initDollarSelf( targetAspect );
+        // allow ref of up_ in anonymous aspect inside entity
+        // (TODO: complain if used and the managed composition is included into
+        // another entity - might induce auto-redirection):
+        if (inEntity && !targetAspect.elements.up_) {
+          const up = {
+            name: {
+              id: 'up_',
+              alias: 'up_',
+              element: obj.name.element,
+              absolute: obj.name.absolute,
+            },
+            kind: '$navElement',
+            location: obj.location,
+          };
+          setLink( up, '_parent', targetAspect );
+          setLink( up, '_main', targetAspect ); // used on main artifact
+          // recompilation case: both target and targetAspect → allow up_ in that case, too:
+          const name = obj.target && resolveUncheckedPath( obj.target, 'target', obj );
+          const entity = name && model.definitions[name];
+          if (entity && entity.elements)
+            setLink( up, '_origin', entity.elements.up_ );
+          // processAspectComposition/expand() sets _origin to element of
+          // generated target entity
+          targetAspect.$tableAliases.up_ = up;
+        }
+        obj = targetAspect;
+      }
+    }
+    if (obj !== parent && obj.elements && parent.enum) {
+      // in extensions, extended enums are represented as elements
+      for (const n in obj.elements) {
+        const e = obj.elements[n];
+        if (e.kind === 'element')
+          e.kind = 'enum';
+      }
+      // obj = Object.assign( { enum: obj.elements}, obj );
+      // delete obj.elements;      // No extra syntax for EXTEND enum
+      forEachGeneric( { enum: obj.elements }, 'enum', init );
+    }
+    else {
+      if (checkDefinitions( construct, parent, 'elements', obj.elements || false ))
+        forEachInOrder( obj, 'elements', init );
+      if (checkDefinitions( construct, parent, 'enum', obj.enum || false ))
+        forEachGeneric( obj, 'enum', init );
+    }
+
+    if (obj.foreignKeys)  // cannot be extended or annotated - TODO: check anyway?
+      forEachInOrder( obj, 'foreignKeys', init );
+    if (checkDefinitions( construct, parent, 'actions' ))
+      forEachGeneric( construct, 'actions', init );
+    if (checkDefinitions( construct, parent, 'params' ))
+      forEachInOrder( construct, 'params', init );
+    const { returns } = construct;
+    if (returns) {
+      returns.kind = (kindProperties[construct.kind].isExtension) ? construct.kind : 'param';
+      init( returns, '' );      // '' is special name for returns parameter
+    }
+    return;
+
+    function init( elem, name, prop ) {
+      if (!elem.kind)           // wrong CSN input
+        elem.kind = dictKinds[prop];
+      if (!elem.name && !elem._outer) {
+        const ref = elem.targetElement || elem.kind === 'element' && elem.value;
+        if (ref && ref.path) {
+          elem.name = Object.assign( { $inferred: 'as' },
+                                     ref.path[ref.path.length - 1] );
+        }
+        else {                  // if JSON parser misses to set name
+          elem.name = { id: name, location: elem.location };
+        }
+      }
+      // if (!kindProperties[ elem.kind ]) console.log(elem.kind,elem.name)
+      if (kindProperties[elem.kind].isExtension && !initExtensions) {
+        storeExtension( elem, name, prop, parent, block );
+        return;
+      }
+      if (isQueryExtension && elem.kind === 'element') {
+        error( 'extend-query', [ elem.location, construct ], // TODO: searchName ?
+               { code: 'extend projection' },
+               'Use $(CODE) to add select items to the query entity' );
+        return;
+      }
+
+      const bl = elem._block || block;
+      setLink( elem, '_block', bl );
+      setMemberParent( elem, name, parent, construct !== parent && prop );
+      // console.log(message( null, elem.location, elem, {}, 'Info', 'INIT').toString())
+      checkRedefinition( elem );
+      defineAnnotations( elem, elem, bl );
+      initMembers( elem, elem, bl, initExtensions );
+
+      // for a correct home path, setMemberParent needed to be called
+
+      if (elem.value && elem.kind === 'element' ) {
+        // For enums in extensions, `elem.kind` is only changed to `enum` for non-parseCdl
+        // mode *and* if the referenced artifact is found.
+        // This means that for non-applicable extensions and parseCdl mode, this check
+        // is not used.
+        //
+        // `parent` is the extended entity/type/enum/... and *not* the "extend: ..."
+        // itself (which is `construct`).
+        if ( parent.kind !== 'select' && parent.kind !== 'extend' ) {
+          error( 'unexpected-val', [ elem.value.location, elem ],
+                 { '#': construct.kind },
+                 {
+                   std: 'Elements can\'t have a value',
+                   entity: 'Entity elements can\'t have a value',
+                   type: 'Type elements can\'t have a value',
+                   extend: 'Cannot extend type/entity elements with values',
+                 });
+          return;
+        }
+      }
+
+      if (parent.enum && elem.type) {
+        // already rejected by from-csn, can only happen in extensions
+        error( 'unexpected-type', [ elem.type.location, elem ], {},
+               'Enum values can\'t have a custom type' );
+      }
+    }
+  }
+
+  function checkDefinitions( construct, parent, prop, dict = construct[prop] ) {
+    // TODO: do differently, see also annotateMembers() in resolver
+    // To have been checked by parsers:
+    // - artifacts (CDL-only anyway) only inside [extend] context|service
+    if (!dict)
+      return false;
+    const names = Object.keys( dict );
+    if (!names.length) // TODO: re-check - really allow empty dict if no other?
+      return false;
+    const feature = kindProperties[parent.kind][prop];
+    if (feature &&
+        (feature === true || construct.kind !== 'extend' || feature( prop, parent )))
+      return true;
+    const location = dict[$location];
+    if (prop === 'actions') {
+      error( 'unexpected-actions', [ location, construct ], {},
+             'Actions and functions only exist top-level and for entities' );
+    }
+    else if (parent.kind === 'action' || parent.kind === 'function') {
+      error( 'extend-action', [ construct.location, construct ], {},
+             'Actions and functions can\'t be extended, only annotated' );
+    }
+    else if (prop === 'params') {
+      if (!feature) {
+        // Note: This error can't be triggered at the moment.  But as we likely want to
+        //       allow extensions with params in the future, we keep the code.
+        error( 'unexpected-params', [ location, construct ], {},
+               'Parameters only exist for entities, actions or functions' );
+      }
+      else {
+        // remark: we could allow this
+        error( 'extend-with-params', [ location, construct ], {},
+               'Extending artifacts with parameters is not supported' );
+      }
+    }
+    else if (feature) {         // allowed in principle, but not with extend
+      error( 'extend-type', [ location, construct ], {},
+             'Only structures or enum types can be extended with elements/enums' );
+    }
+    else if (prop === 'elements') {
+      error( 'unexpected-elements', [ location, construct ], {},
+             'Elements only exist in entities, types or typed constructs' );
+    }
+    else if (prop === 'columns') {
+      error( 'extend-columns', [ location, construct ], { art: construct } );
+    }
+    else { // if (prop === 'enum') {
+      error( 'unexpected-enum', [ location, construct ], {},
+             'Enum symbols can only be defined for types or typed constructs' );
+    }
+    return construct === parent;
+  }
+}
+
+/**
+ * Merge (optional) translations into the XSN model.
+ *
+ * @param {XSN.Model} model
+ */
+function mergeI18nBlocks( model ) {
+  const sortedSources = Object.keys(model.sources)
+    .filter(name => !!model.sources[name].i18n)
+    .sort( (a, b) => compareLayer( model.sources[a], model.sources[b] ) );
+
+  if (sortedSources.length === 0)
+    return;
+
+  if (!model.i18n)
+    model.i18n = Object.create( null );
+
+  for (const name of sortedSources)
+    initI18nFromSource( model.sources[name] );
+
+  /**
+   * Add the source's translations to the model. Warns if the sources translations
+   * do not match the ones from previous sources.
+   *
+   * @param {XSN.AST} src
+   */
+  function initI18nFromSource( src ) {
+    for (const langKey of Object.keys( src.i18n )) {
+      if (!model.i18n[langKey])
+        model.i18n[langKey] = Object.create( null );
+
+      for (const textKey of Object.keys( src.i18n[langKey] )) {
+        const sourceVal = src.i18n[langKey][textKey];
+        const modelVal = model.i18n[langKey][textKey];
+        if (!modelVal) {
+          model.i18n[langKey][textKey] = sourceVal;
+        }
+        else if (modelVal.val !== sourceVal.val) {
+          // TODO: put mergeI18nBlocks() into main function instead
+          model.$messageFunctions.warning( 'i18n-different-value', sourceVal.location,
+                                           { prop: textKey, otherprop: langKey } );
+        }
+      }
+    }
+  }
+}
+
+module.exports = define;