@sap/cds-compiler 3.5.4 → 3.6.2

package/lib/compiler/define.js

@@ -119,7 +119,8 @@
 
 'use strict';
 
-const { forEachGeneric, forEachInOrder } = require('../base/model');
+const { forEachGeneric, forEachInOrder, isBetaEnabled } = require('../base/model');
+const shuffleGen = require('../base/shuffle');
 const {
   dictAdd, dictAddArray, dictForEach, pushToDict,
 } = require('../base/dictionaries');
@@ -161,9 +162,12 @@ function define( model ) {
     resolveUncheckedPath,
     checkAnnotate,
   } = model.$functions;
+  const { shuffleDict, shuffleArray } = shuffleGen( options.testMode );
 
   const extensionsDict = Object.create(null);
   Object.assign( model.$functions, {
+    shuffleDict,
+    shuffleArray,
     initArtifact,
     initMembers,
     extensionsDict,             // a dictionary - TODO: put directly into model?
@@ -176,6 +180,8 @@ function define( model ) {
     return art._subArtifacts || Object.create(null);
   };
 
+  let boundSelfParamType = true; // special `$self` for binding param must still be initialised
+
   return doDefine();
 
   /**
@@ -199,15 +205,16 @@ function define( model ) {
     model.$lateExtensions = Object.create(null); // for generated artifacts
 
     initBuiltins( model );
-    for (const name in model.sources)
+    const sourceNames = shuffleArray( Object.keys( model.sources ) );
+    for (const name of sourceNames)
       addSource( model.sources[name] );
-    for (const name in model.sources)
+    for (const name of sourceNames)
       initNamespaceAndUsing( model.sources[name] );
     dictForEach( model.definitions, initArtifact );
     dictForEach( model.vocabularies, initVocabulary );
     dictForEach( extensionsDict, initExtension );
 
-    mergeI18nBlocks();
+    addI18nBlocks();
   }
 
   // Phase 1: ----------------------------------------------------------------
@@ -232,25 +239,31 @@ function define( model ) {
     }
     if (src.$frontend !== 'json') { // CDL input
       // TODO: set _block to builtin
-      if (src.artifacts)
+      if (src.artifacts) {
+        // addArtifact() adds usings to src.artifacts: shuffleDict must be assigned first
+        src.artifacts = shuffleDict( src.artifacts );
         addPathPrefixes( src.artifacts, prefix ); // before addUsing
-      else if (src.usings || src.namespace)
+      }
+      else if (src.usings || src.namespace) {
         src.artifacts = Object.create(null);
+      }
       if (src.usings)
-        src.usings.forEach( u => addUsing( u, src ) );
+        shuffleArray( src.usings ).forEach( u => addUsing( u, src ) );
       if (namespace)
         addNamespace( namespace, src );
-      if (src.artifacts)     // addArtifact needs usings for context extensions
+      if (src.artifacts) {      // addArtifact needs usings for context extensions
+        src.artifacts = shuffleDict( src.artifacts );
         dictForEach( src.artifacts, a => addArtifact( a, src, prefix ) );
+      }
     }
     else if (src.definitions) {      // CSN input
       prefix = '';
-      dictForEach( src.definitions, v => addDefinition( v, src ) );
+      dictForEach( shuffleDict( 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 ) );
+      dictForEach( shuffleDict( src.vocabularies ), v => addVocabulary( v, src, prefix ) );
     }
     if (src.extensions) {       // requires using to be known!
       src.extensions.forEach( e => addExtension( e, src ) );
@@ -341,6 +354,7 @@ function define( model ) {
       dictAddArray( src.artifacts, name, decl );
   }
 
+  // must be called after addUsing().
   function addNamespace( path, src ) {
     const absolute = pathName( path );
     if (path.broken) // parsing may have failed
@@ -405,10 +419,56 @@ function define( model ) {
     dictAdd( model.vocabularies, name.absolute, vocab );
   }
 
-  // Phase 2 ("init") --------------------------------------------------------
+  /**
+   * Add (optional) translations into the XSN model.
+   */
+  function addI18nBlocks() {
+    // TODO: the sequence should be in sync with extend / annotate / future $sources
+    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)
+      addI18nFromSource( model.sources[name] );
+  }
+
+  /**
+   * Add the source's translations to the model. Warns if the source's translations
+   * do not match the ones from previous sources.
+   *
+   * @param {XSN.SourceAst} src
+   */
+  function addI18nFromSource( 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: behave like annotation assignments?  message-id?
+          warning( 'i18n-different-value', sourceVal.location,
+                   { prop: textKey, otherprop: langKey } );
+        }
+      }
+    }
+  }
+
+  // Phase 2 ("init"), top-level & main -----------------------------------------
   // Functions called from top-level: initNamespaceAndUsing(), initArtifact(),
   // initVocabulary(), initExtension()
 
+  // TODO: message ids
   function checkRedefinition( art ) {
     if (!art.$duplicates || art.$errorReported === 'syntax-duplicate-extend' ||
         art.$errorReported === 'syntax-duplicate-annotate')
@@ -443,7 +503,7 @@ function define( model ) {
         // TODO: make it possible to have no location
         const ns = { kind: 'namespace', name: { absolute, location }, location };
         model.definitions[absolute] = ns;
-        initParentLink( ns, model.definitions );
+        initArtifactParentLink( ns, model.definitions );
       }
       const builtin = model.$builtins[id];
       if (builtin && !builtin.internal &&
@@ -471,7 +531,7 @@ function define( model ) {
 
   function initArtifact( art, reInit = false ) {
     if (!reInit)
-      initParentLink( art, model.definitions );
+      initArtifactParentLink( art, model.definitions );
     const block = art._block;
     checkRedefinition( art );
     initAnnotations( art, block );
@@ -489,27 +549,22 @@ function define( model ) {
     if (!setLink( art, '_leadingQuery', initQueryExpression( art.query, art ) ) )
       return;                   // null or undefined in case of parse error
     setLink( art._leadingQuery, '_$next', art );
-    // the following may 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
+      // TODO: consider this part of a revamped on-demand 'extend' functionality
       setLink( art, 'elements$', art.elements );
       delete art.elements;
     }
-    if (art.enum) { // specified enum via compilation of client-style CSN
-      setLink( art, 'enum$', art.enum );
-      delete art.enum;
-    }
   }
 
   function initVocabulary( art ) {
-    initParentLink( art, model.vocabularies );
+    initArtifactParentLink( art, model.vocabularies );
     checkRedefinition( art );
     const block = art._block;
     initAnnotations( art, block );
     initMembers( art, art, block );
   }
 
-  function initParentLink( art, definitions ) {
+  function initArtifactParentLink( art, definitions ) {
     setLink( art, '_parent', null );
     const { absolute } = art.name;
     const dot = absolute.lastIndexOf('.');
@@ -522,7 +577,7 @@ function define( model ) {
       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 );
+      initArtifactParentLink( parent, definitions );
     }
     setLink( art, '_parent', parent );
     if (!parent._subArtifacts)
@@ -540,7 +595,7 @@ function define( model ) {
    *  - for members in compile(): init annotations via extendMembers/annotateMembers
    *  - for members in parse.cdl(): init annotation via initMembers
    *
-   * In the future:
+   * In the future (after name cleanup):
    *
    *  - also initialize members and member extensions/annotations here
    *  - we might also do other things, like calculating whether an `extend` is
@@ -561,7 +616,7 @@ function define( model ) {
     // no _block: define, _block: annotate/extend/edmx
     // would fit with extending defs with props like length
     for (const prop in art) {
-      if (prop.charAt(0) === '@') {
+      if (prop.charAt(0) === '@' || prop === 'doc') {
         const anno = art[prop];
         // TODO: make anno never be an array, see addAnnotation() in genericAntlrParser
         if (Array.isArray( anno ))
@@ -582,11 +637,7 @@ function define( model ) {
     }
   }
 
-  // From here til EOF, reexamine code ---------------------------------------
-  // See populate:
-  // - userQuery() or _query property?
-  // - initFromColumns()
-  // - ensureColumnName()
+  // Init special things: -------------------------------------------------------
 
   function initDollarSelf( art ) {
     const selfname = '$self';
@@ -628,132 +679,76 @@ function define( model ) {
     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 );
-        initAnnotations( col, parent._block );
-        if (col.inline) { // `@anno elem.{ * }` does not work
-          if (col.doc) {
-            warning( 'syntax-ignoring-anno', [ col.doc.location, col ],
-                     { '#': 'doc', code: '.{ ‹inline› }' } );
-          }
-          // col.$annotations no available for CSN input, have to search.
-          // Warning about first annotation should be enough to avoid spam.
-          const firstAnno = Object.keys(col).find(key => key.startsWith('@'));
-          if (firstAnno) {
-            warning( 'syntax-ignoring-anno', [ col[firstAnno].name.location, col ],
-                     { code: '.{ ‹inline› }' } );
-          }
-        }
-        // TODO: allow sub queries? at least in top-level expand without parallel ref
-        if (columns)
-          initExprForQuery( col.value, parent );
-        initSelectItems( col, null, user );
-      }
-    }
+  // From here til EOF, reexamine code ---------------------------------------
+  // See populate:
+  // - userQuery() or _query property?
+  // - initFromColumns()
+  // - ensureColumnName()
 
-    if (hasItems && !wildcard && parent.excludingDict) {
-      // TODO: Better way to get source file?
-      let block = parent;
-      while (block._block)
-        block = block._block;
+  // Init queries: --------------------------------------------------------------
 
-      if (block.$frontend === 'cdl') {
-        warning('query-ignoring-exclude', [ parent.excludingDict[$location], user ],
-                { prop: '*' },
-                'Excluding elements without wildcard $(PROP) has no effect');
+  // 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)
+        initMixins( query, art );
+      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
     }
-  }
-
-  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 (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 if (expr.path && expr.$expected === 'exists') {
-      expr.$expected = 'approved-exists';
-      approveExistsInChildren(expr);
+    else { // with parse error (`select from <EOF>`, `select from E { *, ( select }`)
+      return undefined;
     }
-  }
+    return query._leadingQuery || query;
 
-  /**
-   * 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 forRelationalDB.
-   *
-   * 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) // may be null in case of parse error
-      return;
-    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));
+    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 new CompilerAssertion();
+      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 );
+    }
   }
 
   // table is table expression in FROM, becomes an alias
@@ -766,8 +761,8 @@ function define( model ) {
         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 );
+        const dot = last?.id?.lastIndexOf('.');
+        const id = (dot >= 0) ? last.id.substring( dot + 1 ) : last.id || '';
         // TODO: if we have too much time, we can calculate the real location with '.'
         table.name = { $inferred: 'as', id, location: last.location };
       }
@@ -847,117 +842,180 @@ function define( model ) {
     }
   }
 
-  // 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
+  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 initExprForQuery( expr, query ) {
+    if (Array.isArray(expr)) { // TODO: old-style $parens ?
+      expr.forEach( e => initExprForQuery( e, query ) );
     }
-    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 if (!expr) {
+      return;
     }
-    else { // with parse error (`select from <EOF>`, `select from E { *, ( select }`)
-      return undefined;
+    else if (expr.query) {
+      initQueryExpression( expr.query, query );
     }
-    return query._leadingQuery || 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') {
+      // TODO: does really the parser has to set $expected?
+      expr.$expected = 'approved-exists';
+      approveExistsInChildren(expr);
+    }
+  }
 
-    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 initMixins( query, art ) {
+    // 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( 'name-invalid-dollar-alias', [ mixin.name.location, mixin ],
+                   { '#': 'mixin', name: '$' } );
+        }
+      }
     }
+  }
 
-    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( 'name-invalid-dollar-alias', [ mixin.name.location, mixin ],
-                     { '#': 'mixin', name: '$' } );
+  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-wildcard', [ col.location, null ],
+                 {
+                   '#': (wildcard.location.col ? 'col' : 'std'),
+                   prop: '*',
+                   line: wildcard.location.line,
+                   col: wildcard.location.col,
+                 }, {
+                   std: 'You have provided a $(PROP) already in line $(LINE)',
+                   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 );
+        initAnnotations( col, parent._block );
+        if (col.inline) { // `@anno elem.{ * }` does not work
+          if (col.doc) {
+            warning( 'syntax-ignoring-anno', [ col.doc.location, col ],
+                     { '#': 'doc', code: '.{ ‹inline› }' } );
+          }
+          // col.$annotations no available for CSN input, have to search.
+          // Warning about first annotation should be enough to avoid spam.
+          const firstAnno = Object.keys(col).find(key => key.startsWith('@'));
+          if (firstAnno) {
+            warning( 'syntax-ignoring-anno', [ col[firstAnno].name.location, col ],
+                     { code: '.{ ‹inline› }' } );
           }
         }
+        // TODO: allow sub queries? at least in top-level expand without parallel ref
+        if (columns)
+          initExprForQuery( col.value, parent );
+        initSelectItems( col, null, user );
       }
     }
-  }
 
-  // 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 (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');
+      }
     }
-    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
   }
 
+  /**
+   * 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 forRelationalDB.
+   *
+   * 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) // may be null in case of parse error
+      return;
+    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));
+  }
+  // TODO: we might issue 'expr-unexpected-exists' and 'expr-no-subquery' already in
+  // define.js (using a to-be-written expression traversal function in utils.js)
+
+  // Members (elements, enum, actions, params): ---------------------------------
+
   /**
    * Set property `_parent` for all elements in `parent` to `parent` and do so
    * recursively for all sub elements.
    *
    * If not for extensions: construct === parent
+   *
+   * TODO: separate extension!
    */
   function initMembers( construct, parent, block, initExtensions = false ) {
     // TODO: split extend from init
-    const isQueryExtension = kindProperties[construct.kind].isExtension &&
-          (parent._main || parent).query;
+    const main = parent._main || parent;
+    const isQueryExtension = kindProperties[construct.kind].isExtension && main.query;
     let obj = construct;
     let { items } = obj;
     while (items) {
@@ -986,6 +1044,7 @@ function define( model ) {
         delete obj.on;          // continuation semantics: not specified
       }
       if (targetAspect.elements) {
+        // TODO: main?
         const inEntity = parent._main && parent._main.kind === 'entity';
         // TODO: also allow indirectly (component in component in entity)?
         setLink( targetAspect, '_outer', obj );
@@ -1025,16 +1084,8 @@ function define( model ) {
         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 );
+    if (obj !== parent && obj.elements && parent.enum) { // applying the extension
+      initElementsAsEnum();
     }
     else {
       if (checkDefinitions( construct, parent, 'elements', obj.elements || false ))
@@ -1056,6 +1107,28 @@ function define( model ) {
     }
     return;
 
+    function initElementsAsEnum() {
+      // in extensions, extended enums are represented as elements
+      for (const n in obj.elements) {
+        const e = obj.elements[n];
+        if (e.kind === 'element') {
+          // An "element" has `$syntax: 'enum'` if it could also be an enum
+          if (e.$syntax === 'enum') { // TODO: what about "just name"? (current forbidden)
+            e.kind = 'enum';
+          }
+          else {
+            // We do not want to complain separately about all element properties:
+            error( 'ext-unexpected-element', [ e.location, construct ],
+                   { name: e.name.id, code: 'extend … with enum' },
+                   // eslint-disable-next-line max-len
+                   'Unexpected elements like $(NAME) in an extension for an enum. Additionally, use $(CODE) when extending enums' );
+            return;
+          }
+        }
+      }
+      forEachGeneric( { enum: obj.elements }, 'enum', init );
+    }
+
     function init( elem, name, prop ) {
       if (!elem.kind)           // wrong CSN input
         elem.kind = dictKinds[prop];
@@ -1083,45 +1156,75 @@ function define( model ) {
 
       const bl = elem._block || block;
       setLink( elem, '_block', bl );
-      setMemberParent( elem, name, parent, construct !== parent && prop );
+      const existing = parent[prop]?.[name];
+      const add = construct !== parent && (!existing || elem.$inferred !== 'include');
+      setMemberParent( elem, name, parent, add && prop );
       // console.log(message( null, elem.location, elem, {}, 'Info', 'INIT').toString())
       checkRedefinition( elem );
       if (elem.kind === 'annotate' || elem.kind === 'extend')
         checkAnnotate( elem, elem );
       initAnnotations( elem, bl );
       initMembers( elem, elem, bl, initExtensions );
+      if (boundSelfParamType && (elem.kind === 'action' || elem.kind === 'function'))
+        initBoundSelfParam( elem.params );
 
       // 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: 'Can\'t extend type/entity elements with values',
-                 });
-          return;
+      if (!elem.value || elem.kind !== 'element' ||
+          elem.$syntax === 'enum' && parent.kind === 'extend') // ambiguous in parse-cdl
+        return;
+      // -> it's a calculated element
+      checkCalculatedElement(elem);
+      elem.$syntax = 'calc';
+    }
+  }
+
+  function checkCalculatedElement( elem ) {
+    const loc = [ elem.value.location, elem ];
+    if (elem._main.kind !== 'entity' && elem._main.kind !== 'aspect' &&
+        elem._main.kind !== 'extend') {
+      error( 'syntax-invalid-calc-elem', loc, { '#': elem._main.kind } );
+    }
+    else if (!isBetaEnabled( options, 'calculatedElements' )) {
+      error( 'def-unsupported-calc-elem', loc,
+             'Calculated elements are not supported' );
+    }
+    else {
+      const noTruthyAllowed = [ 'localized', 'key', 'virtual' ];
+      for (const prop of noTruthyAllowed) {
+        if (elem[prop]?.val) {
+          // probably better than a parse error (which is good for DEFAULT vs calc),
+          // also appears with parse-cdl:
+          error('syntax-invalid-calc-elem', loc, { '#': prop });
+          return; // one error is enough
         }
       }
+    }
+  }
 
-      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 initBoundSelfParam( params ) {
+    if (!params)
+      return;
+    if (boundSelfParamType === true) { // first try
+      const def = model.definitions.$self;
+      if (def) {
+        // TODO v4: bring this always, probably even as error
+        warning( 'name-deprecated-for-artifacts', [ def.location, def ], { name: '$self' },
+                 'Do not use $(NAME) as name for an artifact definition' );
+        boundSelfParamType = false;
+        return;
       }
+      boundSelfParamType = { name: { absolute: '$self' } };
     }
+    const first = params[Object.keys( params )[0] || ''];
+    const type = first?.type || first?.items?.type; // this sequence = no derived type
+    if (type?.path?.length === 1 && type?.path[0]?.id === '$self') // TODO: no where: ?
+      setLink( type, '_artifact', boundSelfParamType );
   }
 
+  // To be reworked -------------------------------------------------------------
+
+  // TODO: make special for extend/annotate
   function checkDefinitions( construct, parent, prop, dict = construct[prop] ) {
     // TODO: do differently, see also annotateMembers() in resolver
     // To have been checked by parsers:
@@ -1161,8 +1264,15 @@ function define( model ) {
       }
     }
     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' );
+      if (parent.$inferred === 'include') { // special case for better error message
+        const variant = (construct.enum || construct.elements) ? 'elements' : 'std';
+        error( 'ref-expected-direct-structure', [ location, construct ],
+               { '#': variant, art: parent });
+      }
+      else {
+        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 ], {},
@@ -1178,47 +1288,19 @@ function define( model ) {
     return construct === parent;
   }
 
-  /**
-   * Merge (optional) translations into the XSN model.
-   */
-  function mergeI18nBlocks() {
-    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 source's translations
-   * do not match the ones from previous sources.
-   *
-   * @param {XSN.SourceAst} 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) {
-          warning( 'i18n-different-value', sourceVal.location,
-                   { prop: textKey, otherprop: langKey } );
-        }
-      }
+  // 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
   }
 }