@sap/cds-compiler 6.4.6 → 6.5.2

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,9 +133,13 @@ const {
 const { kindProperties, dictKinds } = require('./base');
 const {
   setLink,
+  initItemsLinks,
   setMemberParent,
   createAndLinkCalcDepElement,
-  storeExtension,
+  initExprAnnoBlock,
+  initDollarSelf,
+  initDollarParameters,
+  initBoundSelfParam,
   dependsOnSilent,
   pathName,
   targetCantBeAspect,
@@ -172,13 +177,12 @@ function define( model ) {
   Object.assign( model.$functions, {
     shuffleDict,
     shuffleArray,
-    initArtifact,
-    initMembers,
+    initMainArtifact,
+    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 +208,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.definitions, initMainArtifact );
     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 +240,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,12 +248,12 @@ 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
       if (src.artifacts) {
-        // addArtifact() adds usings to src.artifacts: shuffleDict must be assigned first
+        // addBlockArtifact() adds usings to src.artifacts: shuffleDict must be assigned first
         src.artifacts = shuffleDict( src.artifacts );
         addPathPrefixes( src.artifacts, prefix ); // before addUsing
       }
@@ -258,14 +264,14 @@ function define( model ) {
         shuffleArray( src.usings ).forEach( u => addUsing( u, src ) );
       if (namespace?.id)        // successfully set a full name for namespace
         addNamespace( namespace, src );
-      if (src.artifacts) {      // addArtifact needs usings for context extensions
+      if (src.artifacts) {      // addBlockArtifact needs usings for context extensions
         src.artifacts = shuffleDict( src.artifacts );
-        dictForEach( src.artifacts, a => addArtifact( a, src, prefix ) );
+        dictForEach( src.artifacts, a => addBlockArtifact( a, src, prefix ) );
       }
     }
     else if (src.definitions) {      // CSN input
       prefix = '';                   // also for addVocabulary() below
-      dictForEach( shuffleDict( src.definitions ), def => addDefinition( def, src, prefix ) );
+      dictForEach( shuffleDict( src.definitions ), def => addMainArtifact( def, src, prefix ) );
     }
     if (src.vocabularies) {
       if (!model.vocabularies)
@@ -277,11 +283,13 @@ function define( model ) {
     }
   }
 
-  function addDefinition( art, block, prefix ) {
+  function addMainArtifact( 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 +305,6 @@ function define( model ) {
       }
       return;
     }
-    setLink( art, '_block', block );
-    initExprAnnoBlock( art, block );
     // dictAdd might set $duplicates
     dictAdd( model.definitions, absolute, art );
   }
@@ -345,7 +351,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 +360,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 );
@@ -377,15 +383,15 @@ function define( model ) {
       $inferred: 'namespace',
     };
   }
-  function addArtifact( art, block, prefix ) {
+  function addBlockArtifact( art, block, prefix ) {
     if (art.kind === 'using')
       return;
-    addDefinition( art, block, prefix );
+    addMainArtifact( art, block, prefix );
     if (art.artifacts) {
       const p = `${ art.name.id }.`;
       // path prefixes (usings) must be added before extensions in artifacts:
       addPathPrefixes( art.artifacts, p );
-      dictForEach( art.artifacts, a => addArtifact( a, art, p ) );
+      dictForEach( art.artifacts, a => addBlockArtifact( a, art, p ) );
     }
     if (art.extensions) {       // requires using to be known!
       art.extensions.forEach( e => e.name && addExtension( e, art ) );
@@ -418,55 +424,8 @@ 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 );
-      }
-    }
+    dictForEach( ext.artifacts, a => addBlockArtifact( a, ext, prefix ) );
   }
 
   function addVocabulary( vocab, block, prefix ) {
@@ -476,6 +435,8 @@ function define( model ) {
     dictAdd( model.vocabularies, name.id, vocab );
   }
 
+  // I18n code (eventually part of extend.js) -----------------------------------
+
   /**
    * Add (optional) translations into the XSN model.
    */
@@ -522,32 +483,9 @@ function define( model ) {
   }
 
   // Phase 2 ("init"), top-level & main -----------------------------------------
-  // Functions called from top-level: initNamespaceAndUsing(), initArtifact(),
+  // Functions called from top-level: initNamespaceAndUsing(), initMainArtifact(),
   // 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;
@@ -586,13 +524,12 @@ function define( model ) {
     }
   }
 
-  function initArtifact( art, reInit = false ) {
-    if (!reInit)
+  function initMainArtifact( art, reInit = false ) {
+    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 +538,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 initMainArtifact() 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 +692,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 +700,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 +745,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 +767,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 +777,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 +789,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 +829,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 +871,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 +889,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 +917,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 +957,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,10 +980,12 @@ 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 );
+        initMembers( col );      // with #13933, TODO: only for enums
+        checkCdlTypeCast( col );
+      }
     }
 
     if (hasItems && !wildcard && parent.excludingDict && !options.$recompile) {
@@ -1044,76 +997,75 @@ function define( model ) {
     }
   }
 
-  function initCdlTypeCast( col, parent ) {
-    if (col.val)
-      return; // e.g. '*' column
-
-    setMemberParent( col, col.name, parent );
-    initMembers( col, col, col._block );
+  /**
+   * 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 checkCdlTypeCast( col ) { // with #13933:
     // 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)) {
+    else if (col.expand && (col.type || 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 ) {
+    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,290 +1073,110 @@ 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 );
+      if (targetAspect.elements) // eslint-disable-next-line no-multi-assign
+        parent = obj = initAnonymousAspect( parent, obj, targetAspect );
     }
+    forEachInOrder( obj, 'elements', (...args) => initArtifact( parent, ...args ) );
+    forEachGeneric( obj, 'enum', (...args) => initArtifact( parent, ...args ) );
+    forEachInOrder( obj, 'foreignKeys', (...args) => initArtifact( parent, ...args ) );
+    forEachGeneric( parent, 'actions', (...args) => initArtifact( parent, ...args ) );
+    forEachInOrder( parent, 'params', (...args) => initArtifact( parent, ...args ) );
 
-    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
+      initArtifact( parent, 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';
-      // 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_' },
-          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;
-    }
-
-    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 {                  // RETURNS, parser robustness
-          elem.name = { id: name, location: elem.location };
-        }
-      }
-      // if (!kindProperties[ elem.kind ]) console.log(elem.kind,elem.name)
-      if ((elem.kind === 'extend' || elem.kind === 'annotate') && !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 );
-      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 );
-      checkRedefinition( elem );
-      initMembers( elem, elem, bl, initExtensions );
-      if (boundSelfParamType && (elem.kind === 'action' || elem.kind === 'function'))
-        initBoundSelfParam( elem.params, elem._main );
-
-      // for a correct home path, setMemberParent needed to be called
-
-      if (!elem.value || elem.kind !== 'element' ||
-          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.target)
-          elem.type = { ...elem.value.type, $inferred: 'cast' };
-      }
-      elem.$syntax = 'calc';
-      // TODO: it is not just "syntax" - maybe better test for `$calcDepElement`?
-      createAndLinkCalcDepElement( elem );
-
-      // Special case (hack) for calculated elements that use composition+filter:
-      // See "Notes on `$enclosed`" in `ExposingAssocWithFilter.md` for details.
-      if (elem.target && elem.value.path?.[elem.value.path.length - 1]?.where) {
-        delete elem.type;
-        delete elem.on;
-        delete elem.target;
-      }
-    }
+  function initAnonymousAspect( parent, obj, targetAspect ) {
+    // TODO: main?
+    const inEntity = 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
+
+    targetAspect.kind = 'aspect';   // TODO: probably '$aspect' to detect
+    setLink( targetAspect, '_block', parent._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_' },
+        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;
+    }
+    return targetAspect;
   }
 
-  function initBoundSelfParam( params, main ) {
-    if (!params)
-      return;
-    if (boundSelfParamType === true) { // first try
-      const def = model.definitions.$self;
-      if (def) {
-        boundSelfParamType = false;
-        return;
+  function initArtifact( parent, 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 {                  // RETURNS, parser robustness
+        elem.name = { id: name, location: elem.location };
       }
-      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;
-  }
+    if (!elem._block)
+      setLink( elem, '_block', parent._block );
 
-  // To be reworked -------------------------------------------------------------
+    // don't dump with `entity T {}; extend T with { extend e {}; e {}; e {} };`:
+    setMemberParent( elem, name, parent );
+    checkRedefinition( elem );
+    initMembers( elem );
+    if (elem.kind === 'action' || elem.kind === 'function')
+      initBoundSelfParam( elem.params, elem._main );
 
-  // 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];
+    // for a correct home path, setMemberParent needed to be called
 
-    // 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' );
+    if (!elem.value || elem.kind !== 'element' ||
+        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.target)
+        elem.type = { ...elem.value.type, $inferred: 'cast' };
+    }
+    elem.$syntax = 'calc';
+    // TODO: it is not just "syntax" - maybe better test for `$calcDepElement`?
+    createAndLinkCalcDepElement( elem );
+
+    // 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;
+      delete elem.target;
     }
-    return construct === parent;
   }
 
   /**