@sap/cds-dk 10.1.1 → 10.2.0

package/node_modules/@sap/cds-compiler/lib/compiler/define.js

@@ -14,84 +14,12 @@
 // The 'define' phase is the only compile() phase which is also called for
 // parse.cdl.  See file ./finalize-parse-cdl.js for details.
 
-// --------- TODO: begin in extra markdown document -----------------------------
-
-// An XSN for a source looks like
-//   { kind: 'source', artifacts: <dictionary of artifact defs>, namespace: {}, ... }
-//
-// The property `artifacts` of a source contains the top-level definitions.
-// Definitions inside a context are not listed here (as opposed to
-// `definitions`, see below), but inside the property `artifacts` of that context.
-
-// The 'define' phase (function 'define' below) enriches a dictionary of
-// (file names to) AST-like XSNs and restructure them a little bit, the result
-// is called XSN ("augmented CSN"):
-//   { sources: <dictionary of ASTs>, definitions: <dictionary of artifact defs> }
-//
-// The property `sources` is the input argument (dictionary of source ASTs).
-//
-// The property `definitions` is set by this compiler phase.  It contains the
-// definitions of all main artifacts (i.e. not elements) from all sources, the
-// key is the absolute name of that artifact.  These definitions are the same
-// objects as the definitions accessible via `sources` and `artifacts` of the
-// corresponding source/context.
-//
-// You get the compact "official" CSN format by applying the function exported
-// by "../json/to-csn.js" to the XSN.
-
-// Example 'file.cds':
-//   namespace A;
-//   context B {
-//     type C { elem: String(4); }
-//   }
-// Check the augmented CSN by compiling it with
-//   cdsc --raw-output + file.cds
-//
-// ┌───────────────┐           ┌───────────────────────────────────────────┐
-// │    sources    │           │                 definitions               │
-// └──┬────────────┘           └──┬────────────────────────────┬───────────┘
-//    │                           │                            │
-//    │ ['file.cds']              │ ['A.B']                    │ ['A.B.C']
-//    ↓                           ↓                            ↓
-// ┌───────────────┐  _parent  ┌────────────────┐  _parent  ┌──────────────┐
-// │ kind:'source' │←──────────┤ kind:'context' │←──────────┤ kind: 'type' │
-// │ artifacts: ───┼──────────→│ artifacts: ────┼──────────→│ ...          │
-// └───────────────┘   ['B']   └────────────────┘   ['C']   └──────────────┘
-//
-// The _parent properties are not shown in the JSON - they are used for name
-// resolution, see file './resolver.js'.
-
-// An artifact definition looks as follows (example: context "A.B" above):
-//   {
-//     kind: 'context',
-//     name: { path: [ { id: 'B'} ], absolute: 'A.B', location: { <for the id "B"> } },
-//     artifacts: <for contexts, a dictionary of artifacts defined within>,
-//     location: { <of the complete artifact definition> } },
-//     _parent: <the parent artifact, here the source 'file.cds'>
-//   }
-// The properties `name.absolute`, `name.component` and `_parent` are set
-// during this compiler phase.
-
-// The definition of an entity or a structured type would contain an `elements`
-// property instead of an `artifacts` property.
-
-// An element definition looks as follows (example: "elem" above):
-//   {
-//     kind: 'element',
-//     name: { id: 'elem', component: 'elem', location: { <for the id "elem"> } }
-//     type: { path: [ { id: 'String', location: ... } ] },
-//     $typeArgs: [ { number: '4', location: ... } ]
-//     location: { <of the complete element definition> } },
-//     _parent: <the parent artifact, here the type "A.B.C">
-//   }
-// --------- TODO: end in extra markdown document -------------------------------
-
 // Sub phase 1 (addXYZ) - only for main artifacts
 //  - 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(),
+//  - Note: the only allowed name resolving is resolveUncheckedPath(),
 //    TODO: make sure that _no_ _artifact link is set
 //  - POST: all user-written definitions are in model.definitions
 
@@ -103,8 +31,6 @@
 //  - annotation assignments
 //  - POST: resolvePath() can be called for artifact references (if complete model)
 
-// More sub phases...
-
 // The main difficulty is the correct behavior concerning duplicate definitions
 //  - For code completion, all duplicate definitions must be further checked.
 //  - We need a unique object for the _subArtifacts dictionary.
@@ -118,9 +44,19 @@
 //    dictionary, `_combined` dictionary for query search, `$tableAliases`
 //    of JOIN restrictions, `vocabulary` dictionary of a CDL input source.
 
+// Sections in this file:
+//  - Phase 1 add
+//  - i18n
+//  - Phase 2 init artifacts (ex queries)
+//  - Phase 2 init helpers (ex queries)
+//  - Phase 2 init queries
+//  - Create (add + init) for other compiler phases
+//  - Late syntax checks
+
+
 'use strict';
 
-const { weakLocation, builtinLocation } = require('../base/location');
+const { emptyLocation, weakLocation, builtinLocation } = require('../base/location');
 
 const shuffleGen = require('../utils/shuffle');
 const {
@@ -128,6 +64,7 @@ const {
 } = require('./dictionaries');
 const { kindProperties } = require('./base');
 const { CompilerAssertion } = require('../base/error');
+const { XsnArtifact, XsnName } = require('./xsn-model');
 const {
   setLink,
   initItemsLinks,
@@ -141,6 +78,8 @@ const {
   pathName,
   forEachGeneric,
   forEachInOrder,
+  isDirectComposition,
+  targetCantBeAspect,
 } = require('./utils');
 const { compareLayer } = require('./moduleLayers');
 const { initBuiltins } = require('./builtins');
@@ -149,14 +88,7 @@ const { isInReservedNamespace } = require('../base/builtins');
 const $location = Symbol.for( 'cds.$location' );
 
 /**
- * Export function of this file.  Transform argument `sources` = dictionary of
- * AST-like CSNs into augmented CSN.  If a vector is provided for argument
- * `messages` (usually the combined messages from `parse` for all sources), do
- * not throw an exception in case of an error, but push the corresponding error
- * object to that vector.  If at least one AST does not exist due to a parse
- * error, set property `lintMode` of `options` to `true`.  Then, the resolver
- * does not report errors for using directives pointing to non-existing
- * artifacts.
+ * Export function of this file.
  *
  * @param {XSN.Model} model Model with `sources` property that contain AST-like CSNs.
  */
@@ -176,7 +108,6 @@ function define( model ) {
     shuffleArray,
     initMainArtifact,
     initArtifactParentLink,
-    checkRedefinition,
     createGapArtifact,
   } );
   return doDefine();
@@ -195,7 +126,7 @@ function define( model ) {
       } );
     }
     model.definitions = Object.create( null );
-    setLink( model, '_entities', [] ); // for entities with includes
+    setLink( model, '_entities', [] ); // helper property for propagation of keys
     model.$compositionTargets = Object.create( null );
     model.$collectedExtensions = Object.create( null );
 
@@ -241,7 +172,7 @@ function define( model ) {
     }
     if (isInReservedNamespace( prefix )) {
       error( 'reserved-namespace-cds', [ src.namespace.name.location, src.namespace.name ],
-             { name: 'cds' },
+             { name: 'cds' },   // TODO: 'name-reserved-prefix'
              'The namespace $(NAME) is reserved for CDS builtins' );
       namespace = null;         // TODO: reconsider
     }
@@ -292,7 +223,6 @@ function define( model ) {
    */
   function addMainArtifact( art, block, prefix ) {
     setLink( art, '_block', block );
-    initExprAnnoBlock( art, block, error ); // TODO: why also here?
     art.name.id ??= prefix + pathName( art.name.path );
     const absolute = art.name.id;
     // TODO: check reserved, see checkName()/checkLocalizedObjects() of checks.js
@@ -364,8 +294,11 @@ function define( model ) {
       const location = a.name.path?.[0]?.location || a.location;
       const absolute = prefix + using;
       artifacts[using] = {
+        __proto__: XsnArtifact.prototype,
         kind: 'using',          // !, not namespace - we do not know artifact yet
-        name: { id: using, location, $inferred: 'as' },
+        name: {
+          __proto__: XsnName.prototype, id: using, location, $inferred: 'as',
+        },
         extern: { location, id: absolute },
         location,
         $inferred: 'path-prefix',
@@ -393,7 +326,7 @@ function define( model ) {
       return;
     decl.extern.id = pathName( path );
     if (!decl.name)
-      decl.name = { ...path.at(-1), $inferred: 'as' };
+      decl.name = { __proto__: XsnName.prototype, ...path.at(-1), $inferred: 'as' };
     const name = decl.name.id;
     // TODO: check name: no "."
     const found = src.artifacts[name];
@@ -421,8 +354,11 @@ function define( model ) {
       // not used as we have a definition/using with that name, or dotted last path id
       return;
     src.artifacts[id] = {
+      __proto__: XsnArtifact.prototype,
       kind: 'using',
-      name: { id, location: last.location, $inferred: 'as' },
+      name: {
+        __proto__: XsnName.prototype, id, location: last.location, $inferred: 'as',
+      },
       extern: namespace,
       location: namespace.location,
       $inferred: 'namespace',
@@ -440,7 +376,6 @@ function define( model ) {
    */
   function addExtension( ext, block ) {
     setLink( ext, '_block', block );
-    initExprAnnoBlock( ext, block, error );
     const absolute = ext.name && resolveUncheckedPath( ext.name, '_uncheckedExtension', ext );
     if (!absolute)                    // broken path
       return;
@@ -462,11 +397,12 @@ function define( model ) {
     ext.name.id = absolute; // definition might not be there yet, no _artifact link
     delete ext.name.path[0]._artifact; // might point to wrong JS object in phase 1 - TODO: still?
 
-    const location = { file: '' }; // stupid required location
+    const location = emptyLocation( '' ); // stupid required location
     const late = model.$collectedExtensions[absolute] ||
           (model.$collectedExtensions[absolute] = {
+            __proto__: XsnArtifact.prototype,
             kind: 'annotate',
-            name: { id: absolute, location },
+            name: { __proto__: XsnName.prototype, id: absolute, location },
             $inferred: '',
             location,
           });
@@ -534,7 +470,7 @@ function define( model ) {
     }
   }
 
-  // Phase 2 ("init"), top-level & main -----------------------------------------
+  // Phase 2: init artifacts (ex queries) ---------------------------------------
   // Functions called from top-level: initNamespaceAndUsing(), initMainArtifact(),
   // initVocabulary(), initExtension()
 
@@ -555,7 +491,9 @@ function define( model ) {
         return;
       if (!model.definitions[decl.id]) {
         // TODO: make it possible to have no location
-        const ns = { kind: 'namespace', name: decl, location: decl.location };
+        const ns = {
+          __proto__: XsnArtifact.prototype, kind: 'namespace', name: decl, location: decl.location,
+        };
         model.definitions[decl.id] = ns;
         initArtifactParentLink( ns, model.definitions );
       }
@@ -601,7 +539,7 @@ function define( model ) {
     initDollarSelf( art );      // $self, TODO: also for 'namespace'?
     if (art.params)
       initDollarParameters( art ); // $parameters
-    initMembers( art );
+    initCommonAndMembers( art );
 
     if (art.query) {
       initArtifactQuery( art );
@@ -619,7 +557,7 @@ function define( model ) {
   function initVocabulary( art ) {
     initArtifactParentLink( art, model.vocabularies );
     checkRedefinition( art );
-    initMembers( art );
+    initCommonAndMembers( art );
 
     if (art.query) {
       initArtifactQuery( art );
@@ -635,14 +573,76 @@ function define( model ) {
    * @param {XSN.Extension} ext  The collected super-extension node
    */
   function initExtension( ext ) {
-    initMembers( ext );
+    initCommonAndMembers( ext );
     if (ext.columns)
       initSelectItems( ext, ext.columns, ext, true );
     // there are no sub queries in extensions yet
     // Remark: sub queries not yet allowed in `extend … with columns`
   }
 
-  //-----------------------------------------------------------------------------
+  /**
+   * Initialise for a single member (element, enum value, foreign key, action,
+   * function, or parameter).  Infers a missing name from the last path component
+   * of `targetElement`/`value`, sets `_block`/`_parent`/`_main` links, checks for
+   * duplicates, recurses into sub-members, and — for action/function params —
+   * sets up the bound `$self` parameter.  Also promotes elements with a `value`
+   * expression to calculated elements (`$syntax: 'calc'`) and creates the
+   * companion `$calcDepElement`.
+   *
+   * @param {XSN.Artifact|XSN.Element|XSN.Query} parent  Enclosing node
+   * @param {XSN.Element} elem
+   * @param {string} name  Relative member name (empty string `''` for RETURNS)
+   */
+  function initMemberArtifact( parent, elem, name ) {
+    if (!elem.name && !elem._outer) {
+      const ref = elem.targetElement || elem.kind === 'element' && elem.value;
+      if (ref && ref.path) {
+        elem.name = {
+          __proto__: XsnName.prototype,
+          $inferred: 'as',
+          ...ref.path[ref.path.length - 1],
+        };
+      }
+      else {                  // RETURNS, parser robustness
+        elem.name = { __proto__: XsnName.prototype, id: name, location: elem.location };
+      }
+    }
+
+    if (!elem._block)
+      setLink( elem, '_block', parent._block );
+
+    // don't dump with `entity T {}; extend T with { extend e {}; e {}; e {} };`:
+    setMemberParent( elem, name, parent );
+    checkRedefinition( elem );
+    initCommonAndMembers( elem );
+    if (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 === 'or-enum')
+      return;                            // not an element with value
+    // remark: $syntax: 'or-enum' is set in CDL+CSN parser for potential enums
+    // -> 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;
+    }
+  }
+
+  // Phase 2: init helpers = set parent links, common init, …  ------------------
 
   /**
    * Make the `_parent` pointer of artifact `A.B.C` point to `A.B`.  If no `A.B`
@@ -664,7 +664,12 @@ function define( model ) {
       pathIndex ??= path?.length - 1; // just used for location
       const pathItemOrName = (path && pathIndex) ? path[--pathIndex] : art.name;
       const location = weakLocation( pathItemOrName.location );
-      parent = { kind: 'namespace', name: { id: prefix, location }, location };
+      parent = {
+        __proto__: XsnArtifact.prototype,
+        kind: 'namespace',
+        name: { __proto__: XsnName.prototype, id: prefix, location },
+        location,
+      };
       definitions[prefix] = parent;
       initArtifactParentLink( parent, definitions, path, pathIndex );
     }
@@ -677,6 +682,119 @@ function define( model ) {
       parent._subArtifacts[id.substring( dot + 1 )] = art; // not dictAdd()
   }
 
+  /**
+   * Do some common initialization for any artifact `art` (following
+   * `items`/`many` wrappers via `initItemsLinks`):
+   *
+   * - init annotations (needed for checked references)
+   * - init associations/compositions and perform late syntax check for type props
+   * - init all members (element, enum value, foreign key, action, param, and RETURNS),
+   *   including elements of anonymous aspect (managed compositions)
+   *
+   * Queries and columns are not traversed by this function.
+   *
+   * @param {XSN.Artifact|XSN.Element|XSN.Query|XSN.Extension} art
+   */
+  function initCommonAndMembers( art ) {
+    const block = art._block;
+    initExprAnnoBlock( art, block, error );
+    const obj = initItemsLinks( art, block );     // down many / array of
+
+    if (obj.scale && !obj.precision &&
+        (art._main || art).kind === 'extend') { // TODO v7: why just with extend?
+      // TODO: where could we store the location of the name?
+      error( 'syntax-missing-type-property', [ obj.scale.location ],
+             { prop: 'scale', otherprop: 'precision' },
+             'Type extension with property $(PROP) must also have property $(OTHERPROP)' );
+    }
+
+    if (obj.target?.elements || initCompositionTarget( obj )) {
+      obj.targetAspect = obj.target;
+      delete obj.target;
+    }
+    if (obj.targetAspect?.elements) {
+      initAnonymousAspect( art, obj, obj.targetAspect );
+      forEachInOrder( obj.targetAspect, 'elements',
+                      (...args) => initMemberArtifact( obj.targetAspect, ...args ) );
+      return;
+    }
+    forEachInOrder( obj, 'elements', (...args) => initMemberArtifact( art, ...args ) );
+    forEachGeneric( obj, 'enum', (...args) => initMemberArtifact( art, ...args ) );
+    forEachInOrder( obj, 'foreignKeys', (...args) => initMemberArtifact( art, ...args ) );
+    forEachGeneric( art, 'actions', (...args) => initMemberArtifact( art, ...args ) );
+    forEachInOrder( art, 'params', (...args) => initMemberArtifact( art, ...args ) );
+
+    const { returns } = art;
+    if (returns) {
+      const { kind } = art;
+      returns.kind = (kind === 'extend' || kind === 'annotate') ? kind : 'param';
+      initMemberArtifact( art, returns, '' ); // '' is special name for returns parameter
+    }
+  }
+
+  function initCompositionTarget( assoc ) {
+    const name = assoc.target &&
+      assoc.kind !== 'param' && assoc._main?.kind !== 'annotation' &&
+      // TODO v8: forbid associations/compositions in parameter and annotation defs
+      // Remark: compositions in anonymous structs for params are now tagged
+      isDirectComposition( assoc ) &&
+      resolveUncheckedPath( assoc.target, 'target', assoc );
+    if (!name)
+      return null;
+    model.$compositionTargets[name] = true; // does not hurt if set on aspect
+    const target = model.definitions[name];
+    return target?.kind in { aspect: 1, type: 1 } && // type is sloppy
+      target.elements && assoc.kind === 'element' &&
+      !targetCantBeAspect( assoc, false, model.definitions );
+  }
+
+  /**
+   * Initialise the inline aspect that appears as the `targetAspect` of a managed
+   * composition element.  Sets up `_outer`, `_parent`, `_block`, `_main`, and
+   * `$self` links on `targetAspect`, promotes its kind to `'aspect'`, and injects
+   * a synthetic `up_` `$navElement` when the composition is directly inside an
+   * entity (so that references to `up_` inside the aspect resolve correctly).
+   *
+   * @param {XSN.Element} parent        The composition element that owns the inline aspect
+   * @param {XSN.Element} obj           The resolved composition element (may differ via `items`)
+   *     (should always be equal to `parent`, because there is no `many composition of Aspect`)
+   * @param {XSN.InlineAspect} targetAspect  The inline aspect node to initialise
+   * @returns {XSN.InlineAspect}
+   */
+  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 ); // not with extend
+    // 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: { __proto__: XsnName.prototype, 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;
+  }
+
   /**
    * Report a duplicate-definition error for `art` if it was flagged as a redefinition
    * during phase 1.  Extensions (`extend`/`annotate`) are silently skipped because
@@ -688,7 +806,7 @@ function define( model ) {
     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')
+        art.$errorReported === 'syntax-duplicate-extend') // set by CDL parser
       return;
     if (art._main) {
       error( 'duplicate-definition', [ art.name.location, art ], {
@@ -708,52 +826,6 @@ function define( model ) {
 
   // 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 ) {
-    const { query } = art;
-
-    if (art.kind !== 'type')
-      return; // TODO(v6): Also for event
-
-    if (!query.from?.path)
-      return; // union, sub-select, etc. should already be rejected
-
-    const check = (prop, keyword) => (query[prop] && { prop: query[prop], keyword });
-    const unexpectedQueryProp = check( 'where', 'where' ) ||
-      check( 'groupBy', 'group by' ) ||
-      check( 'limit', 'limit' ) ||
-      check( 'having', 'having' ) ||
-      check( 'orderBy', 'order by' ) ||
-      null;
-
-    if (unexpectedQueryProp) {
-      error( 'query-unexpected-prop', [ unexpectedQueryProp.prop.location, query ], {
-        '#': art.kind,
-        keyword: unexpectedQueryProp.keyword,
-      }, {
-        std: 'Unexpected $(KEYWORD) for projection clause used as type expression',
-        type: 'Unexpected $(KEYWORD) for type definition',
-        event: 'Unexpected $(KEYWORD) for event definition',
-      } );
-      return;
-    }
-
-    const firstCondition = query.from.path.find(step => step.where)?.where;
-    if (firstCondition) {
-      error( 'query-unexpected-filter', [ firstCondition.location, query ], { '#': art.kind }, {
-        std: 'Unexpected filter in query source for projection clause used as type expression',
-        type: 'Unexpected filter in projection clause of type definition',
-        event: 'Unexpected filter in projection clause of event definition',
-      } );
-    }
-  }
-
   /**
    * Initialise all queries of a query-bearing artifact and store them in `$queries`.
    *
@@ -811,7 +883,7 @@ function define( model ) {
         initMixins( query, art );
       if (!query.$tableAliases.$self) { // same as $projection
         const self = {
-          name: { id: '$self', location: query.location },
+          name: { __proto__: XsnName.prototype, id: '$self', location: query.location },
           kind: '$self',
           location: query.location,
         };
@@ -872,7 +944,11 @@ function define( model ) {
              (art.kind === '$tableAlias' ? art._parent._$next : art ) );
     setLink( query, '_origin', null ); // set later in initTableExpression → addAsAlias
     query.kind = 'select';
-    query.name = { location: query.location, id: main.$queries.length + 1 };
+    query.name = {
+      __proto__: XsnName.prototype,
+      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 );
@@ -905,7 +981,9 @@ function define( model ) {
         const dot = last?.id?.lastIndexOf( '.' );
         const id = (dot >= 0) ? last.id.substring( dot + 1 ) : last.id || '';
         // TODO: if we have too much time, we can calculate the real location with '.'
-        table.name = { $inferred: 'as', id, location: last.location };
+        table.name = {
+          __proto__: XsnName.prototype, $inferred: 'as', id, location: last.location,
+        };
       }
       addAsAlias( table, query, joinParents );
       // _origin is set when we resolve the ref
@@ -914,7 +992,9 @@ function define( model ) {
       if (!table.name?.id) {
         // We don't worry about duplicate names here.
         const id = `$_select_${ query._main.$queries.length + 1 }__`;
-        table.name = { id, location: table.location, $inferred: '$internal' };
+        table.name = {
+          __proto__: XsnName.prototype, id, location: table.location, $inferred: '$internal',
+        };
       }
       addAsAlias( table, query, joinParents );
       // Store _origin to leading query of table.query for name resolution
@@ -925,7 +1005,7 @@ function define( model ) {
         setLink( table, '_$next', query ); // or query._$next?
         setLink( table, '_block', query._block );
         table.kind = '$join';
-        table.name = { location: query.location }; // param comes later
+        table.name = { __proto__: XsnName.prototype, location: query.location }; // later
         table.$tableAliases = Object.create( null ); // table aliases and mixin definitions
         joinParents = [ ...joinParents, table ];
       }
@@ -1016,7 +1096,7 @@ function define( model ) {
       initExprForQuery( query.where, query );
     if (query.having)
       initExprForQuery( query.having, query );
-    initMembers( query );
+    initCommonAndMembers( query );
   }
 
   /**
@@ -1060,9 +1140,8 @@ function define( model ) {
       setMemberParent( mixin, name, query );
       checkRedefinition( mixin );
       if (!(mixin.$duplicates)) {
-        // TODO: do some initMembers() ?  If people had annotation
-        // assignments on the mixin... (also for future mixin definitions
-        // with generated values)
+        // Currently, both CDL and CSN parser forbid annos for mixin
+        // Otherwise, we would need to initialize them here
         dictAdd( query.$tableAliases, name, query.mixin[name], ( dupName, loc ) => {
           error( 'duplicate-definition', [ loc, query ], { name: dupName, '#': 'alias' } );
         } );
@@ -1071,6 +1150,7 @@ function define( model ) {
                    { '#': 'mixin', name: '$' } );
         }
       }
+      initCompositionTarget( mixin );
     }
   }
 
@@ -1158,7 +1238,7 @@ function define( model ) {
         if (col.expand || col.inline)
           initSelectItems( col, null, user ); // TODO: use col, remove 3rd param?
 
-        initMembers( col );      // with #13933, TODO: only for enums
+        initCommonAndMembers( col );      // with #13933, TODO: only for enums
         checkCdlTypeCast( col );
       }
     }
@@ -1192,7 +1272,9 @@ function define( model ) {
         (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' };
+      col.name = {
+        __proto__: XsnName.prototype, id: last.id || '', location: last.location, $inferred: 'as',
+      };
       return col.name.id;
     }
     else if ((col.expand || col.value) &&
@@ -1205,6 +1287,7 @@ function define( model ) {
              'Alias name is required for this select item' );
     }
     col.name = {
+      __proto__: XsnName.prototype,
       // NOTE: If the alias is changed, corresponding name-clash tests must be updated as well!
       id: `$_column_${ colIndex }`,
       location: (col.value || col).location,
@@ -1213,6 +1296,34 @@ function define( model ) {
     return col.name.id;
   }
 
+  // Create (add + init) for other compiler phases: -----------------------------
+
+  /**
+   * Create "gap" artifact (kind: "namespace") for references which might turn out
+   * to refer to a compiler-generated texts or target entity later.
+   *
+   * A _parent link is set as usual, but the parent does not list the gap artifact
+   * in its _subArtifacts (to allow more precise and processing
+   * sequence-independent resolve errors).  When the gap artifact is replaced by
+   * the generated entity, it is added to the _subArtifacts of the parent.
+   */
+  function createGapArtifact( name, location = builtinLocation() ) {
+    // TODO: make it work without location (or value undefined/null)
+    const art = {
+      __proto__: XsnArtifact.prototype,
+      kind: 'namespace',
+      name: { __proto__: XsnName.prototype, id: name, location },
+      location,
+    };
+    model.definitions[name] = art;
+    // set _parent link, but do not add in _subArtifacts
+    // (TODO: in the future, test better for "valid" completion, and add anyway.)
+    initArtifactParentLink( art, model.definitions, undefined, undefined, true );
+    return art;
+  }
+
+  // Late syntax checks: --------------------------------------------------------
+
   /**
    * Report a CDL-style type cast to an anonymous structure or an expand with an
    * explicit type as a syntax error.  Called for every column during select-item
@@ -1235,182 +1346,51 @@ function define( model ) {
     // Remark: there are quite a few consequential error, TODO: avoid them
   }
 
-  // Members (elements, enum, actions, params): ---------------------------------
-
-  /**
-   * Initialise for all members of `parent`: resolves the concrete member container
-   * (following `items`/`many` wrappers via `initItemsLinks`), reports a scale-without-
-   * precision error on type extensions, detects inline aspects on managed compositions
-   * (delegating to `initAnonymousAspect`), and then calls `initArtifact` for every
-   * element, enum value, foreign key, action, param, and RETURNS declaration.
-   *
-   * @param {XSN.Artifact|XSN.Element|XSN.Query|XSN.Extension} parent
-   */
-  function initMembers( parent ) {
-    // TODO: combine with initMembers() - better structuring
-    const block = parent._block;
-    initExprAnnoBlock( parent, block, error );
-    const obj = initItemsLinks( parent, block );     // down many / array of
-
-    if (obj.scale && !obj.precision &&
-        (parent._main || parent).kind === 'extend') { // TODO v7: why just with extend?
-      // TODO: where could we store the location of the name?
-      error( 'syntax-missing-type-property', [ obj.scale.location ],
-             { prop: 'scale', otherprop: 'precision' },
-             'Type extension with property $(PROP) must also have property $(OTHERPROP)' );
-    }
-
-    if (obj.target?.elements) {
-      // in kick-start.js, we consider a target refererence to an aspect
-      obj.targetAspect = obj.target;
-      delete obj.target;
-    }
-    if (obj.targetAspect?.elements) {
-      initAnonymousAspect( parent, obj, obj.targetAspect );
-      forEachInOrder( obj.targetAspect, 'elements',
-                      (...args) => initArtifact( obj.targetAspect, ...args ) );
-      return;
-    }
-    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 ) );
-
-    const { returns } = parent;
-    if (returns) {
-      const { kind } = parent;
-      returns.kind = (kind === 'extend' || kind === 'annotate') ? kind : 'param';
-      initArtifact( parent, returns, '' ); // '' is special name for returns parameter
-    }
-  }
-
   /**
-   * Initialise the inline aspect that appears as the `targetAspect` of a managed
-   * composition element.  Sets up `_outer`, `_parent`, `_block`, `_main`, and
-   * `$self` links on `targetAspect`, promotes its kind to `'aspect'`, and injects
-   * a synthetic `up_` `$navElement` when the composition is directly inside an
-   * entity (so that references to `up_` inside the aspect resolve correctly).
+   * Restrict the query of `art` to only simple projections, i.e. those without 'group by', etc.
    *
-   * @param {XSN.Element} parent        The composition element that owns the inline aspect
-   * @param {XSN.Element} obj           The resolved composition element (may differ via `items`)
-   * @param {XSN.InlineAspect} targetAspect  The inline aspect node to initialise
-   * @returns {XSN.InlineAspect}
-   */
-  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 ); // not with extend
-    // 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;
-  }
-
-  /**
-   * Initialise for a single member (element, enum value, foreign key, action,
-   * function, or parameter).  Infers a missing name from the last path component
-   * of `targetElement`/`value`, sets `_block`/`_parent`/`_main` links, checks for
-   * duplicates, recurses into sub-members, and — for action/function params —
-   * sets up the bound `$self` parameter.  Also promotes elements with a `value`
-   * expression to calculated elements (`$syntax: 'calc'`) and creates the
-   * companion `$calcDepElement`.
+   * Late syntax check.  TODO v8 and for `type`: do in parsers.
    *
-   * @param {XSN.Artifact|XSN.Element|XSN.Query} parent  Enclosing node
-   * @param {XSN.Element} elem
-   * @param {string} name  Relative member name (empty string `''` for RETURNS)
+   * @param {XSN.Artifact} art
    */
-  // TODO: combine with initMembers()
-  function initArtifact( parent, elem, name ) {
-    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 };
-      }
-    }
+  function restrictToSimpleProjection( art ) {
+    const { query } = art;
 
-    if (!elem._block)
-      setLink( elem, '_block', parent._block );
+    if (art.kind !== 'type')
+      return; // TODO(v6): Also for event
 
-    // 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 );
+    if (!query.from?.path)
+      return; // union, sub-select, etc. should already be rejected
 
-    // for a correct home path, setMemberParent needed to be called
+    const check = (prop, keyword) => (query[prop] && { prop: query[prop], keyword });
+    const unexpectedQueryProp = check( 'where', 'where' ) ||
+      check( 'groupBy', 'group by' ) ||
+      check( 'limit', 'limit' ) ||
+      check( 'having', 'having' ) ||
+      check( 'orderBy', 'order by' ) ||
+      null;
 
-    if (!elem.value || elem.kind !== 'element' || elem.$syntax === 'or-enum')
-      return;                            // not an element with value
-    // remark: $syntax: 'or-enum' is set in CDL+CSN parser for potential enums
-    // -> 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' };
+    if (unexpectedQueryProp) {
+      error( 'query-unexpected-prop', [ unexpectedQueryProp.prop.location, query ], {
+        '#': art.kind,
+        keyword: unexpectedQueryProp.keyword,
+      }, {
+        std: 'Unexpected $(KEYWORD) for projection clause used as type expression',
+        type: 'Unexpected $(KEYWORD) for type definition',
+        event: 'Unexpected $(KEYWORD) for event definition',
+      } );
+      return;
     }
-    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;
+    const firstCondition = query.from.path.find(step => step.where)?.where;
+    if (firstCondition) {
+      error( 'query-unexpected-filter', [ firstCondition.location, query ], { '#': art.kind }, {
+        std: 'Unexpected filter in query source for projection clause used as type expression',
+        type: 'Unexpected filter in projection clause of type definition',
+        event: 'Unexpected filter in projection clause of event definition',
+      } );
     }
   }
-
-  /**
-   * Create "gap" artifact (kind: "namespace") for references which might turn out
-   * to refer to a compiler-generated texts or target entity later.
-   *
-   * A _parent link is set as usual, but the parent does not list the gap artifact
-   * in its _subArtifacts (to allow more precise and processing
-   * sequence-independent resolve errors).  When the gap artifact is replaced by
-   * the generated entity, it is added to the _subArtifacts of the parent.
-   */
-  function createGapArtifact( name, location = builtinLocation() ) {
-    // TODO: make it work without location (or value undefined/null)
-    const art = {
-      kind: 'namespace', name: { id: name, location }, location,
-    };
-    model.definitions[name] = art;
-    // set _parent link, but do not add in _subArtifacts
-    // (TODO: in the future, test better for "valid" completion, and add anyway.)
-    initArtifactParentLink( art, model.definitions, undefined, undefined, true );
-    return art;
-  }
 }
 
 module.exports = define;