@sap/cds-compiler 3.3.2 → 3.4.2

package/lib/checks/elements.js

@@ -93,7 +93,7 @@ function checkPrimaryKey(art) {
 function checkVirtualElement(member) {
   if (member.virtual) {
     if (this.csnUtils.isAssociation(member.type)) { // or Composition ???
-      this.error(null, member.$path, {}, `Element can't be virtual and an association`);
+      this.error(null, member.$path, {}, 'Element can\'t be virtual and an association');
     }
   }
 }

package/lib/checks/parameters.js

@@ -12,8 +12,10 @@ const { isPersistedOnDatabase } = require('../model/csnUtils.js');
  */
 function checkForParams(parent, name, params, path) {
   const artifact = this.csn.definitions[path[1]];
-  if (artifact.kind === 'entity' && isPersistedOnDatabase(artifact) && !(parent.kind !== 'entity'))
-    this.error('ref-unexpected-params', [ ...path, 'params' ], `Parameterized views can't be used with sqlDialect “postgres”`);
+  if (artifact.kind === 'entity' && isPersistedOnDatabase(artifact) && !(parent.kind !== 'entity')) {
+    this.error('ref-unexpected-params', [ ...path, 'params' ], { value: this.options.sqlDialect },
+               'Parameterized views can\'t be used with sqlDialect $(VALUE)');
+  }
 }
 
 module.exports = {

package/lib/checks/queryNoDbArtifacts.js

@@ -101,7 +101,7 @@ function checkQueryForNoDBArtifacts(query) {
         this.error(null,
                    obj.$path,
                    { id: pathStep, elemref: obj },
-                   `Path step $(ID) of $(ELEMREF) has no foreign keys`);
+                   'Path step $(ID) of $(ELEMREF) has no foreign keys');
       }
 
       if (art.on) {

package/lib/checks/sql-snippets.js

@@ -13,15 +13,15 @@
  */
 function checkSqlAnnotationOnElement(member, memberName, prop, path) {
   if (member['@sql.replace'])
-    this.error(null, path, { anno: 'sql.replace' }, `Annotation $(ANNO) is reserved and must not be used`);
+    this.error(null, path, { anno: 'sql.replace' }, 'Annotation $(ANNO) is reserved and must not be used');
   if (member['@sql.prepend'])
-    this.message('anno-invalid-sql-element', path, { anno: 'sql.prepend' }, `Annotation $(ANNO) can't be used on elements` );
+    this.message('anno-invalid-sql-element', path, { anno: 'sql.prepend' }, 'Annotation $(ANNO) can\'t be used on elements' );
 
   if (member['@sql.append']) {
     if (this.artifact.query)
-      this.message('anno-invalid-sql-view-element', path, { anno: 'sql.append' }, `Annotation $(ANNO) can't be used on elements in views` );
+      this.message('anno-invalid-sql-view-element', path, { anno: 'sql.append' }, 'Annotation $(ANNO) can\'t be used on elements in views' );
     else if (this.csnUtils.isStructured(member))
-      this.message('anno-invalid-sql-struct', path, { anno: 'sql.append' }, `Annotation $(ANNO) can't be used on structured elements` );
+      this.message('anno-invalid-sql-struct', path, { anno: 'sql.append' }, 'Annotation $(ANNO) can\'t be used on structured elements' );
     else
       checkValidAnnoValue(member, '@sql.append', path, this.error, this.options);
   }
@@ -37,7 +37,7 @@ function checkSqlAnnotationOnElement(member, memberName, prop, path) {
 function checkValidAnnoValue(carrier, annotation, path, error, options) {
   if (carrier[annotation] !== undefined && carrier[annotation] !== null) {
     if (typeof carrier[annotation] !== 'string')
-      error(null, path, { anno: annotation.slice(1), type: typeof carrier[annotation] }, `Annotation $(ANNO) must be a string, found $(TYPE)` );
+      error(null, path, { anno: annotation.slice(1), type: typeof carrier[annotation] }, 'Annotation $(ANNO) must be a string, found $(TYPE)' );
     else if (options.transformation === 'sql') // HDI and HDBCDS do their own checks
       guardAgainstInjection(annotation, carrier[annotation], path, error);
   }
@@ -52,20 +52,22 @@ function checkValidAnnoValue(carrier, annotation, path, error, options) {
 function checkSqlAnnotationOnArtifact(artifact, artifactName) {
   if (artifact.kind !== 'entity') {
     if (artifact['@sql.prepend'])
-      this.message('anno-invalid-sql-kind', [ 'definitions', artifactName ], { name: '@sql.prepend', kind: artifact.kind }, `Annotation $(NAME) can't be used on an artifact of kind $(KIND)` );
+      this.message('anno-invalid-sql-kind', [ 'definitions', artifactName ], { name: '@sql.prepend', kind: artifact.kind }, 'Annotation $(NAME) can\'t be used on an artifact of kind $(KIND)' );
     if (artifact['@sql.append'])
-      this.message('anno-invalid-sql-kind', [ 'definitions', artifactName ], { name: '@sql.append', kind: artifact.kind }, `Annotation $(NAME) can't be used on an artifact of kind $(KIND)` );
+      this.message('anno-invalid-sql-kind', [ 'definitions', artifactName ], { name: '@sql.append', kind: artifact.kind }, 'Annotation $(NAME) can\'t be used on an artifact of kind $(KIND)' );
   }
   else if (artifact['@sql.prepend']) {
     if (artifact.query)
-      this.message('anno-invalid-sql-view', [ 'definitions', artifactName ], { name: '@sql.prepend' }, `Annotation $(NAME) can't be used on views` );
+      this.message('anno-invalid-sql-view', [ 'definitions', artifactName ], { name: '@sql.prepend' }, 'Annotation $(NAME) can\'t be used on views' );
     else
       checkValidAnnoValue(artifact, '@sql.prepend', [ 'definitions', artifactName ], this.error, this.options);
   }
 
 
-  if (artifact['@sql.replace'])
-    this.error(null, [ 'definitions', artifactName ], { anno: 'sql.replace' }, `Annotation $(ANNO) is reserved and must not be used`);
+  if (artifact['@sql.replace']) {
+    this.error(null, [ 'definitions', artifactName ], { anno: 'sql.replace' },
+               'Annotation $(ANNO) is reserved and must not be used');
+  }
 
   checkValidAnnoValue(artifact, '@sql.append', [ 'definitions', artifactName ], this.error, this.options);
 }

package/lib/checks/validator.js

@@ -190,6 +190,19 @@ function mergeCsnValidators(csnValidators, that) {
   return remapped;
 }
 
+/**
+ * Depending on the dialect we need to run different validations.
+ *
+ * @param {CSN.Options} options
+ * @returns {any[]} Array of validator functions (or objects?)
+ */
+function getDBCsnValidators(options) {
+  if (options.sqlDialect === 'postgres' || options.sqlDialect === 'h2')
+    return [ ...forRelationalDBCsnValidators, checkForHanaTypes, checkForParams ];
+
+  return forRelationalDBCsnValidators;
+}
+
 /**
  * @param {CSN.Model} csn CSN to check
  * @param {object} that Will be provided to the validators via "this"
@@ -197,10 +210,7 @@ function mergeCsnValidators(csnValidators, that) {
  */
 function forRelationalDB(csn, that) {
   return _validate(csn, that,
-                   that.options.sqlDialect === 'postgres'
-                     ? [ ...forRelationalDBCsnValidators,
-                       checkForHanaTypes,
-                       checkForParams ] : forRelationalDBCsnValidators,
+                   getDBCsnValidators(that.options),
                    forRelationalDBMemberValidators.concat(commonMemberValidators),
                    forRelationalDBArtifactValidators.concat(commonArtifactValidators).concat(
                      // why is this hana exclusive

package/lib/compiler/assert-consistency.js

@@ -295,7 +295,7 @@ function assertConsistency( model, stage ) {
       none: { optional: () => true }, // parse error
     },
     columns: {
-      kind: [ 'extend' ],
+      kind: [ 'extend', '$column' ],
       test: isArray( column ),
       optional: thoseWithKind,
       enum: [ '*' ],
@@ -363,12 +363,13 @@ function assertConsistency( model, stage ) {
     suffix: { test: TODO },
     kind: {
       isRequired: !stageParser && (() => true),
+      kind: true,
       // required to be set by Core Compiler even with parse errors
       test: isString,
       enum: [
         'context', 'service', 'entity', 'type', 'aspect', 'const', 'annotation',
         'element', 'enum', 'action', 'function', 'param', 'key', 'event',
-        'annotate', 'extend',
+        'annotate', 'extend', '$column',
         'select', '$join', 'mixin',
         'source', 'namespace', 'using',
         '$tableAlias', '$navElement',
@@ -398,7 +399,7 @@ function assertConsistency( model, stage ) {
         requires: [ 'location', 'path' ],
         optional: [ 'scope', 'variant', '_artifact', '$inferred', '$parens', 'sort', 'nulls' ],
       },
-      none: { optional: [ 'location', '$parens' ] },
+      none: { optional: () => true }, // parse error
       // TODO: why optional / enough in name?
       // TODO: "yes" instead "none": val: true, optional literal/location
       val: {
@@ -821,7 +822,7 @@ function assertConsistency( model, stage ) {
     const sub = Object.assign( {}, s.inherits && schema[s.inherits], s );
     if (spec.requires && sub.requires)
       sub.requires = [ ...sub.requires, ...spec.requires ];
-    if (spec.optional && sub.optional)
+    if (Array.isArray( spec.optional ) && Array.isArray( sub.optional ))
       sub.optional = [ ...sub.optional, ...spec.optional ];
     // console.log(expressionSpec(node) );
     (sub.test || standard)( node, parent, prop, sub, idx );
@@ -834,9 +835,9 @@ function assertConsistency( model, stage ) {
       return 'val';
     else if (node.query)
       return 'query';
-    else if (!node.op)
-      return 'none';
-    return 'op';
+    else if (node.op)
+      return 'op';
+    return 'none';              // parse error
   }
 
   function args( node, parent, prop, spec ) {

package/lib/compiler/checks.js

@@ -18,6 +18,8 @@ const builtins = require('../compiler/builtins');
 const {
   forEachGeneric, forEachDefinition, forEachMember,
 } = require('../base/model');
+const { CompilerAssertion } = require('../base/error');
+const { pathName } = require('./utils');
 
 function check( model ) {       // = XSN
   const {
@@ -66,7 +68,7 @@ function check( model ) {       // = XSN
     forEachGeneric( elem, 'elements', checkElement );
   }
 
-  function checkName( construct ) {
+  function checkName( construct ) { // TODO: move to define.js
     if (model.options.$skipNameCheck)
       return;
     // TODO: Move a corrected version of this check to definer (but do not rely
@@ -78,11 +80,11 @@ function check( model ) {       // = XSN
     }
   }
 
-  // TODO: move into definer.js
   function checkLocalizedElement(elem) {
     // if it is directly a localized element
     if (elem.localized && elem.localized.val) {
       const type = elem._effectiveType;
+      // See discussion issue #6520: should we allow all scalar types?
       if (!type || !type.builtin || type.category !== 'string') {
         warning(null, [ elem.type?.location, elem ], { keyword: 'localized' },
                 'Keyword $(KEYWORD) should only be used in combination with string types');
@@ -339,6 +341,7 @@ function check( model ) {       // = XSN
   }
 
   // Check that min and max cardinalities of 'elem' in 'art' have legal values
+  // TODO: move to define.js or parsers
   function checkCardinality(elem) {
     if (!elem.cardinality)
       return;
@@ -382,13 +385,16 @@ function check( model ) {       // = XSN
 
     // If provided, min cardinality must not exceed max cardinality (note that
     // '*' is considered to be >= any number)
-    const pair = [ [ 'sourceMin', 'sourceMax', 'Source' ], [ 'targetMin', 'targetMax', 'Target' ] ];
+    const pair = [ [ 'sourceMin', 'sourceMax', 'source' ], [ 'targetMin', 'targetMax', 'target' ] ];
     pair.forEach((p) => {
       if (elem.cardinality[p[0]] && elem.cardinality[p[1]] &&
           elem.cardinality[p[1]].literal === 'number' &&
           elem.cardinality[p[0]].val > elem.cardinality[p[1]].val) {
-        error(null, [ elem.cardinality.location, elem ], {},
-              `${ p[2] } minimum cardinality must not be greater than ${ p[2].toLowerCase() } maximum cardinality`);
+        error(null, [ elem.cardinality.location, elem ], { '#': p[2] }, {
+          std: 'Minimum cardinality must not be greater than maximum cardinality', // variant unused
+          source: 'Source minimum cardinality must not be greater than source maximum cardinality',
+          target: 'Target minimum cardinality must not be greater than target maximum cardinality',
+        });
       }
     });
   }
@@ -494,7 +500,7 @@ function check( model ) {       // = XSN
   // associations can be followed (in the ON condition)
   //
   // TODO: this function must be completely reworked, probably even before
-  // integration into name resulution - did the first step.
+  // integration into name resolution - did the first step.
   // It is also incomplete, as associations in structures are not checked.
   // Additionally, `$self.assoc` references are also not found.
   function singleCheckUnmanagedAssocCondArgumentNoFollowUnmanagedAssoc(elem, arg, op) {
@@ -639,8 +645,10 @@ function check( model ) {       // = XSN
               'An association can\'t be used as a value in an expression');
       }
 
-      if (isDollarSelfOrProjectionOperand(arg))
-        error(null, arg.location, {}, `"${ arg.path[0].id }" can only be used as a value in a comparison to an association`);
+      if (isDollarSelfOrProjectionOperand(arg)) {
+        error(null, arg.location, { id: arg.path[0].id },
+              '$(ID) can only be used as a value in a comparison to an association');
+      }
 
       // Recursively traverse the argument expression
       checkTreeLikeExpression(arg, allowAssocTail);
@@ -739,7 +747,9 @@ function check( model ) {       // = XSN
 
     // Element must exist in annotation
     if (!elementDecl) {
-      warning(null, anno.location || anno.name.location, {}, `Element "${ anno.name.path.map(step => step.id).join('.') }" not found for annotation "${ annoDecl.name.absolute }"`);
+      warning(null, anno.location || anno.name.location,
+              { name: pathName(anno.name.path), anno: annoDecl.name.absolute },
+              'Element $(NAME) not found for annotation $(ANNO)');
       return;
     }
 
@@ -751,8 +761,8 @@ function check( model ) {       // = XSN
     // Must have literal or path unless it is a boolean
     if (!anno.literal && !anno.path && getFinalTypeNameOf(elementDecl) !== 'cds.Boolean') {
       if (elementDecl.type && elementDecl.type._artifact.name.absolute) {
-        warning(null, anno.location || anno.name.location, {},
-                `Expecting a value of type "${ elementDecl.type._artifact.name.absolute }" for the annotation`);
+        warning(null, anno.location || anno.name.location, { type: elementDecl.type._artifact },
+                'Expecting a value of type $(TYPE) for the annotation');
       }
       else {
         warning(null, anno.location || anno.name.location, {},
@@ -807,31 +817,31 @@ function check( model ) {       // = XSN
     if (builtins.isStringTypeName(type)) {
       if (value.literal !== 'string' && value.literal !== 'enum' &&
           !elementDecl._effectiveType.enum)
-        warning(null, loc, {}, `A string value is required for type "${ type }"`);
+        warning(null, loc, { type }, 'A string value is required for type $(TYPE)');
     }
     else if (builtins.isBinaryTypeName(type)) {
       if (value.literal !== 'string' && value.literal !== 'x')
-        warning(null, loc, {}, `A hexadecimal string value is required for type "${ type }"`);
+        warning(null, loc, { type }, 'A hexadecimal string value is required for type $(TYPE)');
     }
     else if (builtins.isNumericTypeName(type)) {
       if (value.literal !== 'number' && value.literal !== 'enum' &&
           !elementDecl._effectiveType.enum)
-        warning(null, loc, {}, `A numerical value is required for type "${ type }"`);
+        warning(null, loc, { type }, 'A numerical value is required for type $(TYPE)');
     }
     else if (builtins.isDateOrTimeTypeName(type)) {
       if (value.literal !== 'date' && value.literal !== 'time' &&
           value.literal !== 'timestamp' && value.literal !== 'string')
-        warning(null, loc, {}, `A date/time value or a string is required for type "${ type }"`);
+        warning(null, loc, { type }, 'A date/time value or a string is required for type $(TYPE)');
     }
     else if (builtins.isBooleanTypeName(type)) {
       if (value.literal && value.literal !== 'boolean')
-        warning(null, loc, {}, `A boolean value is required for type "${ type }"`);
+        warning(null, loc, { type }, 'A boolean value is required for type $(TYPE)');
     }
     else if (builtins.isRelationTypeName(type) || builtins.isGeoTypeName(type)) {
-      warning(null, loc, {}, `Type "${ type }" can't be assigned a value`);
+      warning(null, loc, { type }, 'Type $(TYPE) can\'t be assigned a value');
     }
     else {
-      throw new Error(`Unknown primitive type name: ${ type }`);
+      throw new CompilerAssertion(`Unknown primitive type name: ${ type }`);
     }
 
     // Check enums
@@ -841,12 +851,12 @@ function check( model ) {       // = XSN
         // Enum symbol provided and expected
         if (!expectedEnum[value.sym.id]) {
           // .. but no such constant
-          warning(null, loc, {}, `Enum symbol "#${ value.sym.id }" not found in enum`);
+          warning(null, loc, { id: `#${ value.sym.id }` }, 'Enum symbol $(ID) not found in enum');
         }
       }
       else {
         // Enum symbol provided but not expected
-        warning(null, loc, {}, `Can't use enum symbol "#${ value.sym.id }" for non-enum type "${ type }"`);
+        warning(null, loc, { id: `#${ value.sym.id }`, type }, 'Can\'t use enum symbol $(ID) for non-enum type $(TYPE)');
       }
     }
     else if (expectedEnum) {

package/lib/compiler/define.js

@@ -1,15 +1,31 @@
-// Compiler phase "define": transform dictionary of AST-like CSNs into augmented CSN
+// Compiler phase 1 = "define": transform dictionary of AST-like XSNs into XSN
 
-// AST-like CSN looks as follows:
-//   { kind: 'source', env: <dictionary of artifact defs>, namespace: {}, ... }
+// The 'define' phase (function 'define' below) is the first phase of the compile
+// function.  In it, the compiler
+//
+//  - collects definitions and extensions from the XSN representation of CDL and
+//    CSN sources (“ASTs”) into _one_ XSN model,
+//  - sets “structural” links between XSN nodes and completes the “name”,
+//    some links and names inside `extensions` are set at a later stage
+//  - reports errors for: “late” syntax errors (when it is more convenient to do
+//    it here instead of doing it in both CDL and CSN parser), “structural” errors
+//    and “duplicate definition errors”
+
+// 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 CSNs and restructure them a little bit, the result
-// is called "augmented CSN":
+// (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).
@@ -20,14 +36,8 @@
 // objects as the definitions accessible via `sources` and `artifacts` of the
 // corresponding source/context.
 //
-// Because different sources could define artifacts with the same absolute
-// name, this compiler phase also put a property `messages` to the resulting
-// model, which is a vector of messages for the redefinitions.  (Using the same
-// name for different definitions in one source is already recognized during
-// parsing.)
-//
 // You get the compact "official" CSN format by applying the function exported
-// by "../json/to-csn.js" to the augmented CSN.
+// by "../json/to-csn.js" to the XSN.
 
 // Example 'file.cds':
 //   namespace A;
@@ -54,7 +64,7 @@
 // An artifact definition looks as follows (example: context "A.B" above):
 //   {
 //     kind: 'context',
-//     name: { id: 'B', absolute: 'A.B', location: { <for the id "B"> } },
+//     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'>
@@ -74,11 +84,10 @@
 //     location: { <of the complete element definition> } },
 //     _parent: <the parent artifact, here the type "A.B.C">
 //   }
-// References are resolved in the "resolve" phase of the compiler, see
-// './resolver.js'.  We then get the properties `type.absolute` and `length`.
+// --------- TODO: end in extra markdown document -------------------------------
 
 // Sub phase 1 (addXYZ) - only for main artifacts
-//  - set _block links
+//  - set _block links for main definitions, vocabulary and extensions
 //  - store definitions (including context extensions), NO duplicate check
 //  - artifact name check
 //  - Note: the only allow name resolving is resolveUncheckedPath(),
@@ -96,6 +105,7 @@
 // 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.
 //  - We must have a property at the artifact whether there are duplicates in order
 //    to avoid consequential or repeated errors.
@@ -121,6 +131,7 @@ const {
   dependsOnSilent,
   pathName,
   splitIntoPath,
+  annotationHasEllipsis,
 } = require('./utils');
 const { compareLayer } = require('./moduleLayers');
 const { initBuiltins, isInReservedNamespace } = require('./builtins');
@@ -148,15 +159,15 @@ function define( model ) {
   const {
     resolveUncheckedPath,
     checkAnnotate,
-    defineAnnotations,
   } = model.$functions;
 
   const extensionsDict = Object.create(null);
   Object.assign( model.$functions, {
     initArtifact,
     initMembers,
-    extensionsDict,             // a dictionary - TODO: remove
+    extensionsDict,             // a dictionary - TODO: put directly into model?
     checkDefinitions,
+    initAnnotations,
   } );
   // During the definer, we can only resolve artifact references, i.e,
   // after a `.`, we only search in the `_subArtifacts` dictionary:
@@ -193,6 +204,7 @@ function define( model ) {
       initNamespaceAndUsing( model.sources[name] );
     dictForEach( model.definitions, initArtifact );
     dictForEach( model.vocabularies, initVocabulary );
+    dictForEach( extensionsDict, initExtension );
 
     mergeI18nBlocks();
   }
@@ -394,7 +406,7 @@ function define( model ) {
 
   // Phase 2 ("init") --------------------------------------------------------
   // Functions called from top-level: initNamespaceAndUsing(), initArtifact(),
-  // initVocabulary()
+  // initVocabulary(), initExtension()
 
   function checkRedefinition( art ) {
     if (!art.$duplicates || art.$errorReported === 'syntax-duplicate-extend' ||
@@ -461,11 +473,11 @@ function define( model ) {
       initParentLink( art, model.definitions );
     const block = art._block;
     checkRedefinition( art );
-    defineAnnotations( art, art, block );
+    initAnnotations( art, block );
     initMembers( art, art, block );
     initDollarSelf( art );      // $self
     if (art.params)
-      initParams( art );        // $parameters
+      initDollarParameters( art );
     if (art.includes && !(art.name.absolute in extensionsDict)) // TODO: in next phase?
       extensionsDict[art.name.absolute] = []; // structure with includes must be "extended"
 
@@ -492,7 +504,7 @@ function define( model ) {
     initParentLink( art, model.vocabularies );
     checkRedefinition( art );
     const block = art._block;
-    defineAnnotations( art, art, block );
+    initAnnotations( art, block );
     initMembers( art, art, block );
   }
 
@@ -518,6 +530,57 @@ function define( model ) {
       parent._subArtifacts[absolute.substring( dot + 1 )] = art; // not dictAdd()
   }
 
+  /** Initialize the extension `ext`.
+   *
+   * Currently:
+   *
+   *  - initialize annotations (set _block, $priority, `...` check) on "main"
+   *    extension and its columns do more later
+   *  - for members in compile(): init annotations via extendMembers/annotateMembers
+   *  - for members in parse.cdl(): init annotation via initMembers
+   *
+   * In the future:
+   *
+   *  - also initialize members and member extensions/annotations here
+   *  - we might also do other things, like calculating whether an `extend` is
+   *    `annotate`-like, i.e. only contains name-resolution irrelevant extensions.
+   */
+  function initExtension( ext ) {
+    const block = ext._block;
+    initAnnotations( ext, block, ext.kind );
+    if (ext.columns)            // the columns themselves are "definitions"
+      ext.columns.forEach( col => initAnnotations( col, block ) );
+  }
+
+  // Set _block links for annotations (necessary for layering) and do a late
+  // syntax check (`...` only with extensions, not definitions).
+  // extKind is either ext.kind (=art is extension) or false (=art is not an extension)
+  function initAnnotations( art, block, extKind = false ) {
+    // TODO: think of removing $priority, then
+    // no _block: define, _block: annotate/extend/edmx
+    // would fit with extending defs with props like length
+    for (const prop in art) {
+      if (prop.charAt(0) === '@') {
+        const anno = art[prop];
+        // TODO: make anno never be an array, see addAnnotation() in genericAntlrParser
+        if (Array.isArray( anno ))
+          anno.forEach( init );
+        else
+          init( anno );
+      }
+    }
+    return;
+
+    function init( anno ) {
+      setLink( anno, '_block', block );
+      anno.$priority = extKind;
+      if (!extKind && annotationHasEllipsis( anno )) {
+        error( 'anno-unexpected-ellipsis',
+               [ anno.name.location, art ], { code: '...' } );
+      }
+    }
+  }
+
   // From here til EOF, reexamine code ---------------------------------------
   // See populate:
   // - userQuery() or _query property?
@@ -543,7 +606,8 @@ function define( model ) {
     setLink( art, '_$next', model.$magicVariables );
   }
 
-  function initParams( art ) {
+  function initDollarParameters( art ) {
+    // TODO: remove $parameters in v4?
     // TODO: use setMemberParent() ?
     const parameters = {
       name: { id: '$parameters', param: '$parameters', absolute: art.name.absolute },
@@ -606,7 +670,7 @@ function define( model ) {
       // Either expression (value), expand or new association (target && type)
       else if (col.value || col.expand || (col.target && col.type)) {
         setLink( col, '_block', parent._block );
-        defineAnnotations( col, col, parent._block );
+        initAnnotations( col, parent._block );
         if (col.inline) { // `@anno elem.{ * }` does not work
           if (col.doc)
             warning( 'syntax-ignoring-anno', [ col.doc.location, col ], { '#': 'doc' } );
@@ -1025,7 +1089,7 @@ function define( model ) {
       checkRedefinition( elem );
       if (elem.kind === 'annotate' || elem.kind === 'extend')
         checkAnnotate( elem, elem );
-      defineAnnotations( elem, elem, bl );
+      initAnnotations( elem, bl );
       initMembers( elem, elem, bl, initExtensions );
 
       // for a correct home path, setMemberParent needed to be called