@sap/cds-compiler 6.4.2 → 6.5.0

package/lib/compiler/define.js

@@ -87,7 +87,8 @@
 // --------- TODO: end in extra markdown document -------------------------------
 
 // Sub phase 1 (addXYZ) - only for main artifacts
-//  - set _block links for main definitions, vocabulary and extensions
+//  - set _block links for main definitions, vocabulary, extensions and
+//    annotations on those
 //  - store definitions (including context extensions), NO duplicate check
 //  - artifact name check
 //  - Note: the only allow name resolving is resolveUncheckedPath(),
@@ -132,8 +133,13 @@ const {
 const { kindProperties, dictKinds } = require('./base');
 const {
   setLink,
+  initItemsLinks,
   setMemberParent,
   createAndLinkCalcDepElement,
+  initExprAnnoBlock,
+  initDollarSelf,
+  initDollarParameters,
+  initBoundSelfParam,
   storeExtension,
   dependsOnSilent,
   pathName,
@@ -173,12 +179,11 @@ function define( model ) {
     shuffleDict,
     shuffleArray,
     initArtifact,
-    initMembers,
+    initMembers,                // for finalize-parser-cdl.js
+    targetIsTargetAspect,
+    checkRedefinition,
     initSelectItems,
   } );
-
-  let boundSelfParamType = true; // special `$self` for binding param must still be initialised
-
   return doDefine();
 
   /**
@@ -204,16 +209,18 @@ function define( model ) {
     const sourceNames = shuffleArray( Object.keys( model.sources ) );
     for (const name of sourceNames)
       addSource( model.sources[name] );
+
+    // Phase 2:
     for (const name of sourceNames)
       initNamespaceAndUsing( model.sources[name] );
     dictForEach( model.definitions, initArtifact );
     dictForEach( model.vocabularies, initVocabulary );
     dictForEach( model.$collectedExtensions, e => e._extensions.forEach( initExtension ) );
 
-    addI18nBlocks();
+    addI18nBlocks();            // TODO: part of extend.js?
 
     const { $self } = model.definitions;
-    if ($self) {
+    if ($self && $self.kind !== 'namespace') { // TODO v7: non-config error
       message( 'name-deprecated-$self', [ $self.name.location, $self ], { name: '$self' },
                'Do not use $(NAME) as name for an artifact definition' );
     }
@@ -234,7 +241,7 @@ function define( model ) {
 
     let namespace = src.namespace?.name;
     let prefix = '';
-    if (namespace?.path && !namespace.path.broken) {
+    if (namespace?.path) {
       namespace.id = pathName( namespace.path );
       prefix = `${ namespace.id }.`;
     }
@@ -242,7 +249,7 @@ function define( model ) {
       error( 'reserved-namespace-cds', [ src.namespace.name.location, src.namespace.name ],
              { name: 'cds' },
              'The namespace $(NAME) is reserved for CDS builtins' );
-      namespace = null;
+      namespace = null;         // TODO: reconsider
     }
     if (src.$frontend !== 'json') { // CDL input
       // TODO: set _block to builtin
@@ -278,10 +285,12 @@ function define( model ) {
   }
 
   function addDefinition( art, block, prefix ) {
+    setLink( art, '_block', block );
+    initExprAnnoBlock( art, block );
     art.name.id ??= prefix + pathName( art.name.path );
     const absolute = art.name.id;
     // TODO: check reserved, see checkName()/checkLocalizedObjects() of checks.js
-    if (absolute === 'cds' || isInReservedNamespace( absolute )) {
+    if (isInReservedNamespace( absolute )) {
       error( 'reserved-namespace-cds', [ art.name.location, art ], { name: 'cds' },
              'The namespace $(NAME) is reserved for CDS builtins' );
       const builtin = model.definitions[absolute];
@@ -297,8 +306,6 @@ function define( model ) {
       }
       return;
     }
-    setLink( art, '_block', block );
-    initExprAnnoBlock( art, block );
     // dictAdd might set $duplicates
     dictAdd( model.definitions, absolute, art );
   }
@@ -345,7 +352,7 @@ function define( model ) {
       return;
     }
     const path = decl.extern?.path;
-    if (!path || path.broken || !path[0]) // syntax error
+    if (!path || !path[0]) // syntax error
       return;
     decl.extern.id = pathName( path );
     if (!decl.name)
@@ -354,7 +361,7 @@ function define( model ) {
     // TODO: check name: no "."
     const found = src.artifacts[name];
     // a real `using` declaration is “nicer” than a compiler-generated one:
-    if (found && found.$inferred === 'path-prefix' && found.extern.id === decl.extern.id)
+    if (found?.$inferred === 'path-prefix' && found.extern.id === decl.extern.id)
       src.artifacts[name] = decl;
     else
       dictAddArray( src.artifacts, name, decl );
@@ -418,57 +425,10 @@ function define( model ) {
     // Set block number for debugging (--raw-output):
     // eslint-disable-next-line no-multi-assign
     ext.$effectiveSeqNo = model.$blocks[absolute] = (model.$blocks[absolute] || 0) + 1;
-    // add "namespace" for the case that ext.artifacts is empty (TODO: later)
-    // now add all definitions in ext.artifacts:
     const prefix = `${ absolute }.`;
     dictForEach( ext.artifacts, a => addArtifact( a, ext, prefix ) );
   }
 
-  function initExtension( parent ) {
-    forEachMember( parent, function initExtensionMember( sub, name, prop ) {
-      if (sub.kind !== 'extend' && sub.kind !== 'annotate')
-        return;                 // for defs inside, set somewhere else - TODO: rethink
-      if (prop === 'params' && name === '') // RETURNS
-        sub.name = { id: '', location: sub.location };
-      setLink( sub, '_block', parent._block );
-      initExprAnnoBlock( sub, parent._block );
-      setLink( sub, '_parent', parent );
-      setLink( sub, '_main', parent._main || parent );
-      initExtension( sub );
-    } );
-    if (parent.kind !== 'extend')
-      return;
-    // TODO: sub queries? expand/inline?
-    parent.columns?.forEach( c => setLink( c, '_block', parent._block ) );
-    if (parent.scale && !parent.precision) {
-      // TODO: where could we store the location of the name?
-      error( 'syntax-missing-type-property', [ parent.scale.location ],
-             { prop: 'scale', otherprop: 'precision' },
-             'Type extension with property $(PROP) must also have property $(OTHERPROP)' );
-      parent.scale = undefined; // no consequential error
-    }
-  }
-
-  function initExprAnnoBlock( art, block ) {
-    // remark: `art` could also be the extension
-    for (const prop in art) {
-      if (prop.charAt(0) !== '@')
-        continue;
-      const anno = art[prop];
-      // _block links needed for `cast( … as Type )`, `[ ..., cast( … as Type ) ]`
-      if (anno.literal === 'array') {
-        anno.kind = '$annotation';
-        for (const item of anno.val)
-          setLink( item, '_block', block );
-      }
-      else if (anno.$tokenTexts) {
-        // remark: it wouldn't hurt to set it always...
-        anno.kind = '$annotation';
-        setLink( anno, '_block', block );
-      }
-    }
-  }
-
   function addVocabulary( vocab, block, prefix ) {
     setLink( vocab, '_block', block );
     const { name } = vocab;
@@ -476,6 +436,8 @@ function define( model ) {
     dictAdd( model.vocabularies, name.id, vocab );
   }
 
+  // I18n code (eventually part of extend.js) -----------------------------------
+
   /**
    * Add (optional) translations into the XSN model.
    */
@@ -525,29 +487,6 @@ function define( model ) {
   // Functions called from top-level: initNamespaceAndUsing(), initArtifact(),
   // initVocabulary(), initExtension()
 
-  // TODO: message ids
-  function checkRedefinition( art ) {
-    if (!art.$duplicates || !art.name.id ||
-        art.$errorReported === 'syntax-duplicate-extend')
-      return;
-    if (art.kind === 'annotate' || art.kind === 'extend')
-      return; // extensions are merged into a super-annotate; $duplicates are only kept for LSP
-    if (art._main) {
-      error( 'duplicate-definition', [ art.name.location, art ], {
-        name: art.name.id,
-        '#': kindProperties[art.kind].normalized || art.kind,
-      } );
-    }
-    else if (!art.builtin) {
-      // TODO: better messages with definitions with the same name as builtin,
-      // especially if there is just one
-      error( 'duplicate-definition', [ art.name.location, art ], {
-        name: art.name.id,
-        '#': (art.kind === 'annotation' ? 'annotation' : 'absolute' ),
-      } );
-    }
-  }
-
   function initNamespaceAndUsing( src ) {
     if (src.$frontend && src.$frontend !== 'cdl')
       return;
@@ -587,12 +526,11 @@ function define( model ) {
   }
 
   function initArtifact( art, reInit = false ) {
-    if (!reInit)
+    if (!reInit)                // not for auto-exposed entity
       initArtifactParentLink( art, model.definitions );
-    const block = art._block;
     checkRedefinition( art );
     initDollarSelf( art );      // $self
-    initMembers( art, art, block );
+    initMembers( art );
     if (art.params)
       initDollarParameters( art ); // $parameters
     if (art.query) {
@@ -601,9 +539,105 @@ function define( model ) {
     }
   }
 
+  function initVocabulary( art ) {
+    initArtifactParentLink( art, model.vocabularies );
+    checkRedefinition( art );
+    initMembers( art );
+
+    if (art.query) {
+      initArtifactQuery( art );
+      error( 'def-unsupported-projection', [ art.location, art ], null,
+             'Projections for annotation definitions are not supported' );
+    }
+  }
+
+  function initExtension( parent ) {
+    // TODO: re-think
+    forEachMember( parent, function initExtensionMember( sub, name, prop ) {
+      if (sub.kind !== 'extend' && sub.kind !== 'annotate')
+        return;                 // for defs inside, set somewhere else - TODO: rethink
+      if (prop === 'params' && name === '') // RETURNS
+        sub.name = { id: '', location: sub.location };
+      setLink( sub, '_block', parent._block );
+      initExprAnnoBlock( sub, parent._block );
+      setLink( sub, '_parent', parent );
+      setLink( sub, '_main', parent._main || parent );
+      initExtension( sub );
+    } );
+    if (parent.kind !== 'extend')
+      return;
+    // TODO: sub queries? expand/inline?
+    parent.columns?.forEach( c => setLink( c, '_block', parent._block ) );
+    if (parent.scale && !parent.precision) {
+      // TODO: where could we store the location of the name?
+      error( 'syntax-missing-type-property', [ parent.scale.location ],
+             { prop: 'scale', otherprop: 'precision' },
+             'Type extension with property $(PROP) must also have property $(OTHERPROP)' );
+      parent.scale = undefined; // no consequential error
+    }
+  }
+
+  /**
+   * Make the `_parent` pointer of artifact `A.B.C` point to `A.B`.  If no `A.B`
+   * exists in XSN.definitions, create an artifact with kind `namespace` (better
+   * would be `$gap`).  Add `A.B.C` to the `_subArtifacts` dictionary of `A.B`.
+   * Do recursively if necessary, `_parent` of `A.B` is `A` in this example.
+   */
+  function initArtifactParentLink( art, definitions, path, pathIndex ) {
+    setLink( art, '_parent', null );
+    const { id } = art.name;
+    const dot = id.lastIndexOf( '.' );
+    if (dot < 0)
+      return;
+    const prefix = id.substring( 0, dot );
+    let parent = definitions[prefix];
+    if (!parent) {
+      path ??= art.name.path;
+      pathIndex ??= path?.length - 1;
+      const pathItemOrName = (path && pathIndex) ? path[--pathIndex] : art.name;
+      const location = weakLocation( pathItemOrName.location );
+      parent = { kind: 'namespace', name: { id: prefix, location }, location };
+      definitions[prefix] = parent;
+      initArtifactParentLink( parent, definitions, path, pathIndex );
+    }
+    setLink( art, '_parent', parent );
+    if (!parent._subArtifacts)
+      setLink( parent, '_subArtifacts', Object.create( null ) );
+    if (art.$duplicates !== true) // no redef or "first def"
+      parent._subArtifacts[id.substring( dot + 1 )] = art; // not dictAdd()
+  }
+
+  // TODO: message ids
+  // Called by initArtifact() and initVocabulary() and for members
+  function checkRedefinition( art ) {
+    if (art.kind === 'annotate' || art.kind === 'extend') // move this check to call in extend.js?
+      return; // extensions are merged into a super-annotate; $duplicates are only kept for LSP
+    if (!art.$duplicates || !art.name.id ||
+        art.$errorReported === 'syntax-duplicate-extend')
+      return;
+    if (art._main) {
+      error( 'duplicate-definition', [ art.name.location, art ], {
+        name: art.name.id,
+        '#': kindProperties[art.kind].normalized || art.kind,
+      } );
+    }
+    else if (!art.builtin) {
+      // TODO: better messages with definitions with the same name as builtin,
+      // especially if there is just one
+      error( 'duplicate-definition', [ art.name.location, art ], {
+        name: art.name.id,
+        '#': (art.kind === 'annotation' ? 'annotation' : 'absolute' ),
+      } );
+    }
+  }
+
+  // Phase 2, init queries ------------------------------------------------------
+
   /**
    * Restrict the query of `art` to only simple projections, i.e. those without 'group by', etc.
    *
+   * TODO v8 and for `type`: do in parsers
+   *
    * @param {XSN.Artifact} art
    */
   function restrictToSimpleProjection( art ) {
@@ -659,88 +693,6 @@ function define( model ) {
     }
   }
 
-  function initVocabulary( art ) {
-    initArtifactParentLink( art, model.vocabularies );
-    checkRedefinition( art );
-    const block = art._block;
-    initMembers( art, art, block );
-
-    if (art.query) {
-      initArtifactQuery( art );
-      error( 'def-unsupported-projection', [ art.location, art ], null,
-             'Projections for annotation definitions are not supported' );
-    }
-  }
-
-  function initArtifactParentLink( art, definitions, path, pathIndex ) {
-    setLink( art, '_parent', null );
-    const { id } = art.name;
-    const dot = id.lastIndexOf( '.' );
-    if (dot < 0)
-      return;
-    const prefix = id.substring( 0, dot );
-    let parent = definitions[prefix];
-    if (!parent) {
-      path ??= art.name.path;
-      pathIndex ??= path?.length - 1;
-      const pathItemOrName = (path && pathIndex) ? path[--pathIndex] : art.name;
-      const location = weakLocation( pathItemOrName.location );
-      parent = { kind: 'namespace', name: { id: prefix, location }, location };
-      definitions[prefix] = parent;
-      initArtifactParentLink( parent, definitions, path, pathIndex );
-    }
-    setLink( art, '_parent', parent );
-    if (!parent._subArtifacts)
-      setLink( parent, '_subArtifacts', Object.create( null ) );
-    if (art.$duplicates !== true) // no redef or "first def"
-      parent._subArtifacts[id.substring( dot + 1 )] = art; // not dictAdd()
-  }
-
-  // Init special things: -------------------------------------------------------
-
-  function initDollarSelf( art ) {
-    // TODO: use setMemberParent() ?
-    const self = {
-      name: { id: '$self', location: art.location },
-      kind: '$self',
-      location: art.location,
-    };
-    setLink( self, '_parent', art );
-    setLink( self, '_main', art ); // used on main artifact
-    setLink( self, '_origin', art );
-    art.$tableAliases = Object.create( null );
-    art.$tableAliases.$self = self;
-  }
-
-  function initDollarParameters( art ) {
-    // TODO: use setMemberParent() ?
-    const parameters = {
-      name: { id: '$parameters' },
-      kind: '$parameters',
-      location: art.location,
-      deprecated: true, // hide in code completion
-    };
-    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;
-  }
-
-  // From here til EOF, reexamine code ---------------------------------------
-  // See populate:
-  // - userQuery() or _query property?
-  // - initFromColumns()
-  // - ensureColumnName()
-
-  // Init queries: --------------------------------------------------------------
-
   // art is:
   // - entity/event/type for top-level queries (including UNION args)
   // - $tableAlias for sub query in FROM - TODO: what about UNION there?
@@ -749,7 +701,7 @@ function define( model ) {
     if (!query)                 // parse error
       return query;
     if (query.from) {      // select
-      initQuery();
+      initQuery( query, art );
       initTableExpression( query.from, query, [] );
       if (query.mixin)
         initMixins( query, art );
@@ -794,21 +746,21 @@ function define( model ) {
       return undefined;
     }
     return query._leadingQuery || query;
+  }
 
-    function initQuery() {
-      const main = art._main || art;
-      setLink( query, '_$next',
-               (art.kind === '$tableAlias' ? art._parent._$next : art ) );
-      setLink( query, '_block', art._block );
-      query.kind = 'select';
-      query.name = { location: query.location, id: main.$queries.length + 1 };
-      setMemberParent( query, null, main );
-      // console.log(art.kind,art.name,query.name,query._$next.name)
-      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 initQuery( query, art ) {
+    setLink( query, '_block', art._block );
+    const main = art._main || art;
+    setLink( query, '_$next',
+             (art.kind === '$tableAlias' ? art._parent._$next : art ) );
+    query.kind = 'select';
+    query.name = { location: query.location, id: main.$queries.length + 1 };
+    setMemberParent( query, null, main );
+    // console.log(art.kind,art.name,query.name,query._$next.name)
+    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
@@ -816,7 +768,7 @@ function define( model ) {
     if (!table)                 // parse error
       return;
     if (table.path) {           // path in FROM
-      if (!table.path.length || table.path.broken)
+      if (!table.path.length)
         // parse error (e.g. final ',' in FROM), projection on <eof>
         return;
       if (!table.name) {
@@ -826,7 +778,7 @@ function define( model ) {
         // TODO: if we have too much time, we can calculate the real location with '.'
         table.name = { $inferred: 'as', id, location: last.location };
       }
-      addAsAlias();
+      addAsAlias( table, query, joinParents );
       // _origin is set when we resolve the ref
       if (query._parent.kind !== 'select')
         query._main._from.push( table ); // store tabref if outside "real" subquery
@@ -838,7 +790,7 @@ function define( model ) {
         const id = `$_select_${ query._main.$queries.length + 1 }__`;
         table.name = { id, location: table.location, $inferred: '$internal' };
       }
-      addAsAlias();
+      addAsAlias( table, query, joinParents );
       // Store _origin to leading query of table.query for name resolution
       setLink( table, '_origin', initQueryExpression( table.query, table ) );
     }
@@ -878,37 +830,36 @@ function define( model ) {
         // 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, tableAlias ) => {
-        if (tableAlias.name.$inferred === '$internal') {
-          const semanticLoc = tableAlias.query?.name ? tableAlias.query : tableAlias;
-          // TODO: the semanticLoc query is not initialized yet, and thus cannot
-          // be used here
-          error( 'name-missing-alias', [ tableAlias.location, semanticLoc ],
-                 { '#': 'duplicate', code: 'as ‹alias›' } );
-        }
-        else {
-          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 );
+  function addAsAlias( table, query, joinParents ) {
+    table.kind = '$tableAlias';
+    setLink( table, '_block', query._block );
+    setMemberParent( table, table.name.id, query );
+    dictAdd( query.$tableAliases, table.name.id, table, ( name, loc, tableAlias ) => {
+      if (tableAlias.name.$inferred === '$internal') {
+        const semanticLoc = tableAlias.query?.name ? tableAlias.query : tableAlias;
+        // TODO: the semanticLoc query is not initialized yet, and thus cannot
+        // be used here
+        error( 'name-missing-alias', [ tableAlias.location, semanticLoc ],
+               { '#': 'duplicate', code: 'as ‹alias›' } );
       }
-      if (table.name?.id[0] === '$' && table.name.$inferred !== '$internal') {
-        message( 'name-invalid-dollar-alias', [ table.name.location, table ], {
-          '#': (table.name.$inferred ? '$tableImplicit' : '$tableAlias'),
-          name: '$',
-          keyword: 'as',
-        } );
+      else {
+        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] === '$' && table.name.$inferred !== '$internal') {
+      message( 'name-invalid-dollar-alias', [ table.name.location, table ], {
+        '#': (table.name.$inferred ? '$tableImplicit' : '$tableAlias'),
+        name: '$',
+        keyword: 'as',
+      } );
     }
   }
 
@@ -921,7 +872,7 @@ function define( model ) {
       initExprForQuery( query.where, query );
     if (query.having)
       initExprForQuery( query.having, query );
-    initMembers( query, query, query._block );
+    initMembers( query );
   }
 
   function initExprForQuery( expr, query ) {
@@ -939,11 +890,6 @@ function define( model ) {
       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 initMixins( query, art ) {
@@ -972,15 +918,18 @@ function define( model ) {
     let wildcard = !!inExtension; // no `extend … with columns { * }`
     // TODO: forbid expand/inline in ref-where, outside queries (CSN), ...
     let hasItems = false;
+    let colIndex = 0;
     for (const col of columns || parent.expand || parent.inline || []) {
+      ++colIndex;
       if (!col)                 // parse error
         continue;
       hasItems = true;
       if (!columns) {           // expand or inline
         if (parent.value)
-          setLink( col, '_columnParent', parent ); // also set for '*' in expand/inline
+          setLink( col, '_columnParent', parent ); // TODO?: also set for '*' in expand/inline
         else if (parent._columnParent)
           setLink( col, '_columnParent', parent._columnParent );
+        // colParent not set for `{ col } as struct`, except if that is in expand/inline
       }
       if (col.val === '*') {
         if (!wildcard) {
@@ -1009,10 +958,13 @@ function define( model ) {
         }
       }
       // Either expression (value), expand, new virtual or new association
-      else if (col.value || col.name) {
+      else {
         col.kind = 'element';
         if (!col._block)
           setLink( col, '_block', parent._block );
+        setMemberParent( col, null, parent );
+        // remark: _parent might be change if col is in expand of to-many assoc
+        ensureColumnName( col, colIndex, parent, !columns );
         if (col.inline) { // `@anno elem.{ * }` does not work
           if (col.doc) {
             message( 'syntax-unexpected-anno', [ col.doc.location, col ],
@@ -1029,7 +981,8 @@ function define( model ) {
         // TODO: allow sub queries? at least in top-level expand without parallel ref
         if (columns && !inExtension) // not (yet) in `extend … with columns {…}`
           initExprForQuery( col.value, parent );
-        initSelectItems( col, null, user ); // TODO: use col as user (i.e. remove param)
+        if (col.expand || col.inline)
+          initSelectItems( col, null, user ); // TODO: use col, remove 3rd param?
       }
 
       initCdlTypeCast( col, parent );
@@ -1044,76 +997,81 @@ function define( model ) {
     }
   }
 
+  /**
+   * Ensure that the column has a name.
+   *
+   * @param col
+   * @param {number} colIndex
+   * @param query
+   * @param {boolean} insideExpand
+   *     Whether the column is inside 'expand'.
+   *     Anonymous 'expands' don't have a column parent, hence why we need to know this explicitly.
+   */
+  function ensureColumnName( col, colIndex, query, insideExpand ) {
+    if (col.name)
+      return col.name.id;
+    if (col.inline || col.val === '*' || col.val === '**') // '**' = duplicate '*'
+      return '';
+    // TODO: should we give technical name (colIndex) for error messages?
+    const path = col.value &&
+        (col.value.path || !col.value.args && col.value.func?.path);
+    const last = path?.length && path[path.length - 1];
+    if (last) {
+      col.name = { id: last.id || '', location: last.location, $inferred: 'as' };
+      return col.name.id;
+    }
+    else if ((col.expand || col.value) &&
+             !path &&           // no parse error (path without last item)
+             (insideExpand || query._parent.kind !== 'select')) { // not sub-selects
+      error( 'query-req-name',
+             // TODO: message function: `query` should work directly
+             [ (col.value || col).location, (query.name ? query : query._parent ) ],
+             {},
+             'Alias name is required for this select item' );
+    }
+    col.name = {
+      // NOTE: If the alias is changed, corresponding name-clash tests must be updated as well!
+      id: `$_column_${ colIndex }`,
+      location: (col.value || col).location,
+      $inferred: '$internal',
+    };
+    return col.name.id;
+  }
+
   function initCdlTypeCast( col, parent ) {
     if (col.val)
       return; // e.g. '*' column
 
     setMemberParent( col, col.name, parent );
-    initMembers( col, col, col._block );
+    initMembers( col );
 
     // We don't allow CDL-style casts to anonymous structures.  We reject it already here
     // and not in checks.js to ensure that it's rejected in parseCdl.
+    // TODO: via <guard> in CdlGrammar.g4
     if (col.elements) {
-      error('type-invalid-cast', [ col.elements[$location] ?? col.location, col ],
-            { '#': 'to-inline-structure' });
+      error( 'type-invalid-cast', [ (col.elements[$location] ?? col.location), col ],
+             { '#': 'to-inline-structure' } );
     }
     else if (col.expand && (col.type || col.elements || col.items)) {
       const loc = (col.type?.location || col.elements?.[$location] ||
-        col.items?.location || col.location);
-      error('type-invalid-cast', [ loc, col ], { '#': 'expand' });
+                   col.items?.location || col.location);
+      error( 'type-invalid-cast', [ loc, col ], { '#': 'expand' } );
     }
+    // Remark: there are quite a few consequential error, TODO: avoid them
   }
 
-  /**
-   * 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 (Array.isArray(exprOrPathElement.args))
-      exprOrPathElement.args.forEach( elem => approveExistsInChildren( elem ) );
-    else if (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
-   *
    * Param `initExtensions` is for parse.cdl - TODO delete
-   *
-   * TODO: separate extension!
    */
-  function initMembers( construct, parent, block, initExtensions = false ) {
-    // TODO: split extend from init
-    const main = parent._main || parent;
-    const isQueryExtension = construct.kind === 'extend' && main.query;
-    let obj = initItemsLinks( construct, block );
-    initExprAnnoBlock( construct, block );
+  function initMembers( parent, initExtensions = false ) {
+    const block = parent._block;
+    let obj = initItemsLinks( parent, block );
+    initExprAnnoBlock( parent, block );
     if (obj.target && targetIsTargetAspect( obj )) {
       obj.targetAspect = obj.target;
       delete obj.target;
@@ -1121,74 +1079,30 @@ function define( model ) {
     const { targetAspect } = obj;
     if (targetAspect) {
       if (obj.foreignKeys) {
-        error( 'type-unexpected-foreign-keys', [ obj.foreignKeys[$location], construct ] );
+        error( 'type-unexpected-foreign-keys', [ obj.foreignKeys[$location], parent ] );
         delete obj.foreignKeys; // continuation semantics: not specified
       }
       if (obj.on && !obj.target) {
-        error( 'type-unexpected-on-condition', [ obj.on.location, construct ] );
+        error( 'type-unexpected-on-condition', [ obj.on.location, parent ] );
         delete obj.on;          // continuation semantics: not specified
       }
       if (targetAspect.elements)
         initAnonymousAspect();
     }
-    if (obj !== parent && obj.elements && parent.enum) { // applying the extension
-      initElementsAsEnum();
-    }
-    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 );
-    }
+    forEachInOrder( obj, 'elements', init );
+    forEachGeneric( obj, 'enum', init );
+    forEachInOrder( obj, 'foreignKeys', init );
+    forEachGeneric( parent, 'actions', init );
+    forEachInOrder( parent, 'params', init );
 
-    if (obj.foreignKeys)
-      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;
+    const { returns } = parent;
     if (returns) {
-      const { kind } = construct;
+      const { kind } = parent;
       returns.kind = (kind === 'extend' || kind === 'annotate') ? kind : 'param';
       init( returns, '' );      // '' is special name for returns parameter
     }
     return;
 
-    function initElementsAsEnum() {
-      // in extensions, extended enums are represented as elements
-      let hasElement = false;
-      for (const n in obj.elements) {
-        const e = obj.elements[n];
-        if (e.kind === 'extend')
-          continue;
-        const noVal = e.value?.val === undefined && e.value?.sym === undefined;
-        // TODO: forbid #symbol as enum value
-        if (e.$syntax === 'element' || // `extend … with elements` or `extend with { element … }`
-            noVal && e.$syntax !== 'enum' || // no value in CDL input
-            e.virtual || e.key || e.masked || e.type || e.elements || e.items || e.stored) {
-          // 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 @stylistic/max-len
-                 'Unexpected elements like $(NAME) in an extension for an enum. Additionally, use $(CODE) when extending enums' );
-          // Don't emit 'ext-expecting-enum' if this error is emitted.
-          return;
-        }
-        e.kind = 'enum';
-        if (noVal || e.$syntax !== 'enum')
-          hasElement = true;    // warning with CDL input or `name: {}` in CSN input
-      }
-      if (hasElement) {
-        // This message is similar to the one above.  In v6, we could probably
-        // turn this warning into an error, remove `$syntax: 'element',
-        // and use the above `ext-unexpected-element` only for CSN input.
-        warning( 'ext-expecting-enum', [ obj.elements[$location], construct ],
-                 { code: 'extend … with enum' }, 'Use $(CODE) when extending enums' );
-      }
-      forEachGeneric( { enum: obj.elements }, 'enum', init );
-    }
-
     function initAnonymousAspect() {
       // TODO: main?
       const inEntity = parent._main?.kind === 'entity';
@@ -1198,7 +1112,6 @@ function define( model ) {
       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 );
@@ -1243,24 +1156,15 @@ function define( model ) {
         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 );
-      const existing = parent[prop]?.[name];
-      const add = construct !== parent && (!existing || elem.$inferred !== 'include');
+
       // don't dump with `entity T {}; extend T with { extend e {}; e {}; e {} };`:
-      if (elem.$duplicates === true && add)
-        elem.$duplicates = null;
-      setMemberParent( elem, name, parent, add && prop );
+      setMemberParent( elem, name, parent );
       checkRedefinition( elem );
-      initMembers( elem, elem, bl, initExtensions );
-      if (boundSelfParamType && (elem.kind === 'action' || elem.kind === 'function'))
+      initMembers( elem, initExtensions );
+      if (elem.kind === 'action' || elem.kind === 'function')
         initBoundSelfParam( elem.params, elem._main );
 
       // for a correct home path, setMemberParent needed to be called
@@ -1269,7 +1173,7 @@ function define( model ) {
           elem.$syntax === 'enum' && parent.kind === 'extend') // ambiguous in parse-cdl
         return;
       // -> it's a calculated element
-      if (!elem.type && elem.value?.type) {  // top-level CAST( expr AS type )
+      if (!elem.type && elem.value.type) {  // top-level CAST( expr AS type )
         if (!elem.target)
           elem.type = { ...elem.value.type, $inferred: 'cast' };
       }
@@ -1279,6 +1183,7 @@ function define( model ) {
 
       // Special case (hack) for calculated elements that use composition+filter:
       // See "Notes on `$enclosed`" in `ExposingAssocWithFilter.md` for details.
+      // TODO: hm, only for inferred type - then just do not infer it in that case
       if (elem.target && elem.value.path?.[elem.value.path.length - 1]?.where) {
         delete elem.type;
         delete elem.on;
@@ -1287,126 +1192,6 @@ function define( model ) {
     }
   }
 
-  function initBoundSelfParam( params, main ) {
-    if (!params)
-      return;
-    if (boundSelfParamType === true) { // first try
-      const def = model.definitions.$self;
-      if (def) {
-        boundSelfParamType = false;
-        return;
-      }
-      boundSelfParamType = '$self';
-    }
-    const first = params[Object.keys( params )[0] || ''];
-    const type = first?.type || first?.items?.type; // this sequence = no derived type
-    const path = type?.path;
-    if (path?.length === 1 && path[0]?.id === '$self') { // TODO: no where: ?
-      const $self = main.$tableAliases?.$self ||
-                    main.kind === 'extend' && { name: { id: '$self' } };
-      // remark: an 'extend' has no "table alias" `$self` (relevant for parse-cdl)
-      setLink( type, '_artifact', $self );
-      setLink( path[0], '_artifact', $self );
-    }
-  }
-
-  /**
-   * Initialize artifact links inside `obj.items` (for nested ones as well).
-   * Does nothing, it `obj.items` does not exist.
-   *
-   * @param {XSN.Artifact} obj
-   * @param {object} block
-   * @return {XSN.Artifact}
-   */
-  function initItemsLinks( obj, block ) {
-    let { items } = obj;
-    while (items) {
-      setLink( items, '_outer', obj );
-      setLink( items, '_parent', obj._parent );
-      setLink( items, '_block', block );
-      obj = items;
-      items = obj.items;
-    }
-    return obj;
-  }
-
-  // To be reworked -------------------------------------------------------------
-
-  // TODO: is only necessary for extensions - 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:
-    // - artifacts (CDL-only anyway) only inside [extend] context|service
-    if (!dict)
-      return false;
-    const feature = kindProperties[parent.kind ?? 'element'][prop];
-    if (feature &&
-        (feature === true || construct.kind !== 'extend' || feature( prop, parent )))
-      return true;
-    const location = dict[$location];
-
-    // TODO: a bit inconsistent = not a simple switch on `prop`…
-    if (prop === 'actions') {
-      if (Object.keys( dict ).length) {
-        error( 'def-unexpected-actions', [ location, construct ], {}, // TODO: ext-
-               'Actions and functions only exist top-level and for entities' ); // or aspects
-      }
-      else {
-        warning( 'ext-ignoring-actions', [ location, construct ], {},
-                 'Actions and functions only exist top-level and for entities' );
-        return false;
-      }
-    }
-    else if (parent.kind === 'action' || parent.kind === 'function') {
-      error( 'ext-unexpected-action', [ construct.location, construct ], { '#': parent.kind }, {
-        std: 'Actions and functions can\'t be extended, only annotated', // TODO: → ext-unsupported
-        action: 'Actions can\'t be extended, only annotated',
-        function: '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( 'def-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
-      if (!Object.keys( dict ).length) {
-        warning( 'ext-ignoring-elements', [ location, construct ], {},
-                 'Only structures with directly specified elements can be extended by elements' );
-        return false;
-      }
-      else 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( 'def-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( 'def-unexpected-enum', [ location, construct ], {},
-             'Enum symbols can only be defined for types or typed constructs' );
-    }
-    return construct === parent;
-  }
-
   /**
    * Return whether the `target` is actually a `targetAspect`
    */