@sap/cds-compiler 4.4.4 → 4.6.0

package/lib/compiler/assert-consistency.js

@@ -126,6 +126,7 @@ function assertConsistency( model, stage ) {
         '@sql_mapping',         // TODO: it is time that a 'header' attribute replaces 'version'
         '$withLocalized',
         '$sources',
+        'tokenStream',
       ],
       instanceOf: XsnSource,
     },
@@ -196,13 +197,14 @@ function assertConsistency( model, stage ) {
       schema: {
         kind: { test: isString, enum: [ '$magicVariables' ] },
         elements: {
-          // Do not use "normal" definitions spec because of these artifacts
+          // Do not use "normal" definitions spec because these artifacts
           // are missing the location property
           test: isDictionary( definition ),
           requires: [ 'kind', 'name' ],
           optional: [
             'elements', '$autoElement', '$uncheckedElements', '_origin', '_extensions',
-            '$requireElementAccess', '_effectiveType', '$effectiveSeqNo', '_deps', '_parent',
+            '$requireElementAccess', '_effectiveType', '$effectiveSeqNo', '_deps',
+            '$calcDepElement', '$filtered', '_parent',
           ],
           schema: {
             kind: { test: isString, enum: [ 'builtin' ] },
@@ -249,10 +251,13 @@ function assertConsistency( model, stage ) {
     elements$: { kind: true, enumerable: false, test: TODO },
     enum$: { kind: true, enumerable: false, test: TODO },
     typeProps$: { kind: true, enumerable: false, test: TODO },
+    // helper property for faster processing:
+    $contains: { kind: true, test: TODO },
     actions: { kind: true, inherits: 'definitions' },
     enum: { kind: true, inherits: 'definitions' },
     foreignKeys: { kind: true, inherits: 'definitions', instanceOf: 'ignore' },
     $keysNavigation: { kind: true, test: TODO },
+    $filtered: { kind: true, inherits: 'value' }, // for assoc+filter
     params: { kind: true, inherits: 'definitions' },
     _extendType: { kind: true, test: TODO },
     mixin: { inherits: 'definitions' },
@@ -264,16 +269,18 @@ function assertConsistency( model, stage ) {
         requires: [ 'op', 'location', 'args' ],
         optional: [
           'quantifier', 'orderBy', 'limit', 'name', '$parens', 'kind',
-          '_origin',            // TODO tmp, see TODO in getOriginRaw()
+          '_origin', '$contains', // TODO tmp, see TODO in getOriginRaw()
           '_parent', '_main', '_leadingQuery', '_effectiveType', '$effectiveSeqNo', // in FROM
+          '_$next', // parsing error: tableTerm with UNION on rhs.
         ],
       },
       select: {                   // sub query
         requires: [ 'op', 'location', 'from' ],
         optional: [
           'name', '$parens', 'quantifier', 'mixin', 'excludingDict', 'columns', 'elements', '_deps',
+          '$calcDepElement',
           'where', 'groupBy', 'having', 'orderBy', '$orderBy', 'limit', '$limit',
-          '_origin', '_block',
+          '_origin', '_block', '$contains',
           '_projections', '_parent', '_main', '_effectiveType', '$effectiveSeqNo', '$expand',
           '$tableAliases', 'kind', '_$next', '_combined', '$inlines', '_status',
         ],
@@ -396,7 +403,7 @@ function assertConsistency( model, stage ) {
         'annotate', 'extend', '$column',
         'select', '$join', 'mixin',
         'source', 'namespace', 'using',
-        '$tableAlias', '$navElement',
+        '$tableAlias', '$navElement', '$calculation', '$annotation',
         'builtin', // magic variables
       ],
     },
@@ -473,7 +480,8 @@ function assertConsistency( model, stage ) {
       optional: [
         'literal', 'val', 'sym', 'struct', 'variant', 'path', 'name', '$duplicates', 'upTo',
         // expressions as annotation values
-        '$tokenTexts', 'op', 'args', 'func', '_artifact', 'type',
+        '$tokenTexts', 'op', 'args', 'func', '_artifact', 'type', '$typeArgs',
+        'scale', 'srid', 'length', 'precision',
       ],
       // TODO: restrict path to #simplePath
     },
@@ -505,7 +513,8 @@ function assertConsistency( model, stage ) {
       optional: [
         'name', '_block', '$priority', '$inferred', '$duplicates', '$errorReported',
         // annotation values
-        '$tokenTexts',
+        '$tokenTexts', 'kind', '_outer',
+        '_effectiveType', '$effectiveSeqNo', '_origin', '_deps',
         // CSN parser may let these properties slip through to XSN, even if input is invalid.
         'args', 'op', 'func', 'suffix',
       ],
@@ -554,6 +563,7 @@ function assertConsistency( model, stage ) {
         'elements', 'cardinality', 'target', 'on', 'foreignKeys', 'items',
         '_outer', '_effectiveType', '$effectiveSeqNo', 'notNull', '_parent',
         '_origin', '_block', '$inferred', '$expand', '$inCycle', '_deps',
+        '$calcDepElement',
         '$syntax', '_extensions',
         '_status', '_redirected',
         ...typeProperties,
@@ -563,20 +573,20 @@ function assertConsistency( model, stage ) {
     artifacts: { kind: true, inherits: 'definitions', test: isDictionary( inDefinitions ) },
     _subArtifacts: { kind: true, inherits: 'definitions', test: isDictionary( inDefinitions ) },
     blocks: { kind: true, test: TODO },    // TODO: make it $blocks ?
-    length: { kind: true, inherits: 'value' }, // for number is to be checked in resolver
-    precision: { kind: true, inherits: 'value' },
-    scale: { kind: true, inherits: 'value' },
-    srid: { kind: true, inherits: 'value' },
+    length: { kind: true, test: isNumberVal }, // for number is to be checked in resolver
+    precision: { kind: true, test: isNumberVal },
+    scale: { kind: true, test: isNumberVal, also: [ 'floating', 'variable' ] },
+    srid: { kind: true, test: isNumberVal },
     localized: { kind: true, test: locationVal() },
     cardinality: {
       kind: true,
       requires: [ 'location' ],
       optional: [ 'sourceMin', 'sourceMax', 'targetMin', 'targetMax' ],
     },
-    sourceMin: { test: locationVal( isNumber ) },
-    sourceMax: { test: locationVal( isNumber ), also: [ '*' ] },
-    targetMin: { test: locationVal( isNumber ) },
-    targetMax: { test: locationVal( isNumber ), also: [ '*' ] },
+    sourceMin: { test: isNumberVal },
+    sourceMax: { test: isNumberVal, also: [ '*' ] },
+    targetMin: { test: isNumberVal },
+    targetMax: { test: isNumberVal, also: [ '*' ] },
     default: { kind: true, inherits: 'value' },
     $typeArgs: { parser: true, kind: true, test: TODO },
     $tableAliases: { kind: true, test: TODO }, // containing $self outside queries
@@ -585,13 +595,18 @@ function assertConsistency( model, stage ) {
     _service: { kind: true, test: TODO },
     _main: { kind: true, test: TODO },
     _user: { kind: true, test: TODO },
+    // - on a path item with a filter condition to the user of the ref (not nested)
+    // - on a JOIN node to the query (TODO: _outer?)
     _artifact: { test: TODO },
     _navigation: { test: TODO },
     _effectiveType: { kind: true, test: TODO },
     $effectiveSeqNo: { kind: true, test: isNumber },
     _joinParent: { test: TODO },
     $joinArgsIndex: { test: isNumber },
-    _outer: { test: TODO },              // for returns/items
+    _outer: { test: TODO },              // for items
+    // - on an array item to the array elem/type/item (nested)
+    // - on an anonymous aspect to the composition element
+    // - on an annotation assignment to the annotatee
     $queries: {
       kind: [ 'entity', 'event' ],
       test: isArray(),
@@ -605,7 +620,7 @@ function assertConsistency( model, stage ) {
       ],
       optional: [
         '_effectiveType', '$effectiveSeqNo', '$parens',
-        '_deps', '$expand',
+        '_deps', '$calcDepElement', '$expand', '$contains',
         // query specific
         'where', 'columns', 'mixin', 'quantifier', 'offset',
         'orderBy', '$orderBy', 'groupBy', 'excludingDict', 'having',
@@ -628,6 +643,9 @@ function assertConsistency( model, stage ) {
     _annotate: { kind: true, test: TODO }, // for collecting extend/annotate on artifact
     _extension: { kind: true, test: TODO }, // on artifact to its "super extend/annotate" statement
     _deps: { kind: true, test: TODO },      // for cyclic calculation
+    // a fake element for cyclic dependency detection: e.g. dependencies to target entities.
+    // dependants don't only depend on the calc element, but on this element as well.
+    $calcDepElement: { kind: true, test: TODO },
     _scc: { kind: true, test: TODO },       // for cyclic calculation
     _sccCaller: { kind: true, test: TODO }, // for cyclic calculation
     _status: { kind: true, test: TODO },    // TODO: $status
@@ -703,6 +721,7 @@ function assertConsistency( model, stage ) {
     $extra: { parser: true, test: TODO },   // for unexpected properties in CSN
     $withLocalized: { test: isBoolean },
     $sources: { parser: true, test: isArray( isString ) },
+    tokenStream: { parser: true, test: TODO },
     $expected: { parser: true, test: isOneOf( [ 'approved-exists', 'exists' ] ) },
     $messageFunctions: { test: TODO },
     $functions: { test: TODO },
@@ -958,6 +977,10 @@ function assertConsistency( model, stage ) {
       throw new InternalConsistencyError( `Expected boolean or null${ at( [ node, parent ], prop ) }` );
   }
 
+  function isNumberVal() {
+    return locationVal( isNumber );
+  }
+
   function isNumber( node, parent, prop, spec ) {
     if (spec.also && spec.also.includes( node ))
       return;

package/lib/compiler/builtins.js

@@ -9,6 +9,7 @@
 
 const { builtinLocation } = require('../base/location');
 const { setLink: setProp } = require('./utils');
+const { isBetaEnabled } = require('../base/model');
 
 // TODO: make type parameters a dict
 const core = {
@@ -31,6 +32,7 @@ const core = {
   Timestamp: { category: 'dateTime' },
   Boolean: { category: 'boolean' },
   UUID: { category: 'string' },
+  Vector: { parameters: [ 'length' /* , 'type' */ ], category: 'vector' },
   Association: { internal: true, category: 'relation' },
   Composition: { internal: true, category: 'relation' },
 };
@@ -190,14 +192,14 @@ function compileArg( src ) {
  */
 const magicVariables = {
   $user: {
-    // id and locale are always available
-    elements: { id: {}, locale: {}, tenant: {} },
+    // always available
+    elements: { id: {}, locale: {} },
     // Allow $user.<any>
     $uncheckedElements: true,
     // Allow shortcut in CDL: `$user` becomes `$user.id` in CSN.
     $autoElement: 'id',
   },
-  $at: { // CDS-specific, not part of SQL
+  $at: {
     elements: {
       from: {}, to: {},
     },
@@ -211,7 +213,8 @@ const magicVariables = {
     // Require that elements are accessed, i.e. no $valid, only $valid.<element>.
     $requireElementAccess: true,
   },
-  $now: {}, // Dito
+  $now: {},
+  $tenant: { $requiresBetaFlag: 'tenantVariable' },
   $session: {
     // In ABAP CDS session variables are accessed in a generic way via
     // the pseudo variable $session.
@@ -229,7 +232,7 @@ const timeRegEx = /^T?(\d{1,2}):(\d{1,2})(?::(\d{1,2}))?(?:Z|[+-]\d{2}(?::\d{2})
 // eslint-disable-next-line max-len
 const timestampRegEx = /^(-?\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2})(\.\d{1,7})?)?(?:Z|[+-]\d{2}(?::\d{2})?)?$/;
 //                          YYYY  -  MM   -  dd    T    HH   :   mm     :  ss     . fraction     TZD
-const numberRegEx = /^[ \t]*[-+]?(\d+(\.\d*)?|\.\d+)(e[-+]\d+)?[ \t]*$/i;
+const numberRegEx = /^[ \t]*[-+]?(\d+(\.\d*)?|\.\d+)(e[-+]?\d+)?[ \t]*$/i;
 
 /**
  * Patterns for literal token tests and creation.  The value is a map from the
@@ -318,9 +321,7 @@ function checkDate( year, month, day ) {
  * Return whether JSON object `val` is a representation for an annotation expression
  */
 function isAnnotationExpression( val ) {
-  // TODO: we might allow `'=': true`, not just a string, for expressions, to be
-  // decided → just check truthy at the moment
-  return val['='] && xprInAnnoProperties.some( prop => val[prop] !== undefined );
+  return val?.['='] !== undefined && xprInAnnoProperties.some( prop => val[prop] !== undefined );
 }
 
 /**
@@ -352,6 +353,7 @@ const typeCategories = {
   boolean: [],
   relation: [],
   geo: [],
+  vector: [],
 };
 // Fill type categories with `cds.*` types
 Object.keys( core ).forEach( (type) => {
@@ -364,46 +366,10 @@ Object.keys( coreHana ).forEach( (type) => {
     typeCategories[coreHana[type].category].push( `cds.hana.${ type }` );
 } );
 
-/** @param {string} typeName */
-function isIntegerTypeName( typeName ) {
-  return typeCategories.integer.includes( typeName );
-}
-/** @param {string} typeName */
-function isDecimalTypeName( typeName ) {
-  return typeCategories.decimal.includes( typeName );
-}
-/** @param {string} typeName */
-function isNumericTypeName( typeName ) {
-  return isIntegerTypeName( typeName ) || isDecimalTypeName( typeName );
-}
-/** @param {string} typeName */
-function isStringTypeName( typeName ) {
-  return typeCategories.string.includes( typeName );
-}
-/** @param {string} typeName */
-function isDateOrTimeTypeName( typeName ) {
-  return typeCategories.dateTime.includes( typeName );
-}
-/** @param {string} typeName */
-function isBooleanTypeName( typeName ) {
-  return typeCategories.boolean.includes( typeName );
-}
-/** @param {string} typeName */
-function isBinaryTypeName( typeName ) {
-  return typeCategories.binary.includes( typeName );
-}
 /** @param {string} typeName */
 function isGeoTypeName( typeName ) {
   return typeCategories.geo.includes( typeName );
 }
-/**
- * Whether the given type name is a relation, i.e. an association or composition.
- *
- * @param {string} typeName
- */
-function isRelationTypeName( typeName ) {
-  return typeCategories.relation.includes( typeName );
-}
 
 /**
  * Checks whether the given absolute path is inside a reserved namespace.
@@ -433,6 +399,16 @@ function isBuiltinType( type ) {
   return typeof type === 'string' && isInReservedNamespace( type );
 }
 
+/**
+ * Tell if a name is a magic variable
+ *
+ * @param {string} name
+ * @returns {boolean}
+ */
+function isMagicVariable( name ) {
+  return typeof name === 'string' && Object.prototype.hasOwnProperty.call(magicVariables, name);
+}
+
 /**
  * Add CDS builtins like the `cds` namespace with types like `cds.Integer` to
  * `definitions` of the XSN model as well as to `$builtins`.
@@ -445,9 +421,14 @@ function initBuiltins( model ) {
   // namespace:"cds" stores the builtins ---
   const cds = createNamespace( 'cds', 'reserved' );
   model.definitions.cds = cds;
+
   // Also add the core artifacts to model.definitions`
-  model.$builtins = env( core, 'cds.', cds );
+  const c = { ...core };
+  if (!isBetaEnabled( model.options, 'vectorType' ))
+    delete c.Vector;
+  model.$builtins = env( c, 'cds.', cds );
   model.$builtins.cds = cds;
+
   // namespace:"cds.hana" stores HANA-specific builtins ---
   const hana = createNamespace( 'cds.hana', 'reserved' );
   model.definitions['cds.hana'] = hana;
@@ -507,6 +488,9 @@ function initBuiltins( model ) {
     model.$magicVariables = { kind: '$magicVariables', elements };
     for (const id in builtins) {
       const magic = builtins[id];
+      if (magic.$requiresBetaFlag && !isBetaEnabled( options, magic.$requiresBetaFlag ))
+        continue;
+
       // TODO: rename to $builtinFunction
       const art = {
         kind: 'builtin',        // TODO: $var
@@ -565,13 +549,6 @@ module.exports = {
   isAnnotationExpression,
   isInReservedNamespace,
   isBuiltinType,
-  isIntegerTypeName,
-  isDecimalTypeName,
-  isNumericTypeName,
-  isStringTypeName,
-  isDateOrTimeTypeName,
-  isBooleanTypeName,
-  isBinaryTypeName,
+  isMagicVariable,
   isGeoTypeName,
-  isRelationTypeName,
 };

package/lib/compiler/checks.js

@@ -15,6 +15,7 @@ const {
   forEachDefinition,
   forEachMember,
   forEachMemberRecursively,
+  isDeprecatedEnabled,
 } = require('../base/model');
 const { CompilerAssertion } = require('../base/error');
 const { typeParameters } = require('./builtins');
@@ -153,13 +154,18 @@ function check( model ) {
     while (effectiveType?.enum)
       effectiveType = (effectiveType._origin || effectiveType.type?._artifact)?._effectiveType;
 
-    if (!effectiveType) {
-      return; // e.g. illegal definition references, cycles, ...
+    if (!effectiveType || (effectiveType.type && !effectiveType.type._artifact)) {
+      return; // e.g. illegal definition references, cycles, unknown artifacts, …
     }
     else if (!art.type && !effectiveType.type && !effectiveType?.builtin) {
-      error( 'type-missing-type', [ art.location, user ],
-             { otherprop: 'type', prop: actualParams[0] },
-             'Missing $(OTHERPROP) property next to $(PROP)' );
+      // Special case for deprecated flag "ignore specified elements": The `type` property
+      // is lost in columns, but `length`,… are kept -> mismatch.  This behavior is the
+      // same as in cds-compiler v3.  See #12169 for details.
+      if (!isDeprecatedEnabled( model.options, 'ignoreSpecifiedQueryElements' )) {
+        error( 'type-missing-type', [ art.location, user ],
+               { otherprop: 'type', prop: actualParams[0] },
+               'Missing $(OTHERPROP) property next to $(PROP)' );
+      }
       return;
     }
 
@@ -182,12 +188,14 @@ function check( model ) {
         } );
         break; // Avoid spam: Only emit the first error.
       }
-      else if (!typeParameters.expectedLiteralsFor[param].includes( art[param].literal )) {
+      else if (!typeParameters.expectedLiteralsFor[param].includes( typeof art[param].val )) {
+        // TODO: this could be probably better done via syntax check (already for CSN input)
         error( 'type-unexpected-argument', [ art[param].location, user ], {
           '#': 'incorrect-type',
           prop: param,
-          code: art[param].literal,
+          code: typeof art[param].val,
           names: typeParameters.expectedLiteralsFor[param],
+          // TODO: no double quote via $(NAMES), but see TODO above
         } );
         break; // Avoid spam: Only emit the first error.
       }
@@ -422,8 +430,8 @@ function check( model ) {
     // Max cardinalities must be a positive number or '*'
     for (const prop of [ 'sourceMax', 'targetMax' ]) {
       if (art.cardinality[prop]) {
-        const { literal, val, location } = art.cardinality[prop];
-        if (!(literal === 'number' && val > 0 || literal === 'string' && val === '*')) {
+        const { val, location } = art.cardinality[prop];
+        if (val !== '*' && val <= 0) {
           error( 'type-invalid-cardinality', [ location, art ],
                  { '#': prop, prop: val, otherprop: '*' } );
         }
@@ -630,24 +638,30 @@ function check( model ) {
   }
 
   function checkCalculatedElementValue( elem ) {
+    const isStored = elem.value.stored?.val;
     visitExpression( elem.value, elem, (xpr, user) => {
       // We only need to check artifact references.  To avoid false positives and conflicts
       // with $self comparison-checks, ignore bare $self.
       const isArtRef = xpr._artifact && !(xpr.path?.length === 1 &&
           xpr.path[0]._navigation?.kind === '$self');
       if (isArtRef) {
-        const sourceLoc = xpr.path?.[xpr.path.length - 1].location || xpr.location;
+        const lastStep = xpr.path?.[xpr.path.length - 1];
+        const sourceLoc = lastStep.location || xpr.location;
         checkExpressionNotVirtual( xpr, user );
         // For inferred (e.g. included) calc elements, this error is already emitted at the origin.
         // And users can't change structured to non-structured elements.
         if (!elem.$inferred && xpr._artifact._effectiveType?.elements) {
           error( 'ref-unexpected-structured', [ sourceLoc, elem ], { '#': 'expr' } );
         }
-        else if (xpr._artifact.target !== undefined) {
-          const variant = isComposition( model, xpr._artifact ) ? 'expr-comp' : 'expr';
+        else if (xpr._artifact.target !== undefined && (!lastStep.where || isStored)) {
+          // Allow using an association _with filter_, but only for on-read calculated elements.
+          // TODO: Also allow bare unmanaged association references and remove beta.
+          const variant = (isStored && lastStep.where && 'assoc-stored') ||
+            (isComposition( model, xpr._artifact ) && 'expr-comp') ||
+            'expr';
           error( 'ref-unexpected-assoc', [ sourceLoc, elem ], { '#': variant } );
         }
-        else if (xpr._artifact.localized?.val && elem.value.stored?.val) {
+        else if (xpr._artifact.localized?.val && isStored) {
           error( 'ref-unexpected-localized', [ sourceLoc, elem ], { '#': 'calc' } );
         }
       }
@@ -807,6 +821,9 @@ function check( model ) {
   // Has been slightly adapted for model.vocabularies but comments need to be
   // adapted, etc.
   function checkAnnotationAssignment1( art, anno ) {
+    if (art.$contains?.$annotation)
+      checkAnnotationExpressions( anno, art );
+
     // Sanity checks (ignore broken assignments)
     if (!anno.name?.id)
       return;
@@ -874,7 +891,6 @@ function check( model ) {
         warning( 'anno-expecting-value', [ anno.location || anno.name.location, art, anno ],
                  { '#': 'std', anno: anno.name.id } );
       }
-
       return;
     }
 
@@ -882,6 +898,22 @@ function check( model ) {
     checkValueAssignableTo( anno, anno, elementDecl, art );
   }
 
+  /**
+   * Check the expressions inside annotations.
+   */
+  function checkAnnotationExpressions( anno, art ) {
+    if (anno.$tokenTexts) {
+      checkGenericExpression( anno, art );
+    }
+    else if (anno.literal === 'array') {
+      anno.val.forEach( val => checkAnnotationExpressions( val, art ) );
+    }
+    else if (anno.literal === 'struct') {
+      const struct = Object.values(anno.struct);
+      struct.forEach(val => checkAnnotationExpressions( val, art ));
+    }
+  }
+
   // Check that annotation assignment 'value' (having 'path or 'literal' and
   // 'val') is potentially assignable to element 'element'. Complain on 'loc'
   // if not

package/lib/compiler/cycle-detector.js

@@ -30,10 +30,7 @@ function detectCycles( definitions, reportCycle, cbScc ) {
 
   for (const name in definitions) {
     const a = definitions[name];
-    if (Array.isArray( a ))
-      a.forEach( strongConnectRec );
-    else
-      strongConnectRec( a );
+    strongConnectRec( a );
   }
   // now the cleanup
   let nodes = Object.getOwnPropertyNames( definitions ).map( n => definitions[n] );

package/lib/compiler/define.js

@@ -133,6 +133,7 @@ const { kindProperties, dictKinds } = require('./base');
 const {
   setLink,
   setMemberParent,
+  createAndLinkCalcDepElement,
   storeExtension,
   dependsOnSilent,
   pathName,
@@ -939,6 +940,8 @@ function define( model ) {
           initExprForQuery( col.value, parent );
         initSelectItems( col, null, user ); // TODO: use col as user (i.e. remove param)
       }
+
+      initItemsLinks( col, parent._block );
     }
 
     if (hasItems && !wildcard && parent.excludingDict && !options.$recompile) {
@@ -974,7 +977,7 @@ function define( model ) {
     // Drill down
     if (exprOrPathElement.args)
       exprOrPathElement.args.forEach( elem => approveExistsInChildren( elem ) );
-    else if (exprOrPathElement.where && exprOrPathElement.where.args)
+    else if (exprOrPathElement.where?.args)
       exprOrPathElement.where.args.forEach( elem => approveExistsInChildren( elem ) );
     else if (exprOrPathElement.path)
       exprOrPathElement.path.forEach( elem => approveExistsInChildren( elem ) );
@@ -998,15 +1001,7 @@ function define( model ) {
     // TODO: split extend from init
     const main = parent._main || parent;
     const isQueryExtension = construct.kind === 'extend' && main.query;
-    let obj = construct;
-    let { items } = obj;
-    while (items) {
-      setLink( items, '_outer', obj );
-      setLink( items, '_parent', obj._parent );
-      setLink( items, '_block', block );
-      obj = items;
-      items = obj.items;
-    }
+    let obj = initItemsLinks( construct, block );
     if (obj.target && targetIsTargetAspect( obj )) {
       obj.targetAspect = obj.target;
       delete obj.target;
@@ -1169,6 +1164,16 @@ function define( model ) {
           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 associations+filter:
+      // See "Notes on `$filtered`" 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;
+      }
     }
   }
 
@@ -1196,6 +1201,26 @@ function define( model ) {
     }
   }
 
+  /**
+   * 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

package/lib/compiler/extend.js

@@ -18,6 +18,7 @@ const {
   copyExpr,
   setExpandStatusAnnotate,
   linkToOrigin,
+  createAndLinkCalcDepElement,
   dependsOnSilent,
   pathName,
   annotationHasEllipsis,
@@ -390,7 +391,8 @@ function extend( model ) {
         col.$extended = true;
 
       if (!query?.from?.path) {
-        error( 'extend-columns', [ ext.columns[$location], ext ], { art } );
+        const variant = (query?.from || query)?.op?.val || 'std';
+        error( 'extend-columns', [ ext.columns[$location], ext ], { '#': variant, art } );
         return;
       }
       if (!query.columns)
@@ -485,12 +487,13 @@ function extend( model ) {
     if ('val' in upToSpec) {
       if (previousItem.val === upToSpec.val) // enum, struct and ref have no val
         return true;
-      const typeUpTo = typeof upToSpec.val;
-      const typePrev = typeof previousItem.val;
-      if (typeUpTo === 'number')
-        return typePrev === 'string' && previousItem.val === upToSpec.val.toString();
-      if (typePrev === 'number')
-        return typeUpTo === 'string' && upToSpec.val === previousItem.val.toString();
+      // TODO v5: delete the speciao UP TO comparison?
+      const upToVal = upToSpec.val;
+      const prevVal = previousItem.val;
+      // eslint-disable-next-line eqeqeq
+      return prevVal == upToVal &&
+        ( typeof upToVal === 'number' && stringCouldHaveBeenCdlNumber( prevVal ) ||
+          typeof prevVal === 'number' && stringCouldHaveBeenCdlNumber( upToVal ) );
     }
     else if (upToSpec.path) {
       return previousItem.path && normalizeRef( previousItem ) === normalizeRef( upToSpec );
@@ -505,6 +508,16 @@ function extend( model ) {
     return false;
   }
 
+  // We only compare a string by number if the string is not empty, and could have
+  // been produced for a CDL number by (a previous version of) the compiler,
+  // i.e. having used a decimal dot, or using the scientific notation:
+  function stringCouldHaveBeenCdlNumber( val ) { // also consider previous compiler versions
+    return val && typeof val === 'string' && /[.eE]/.test( val );
+    // We do not use `!Number.isSafeInteger( Number.parseFloat( text||'0' )`
+    // because it is unlikely that people have written a non-integer like this,
+    // more likely is meant a digit-sequence as string
+  }
+
   function normalizeRef( node ) { // see to-csn.js
     const ref = pathName( node.path );
     // TODO: get rid of name.variant (induces a wrong structure anyway)
@@ -1206,6 +1219,7 @@ function extend( model ) {
             // TODO: Unify with coding in extend.js
             elem.value = Object.assign( { $inferred: 'include' }, copyExpr( origin.value ));
             elem.$syntax = 'calc';
+            createAndLinkCalcDepElement( elem );
             setLink( elem, '_calcOrigin', origin._calcOrigin || origin );
           }
           // TODO: also complain if elem is just defined in art

package/lib/compiler/generate.js

@@ -13,6 +13,7 @@ const {
   setAnnotation,
   linkToOrigin,
   setMemberParent,
+  createAndLinkCalcDepElement,
   augmentPath,
   isDirectComposition,
   copyExpr,
@@ -770,6 +771,8 @@ function generate( model ) {
         // TODO: Unify with coding in extend.js
         proxy.value = Object.assign( { $inferred: 'include' }, copyExpr( origin.value ));
         proxy.$syntax = 'calc';
+        createAndLinkCalcDepElement( proxy );
+        // TODO: re-check _calcOrigin
         setLink( proxy, '_calcOrigin', origin._calcOrigin || origin );
       }
       if (anno)