@sap/cds-compiler 4.4.4 → 4.5.0

package/lib/base/messages.js

@@ -797,15 +797,16 @@ function tokenSymbol( token ) {
  * Transform an element reference (/path), e.g. on-condition path.
  */
 function transformElementRef( arg ) {
-  if (arg.ref) {
-    // Can be used by CSN backends to create a simple path such as E:elem
-    return quoted(arg.ref.map((ref) => {
-      if (ref.id)
-        return `${ ref.id }${ref.args ? '(…)' : ''}${ref.where ? '[…]' : ''}`;
-      return ref;
-    }).join('.'));
-  }
-  return quoted(arg);
+  const ref = arg.ref || arg.path;
+  if (!ref)
+    return quoted( arg );
+  // Can be used by CSN backends or compiler to create a simple path such as E:elem
+  return quoted(
+    ref.map(
+      item => (typeof item !== 'string'
+               ? `${ item.id }${item.args ? '(…)' : ''}${item.where ? '[…]' : ''}`
+               : item) )
+      .join('.') );
 }
 
 function transformArg( arg, r, args, texts ) {
@@ -1299,7 +1300,7 @@ function deduplicateMessages( messages ) {
 }
 
 function shortArtName( art ) {
-  if (!art.name)
+  if (!art.name || art.kind === '$annotation')
     return artName( art );
   const name = getArtifactName( art );
   if ([ 'select', 'action', 'alias', 'param' ].every( n => name[n] == null || name[n] === 1 ) &&
@@ -1310,7 +1311,7 @@ function shortArtName( art ) {
 
 function artName( art, omit ) {
   let suffix = 0;
-  while (!art.name && art._outer) {
+  while (!art.name && art._outer && art.kind !== '$annotation') {
     ++suffix;
     art = art._outer;
   }
@@ -1367,8 +1368,12 @@ function homeName( art, absoluteOnly ) {
     return art;
   if (art._user)               // when providing a path item with filter as “user”
     return homeName( art._user, absoluteOnly );
-  if (art._outer)               // in items property
-    return homeName( art._outer, absoluteOnly );
+  if (art._outer) {              // in items property, or annotation with path
+    const outer = homeName( art._outer, absoluteOnly );
+    return (art.kind === '$annotation')
+      ? `${ outer }/${ quoted( '@' + art.name.id ) }`
+      : outer;
+  }
   else if (art.kind === 'source' || !art.name) // error reported in parser or on source level
     return null;
   else if (art.kind === 'using')

package/lib/base/model.js

@@ -27,6 +27,7 @@ const queryOps = {
 const availableBetaFlags = {
   // enabled by --beta-mode
   annotationExpressions: true,
+  odataAnnotationExpressions: true,
   assocsWithParams: true, // beta, because runtimes don't support it, yet.
   hanaAssocRealCardinality: true,
   mapAssocToJoinCardinality: true, // only SAP HANA HEX engine supports it
@@ -35,6 +36,8 @@ const availableBetaFlags = {
   optionalActionFunctionParameters: true, // not supported by runtime, yet.
   annotateForeignKeys: true,
   effectiveCsn: true,
+  tenantVariable: true,
+  calcAssoc: true,
   // disabled by --beta-mode
   nestedServices: false,
 };

package/lib/checks/annotationsOData.js

@@ -66,9 +66,58 @@ function checkReadOnlyAndInsertOnly( artifact, artifactName ) {
     this.warning(null, artifact.$path, {}, 'Annotations “@readonly” and “@insertonly” can\'t be assigned in combination');
 }
 
+/**
+ * Check temporal annotations @cds.valid.from, @cds.valid.to, @cds.valid.key
+ * assignment for the given artifact. This consists of the following:
+ * - @cds.valid.from/to/key annotation is assigned only once in the scope of the definition
+ * - annotation is assigned only to allowed element types. Not allowed on association/composition,
+ *   structured elements, leaf element of a structure
+ * - when @cds.valid.key is used, it requires also @cds.valid.from and @cds.valid.to to be defined
+ * @param {CSN.Artifact} artifact
+ * @param {string} artifactName
+ */
+function checkTemporalAnnotationsAssignment( artifact, artifactName ) {
+  const valid = { from: [], to: [], key: [] };
+
+  // collect annotation assignments throughout the elements of the definition
+  this.recurseElements( artifact, artifact.$path || [ 'definitions', artifactName ], (member, path) => {
+    checkForAnnoAssignmentAndApplicability.bind(this)('from', member, path);
+    checkForAnnoAssignmentAndApplicability.bind(this)('to', member, path);
+    checkForAnnoAssignmentAndApplicability.bind(this)('key', member, path);
+  });
+
+  // check if the annotations are assigned more than once in the scope of the current artifact
+  this.checkMultipleAssignments(valid.from, '@cds.valid.from', artifact, artifactName);
+  this.checkMultipleAssignments(valid.to, '@cds.valid.to', artifact, artifactName);
+  this.checkMultipleAssignments(valid.key, '@cds.valid.key', artifact, artifactName);
+
+  // if @cds.valid.key is defined, check whether @cds.valid.from and @cds.valid.to are also there
+  if (valid.key.length && !(valid.from.length && valid.to.length))
+    this.error(null, [ 'definitions', artifactName ], 'Annotation “@cds.valid.key” was used but “@cds.valid.from” and “@cds.valid.to” are missing');
+
+  /**
+   * Check if the given annotation is assigned to the current member and collect the path if so.
+   * Also determine whether the annotation is applicable for the member type. @cds.valid.from/to.key annotations
+   * are NOT allowed for elements which are: association/composition, structured or leaf element of a structure
+   *
+   * @param {string} annoIdentifier
+   * @param {CSN.Element} member
+   * @param {CSN.Path} path
+   */
+  function checkForAnnoAssignmentAndApplicability( annoIdentifier, member, path ) {
+    if (this.csnUtils.hasAnnotationValue(member, `@cds.valid.${ annoIdentifier }`)) {
+      valid[annoIdentifier].push(path);
+      // check whether annotation is not assigned to not allowed element type, these are: association, structured elements, leaf element of a structure
+      if (this.csnUtils.isAssocOrComposition(member) || this.csnUtils.isStructured(member) || path.length > 5)
+        this.error(null, member.$path, { anno: `@cds.valid.${ annoIdentifier }` }, 'Element can\'t be annotated with $(ANNO)');
+    }
+  }
+}
+
 module.exports = {
   checkCoreMediaTypeAllowance,
   checkAnalytics,
   checkAtSapAnnotations,
   checkReadOnlyAndInsertOnly,
+  checkTemporalAnnotationsAssignment,
 };

package/lib/checks/validator.js

@@ -22,6 +22,7 @@ const { checkActionOrFunction } = require('./actionsFunctions');
 const {
   checkCoreMediaTypeAllowance, checkAnalytics,
   checkAtSapAnnotations, checkReadOnlyAndInsertOnly,
+  checkTemporalAnnotationsAssignment,
 } = require('./annotationsOData');
 // both
 const { validateOnCondition, validateMixinOnCondition } = require('./onConditions');
@@ -136,10 +137,10 @@ const commonQueryValidators = [ validateMixinOnCondition ];
  *
  * @param {CSN.Model} csn CSN to check
  * @param {object} that Will be provided to the validators via "this"
- * @param {object[]} [csnValidators=[]] Validations on whole CSN using applyTransformations
- * @param {Function[]} [memberValidators=[]] Validations on member-level
- * @param {Function[]} [artifactValidators=[]] Validations on artifact-level
- * @param {Function[]} [queryValidators=[]] Validations on query-level
+ * @param {object[]} [csnValidators] Validations on whole CSN using applyTransformations
+ * @param {Function[]} [memberValidators] Validations on member-level
+ * @param {Function[]} [artifactValidators] Validations on artifact-level
+ * @param {Function[]} [queryValidators] Validations on query-level
  * @param {object} iterateOptions can be used to skip certain kinds from being iterated e.g. 'action' and 'function' for hana
  * @returns {Function} Function taking no parameters, that cleans up the attached helpers
  */
@@ -267,6 +268,7 @@ function forOdata( csn, that ) {
                            checkAtSapAnnotations.bind(that),
                          ]);
                        }
+                       checkTemporalAnnotationsAssignment.bind(that)(artifact, artifactName);
                      }
                    ),
                    // eslint-disable-next-line sonarjs/no-empty-collection

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
       ],
     },
@@ -505,7 +512,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 +562,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 +572,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 +594,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 +619,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 +642,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 +720,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 +976,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 = {
@@ -190,14 +191,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 +212,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 +231,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
@@ -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.
@@ -507,6 +473,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 +534,5 @@ module.exports = {
   isAnnotationExpression,
   isInReservedNamespace,
   isBuiltinType,
-  isIntegerTypeName,
-  isDecimalTypeName,
-  isNumericTypeName,
-  isStringTypeName,
-  isDateOrTimeTypeName,
-  isBooleanTypeName,
-  isBinaryTypeName,
   isGeoTypeName,
-  isRelationTypeName,
 };

package/lib/compiler/checks.js

@@ -182,12 +182,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 +424,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 +632,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' } );
         }
       }

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,
@@ -974,7 +975,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 ) );
@@ -1169,6 +1170,8 @@ 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 );
     }
   }
 

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)