@sap/cds-compiler 2.15.8 → 3.1.0

package/lib/compiler/assert-consistency.js

@@ -97,7 +97,6 @@ function assertConsistency( model, stage ) {
         '$lateExtensions',
         '_entities', '$entity',
         '$blocks',
-        '$newfeatures',
         '$messageFunctions',
         '$functions',
         '$volatileFunctions',
@@ -118,8 +117,10 @@ function assertConsistency( model, stage ) {
         '$sources',
       ],
     },
-    location: {                 // location req if at least one property:
-      isRequired: parent => noSyntaxErrors() || Object.keys( parent ).length,
+    location: {
+      // every thing with a $location in CSN must have a XSN location even
+      // with syntax errors (currently even internal artifacts like $using):
+      isRequired: parent => noSyntaxErrors() || parent && parent.kind,
       kind: true,
       requires: [ 'file' ],     // line is optional in top-level location
       optional: [ 'line', 'col', 'endLine', 'endCol', '$notFound' ],
@@ -141,7 +142,6 @@ function assertConsistency( model, stage ) {
     },
     fileDep: { test: TODO },    // in usings
     $frontend: { parser: true, test: isString, enum: [ 'cdl', 'json', 'xml' ] },
-    $newfeatures: { test: TODO }, // if new features have been used which break the old backends
     messages: {
       enumerable: () => true,  // does not matter (non-enum std), enum in CSN/XML parser
       test: isArray( TODO ),
@@ -173,7 +173,6 @@ function assertConsistency( model, stage ) {
         return innerDict( val, parent, lang, spec );
       } ),
     },
-    _assocSources: { kind: true, test: TODO }, // just null: isArray( inDefinitions ) during resolve
     $magicVariables: {
       // $magicVariables contains "builtin" artifacts that differ from
       // "normal artifacts" and therefore have a custom schema
@@ -185,12 +184,16 @@ function assertConsistency( model, stage ) {
           // are missing the location property
           test: isDictionary( definition ),
           requires: [ 'kind', 'name' ],
-          optional: [ 'elements', '$autoElement', '$uncheckedElements', '_effectiveType', '_deps' ],
+          optional: [
+            'elements', '$autoElement', '$uncheckedElements',
+            '$requireElementAccess', '_effectiveType', '_deps',
+          ],
           schema: {
             kind: { test: isString, enum: [ 'builtin' ] },
             name: { test: isObject, requires: [ 'id', 'element' ] },
             $autoElement: { test: isString },
             $uncheckedElements: { test: isBoolean },
+            $requireElementAccess: { test: isBoolean },
             // missing location for normal "elements"
             elements: { test: TODO },
           },
@@ -217,8 +220,7 @@ function assertConsistency( model, stage ) {
     usings: {
       test: isArray(),
       requires: [ 'kind', 'location' ],
-      optional: [ 'name', 'extern', 'usings', '$annotations', 'fileDep' ],
-      // TODO: get rid of $annotations: []
+      optional: [ 'name', 'extern', 'usings', 'fileDep' ],
     },
     extern: {
       requires: [ 'location', 'path' ],
@@ -251,6 +253,7 @@ function assertConsistency( model, stage ) {
           'where', 'groupBy', 'having', 'orderBy', '$orderBy', 'limit',
           '_projections', '_block', '_parent', '_main', '_effectiveType', '$expand',
           '$tableAliases', 'kind', '_$next', '_combined', '$inlines', '_status',
+          '_extension', // for unapplied extensions
         ],
       },
       none: { optional: () => true }, // parse error
@@ -304,7 +307,6 @@ function assertConsistency( model, stage ) {
       kind: 'element',
       test: isDictionary( definition ), // definition since redef
       requires: [ 'location', 'name' ],
-      optional: [ '$annotations' ], // TODO: get rid of annos: []
     },
     orderBy: { inherits: 'value', test: isArray( expression ) },
     sort: { test: locationVal( isString ), enum: [ 'asc', 'desc' ] },
@@ -371,13 +373,21 @@ function assertConsistency( model, stage ) {
     },
     // locations of parentheses pairs around expression:
     $parens: { parser: true, test: TODO },
+    $prefix: { test: isString }, // compiler-corrected path prefix
     $syntax: {
       parser: true,
       kind: [ 'entity', 'view', 'type', 'aspect' ],
       test: isString,            // CSN parser should check for 'entity', 'view', 'projection'
     },
     value: {
-      optional: [ 'location', '$inferred', 'sort', 'nulls' ],
+      optional: [
+        'location', '$inferred', 'sort', 'nulls',
+        'param', 'scope', // for dynamic parameter '?'
+        // through cast() with enum through CSN->XSN
+        // TODO: re-check #9225, this should be directly in the query element,
+        // not inside value, no `enum` inside `cast`!
+        'elements', 'items', 'enum', '$expand', 'target',
+      ],
 
       kind: true,
       test: expression,         // properties below are "sub specifications"
@@ -435,7 +445,10 @@ function assertConsistency( model, stage ) {
     struct: { inherits: 'val', test: isDictionary( definition ) }, // def because double @
     args: {
       inherits: 'value',
-      optional: [ 'name', '$duplicate', '$expected', 'args', 'suffix' ],
+      optional: [
+        'name', '$duplicate', '$expected', 'args', 'suffix',
+        'param', 'scope', // for dynamic parameter '?'
+      ],
       test: args,
     },
     on: { kind: true, inherits: 'value', test: expression },
@@ -449,11 +462,11 @@ function assertConsistency( model, stage ) {
     '@': {
       kind: true,
       inherits: 'value',
-      optional: [ 'name', '_block', '$priority', '$duplicate', '$inferred', '$duplicates' ],
+      optional: [ 'name', '_block', '$priority', '$inferred', '$duplicates', '$errorReported' ],
       // TODO: name requires if not in parser?
     },
-    $priority: { test: TODO }, // TODO: rename to $priority
-    $annotations: { parser: true, kind: true, test: TODO },
+    $priority: { test: isOneOf([ undefined, false, 'extend', 'annotate' ]) },
+    $annotations: { parser: true, kind: true, test: TODO }, // deprecated, still there for cds-lsp
     name: {
       isRequired: stageParser && (() => false), // not required in parser
       kind: true,
@@ -468,10 +481,10 @@ function assertConsistency( model, stage ) {
       ],
     },
     absolute: { test: isString },
-    variant: { test: TODO }, // TODO: not set in CDL parser, only in $annotations
+    variant: { test: TODO }, // TODO: not set in CDL parser
     element: { test: TODO }, // TODO: { test: isString },
     action: { test: isString },
-    param: { test: isString },
+    param: { test: TODO },
     alias: { test: isString },
     expectedKind: { kind: [ 'extend' ], inherits: 'kind' },
     virtual: { kind: true, test: locationVal() },
@@ -524,7 +537,6 @@ function assertConsistency( model, stage ) {
     _service: { kind: true, test: TODO },
     _main: { kind: true, test: TODO },
     _artifact: { test: TODO },
-    _base: { test: TODO, kind: true },
     _navigation: { test: TODO },
     _effectiveType: { kind: true, test: TODO },
     _joinParent: { test: TODO },
@@ -548,6 +560,7 @@ function assertConsistency( model, stage ) {
         'where', 'columns', 'mixin', 'quantifier', 'offset',
         'orderBy', '$orderBy', 'groupBy', 'excludingDict', 'having',
         'limit', '_status',
+        '_extension', // for unapplied extensions
       ],
     },
     _leadingQuery: { kind: true, test: TODO },
@@ -581,20 +594,57 @@ function assertConsistency( model, stage ) {
     // (it can contain the artifact itself with no/failed autoexposure):
     _descendants: { kind: [ 'entity' ], test: isDictionary( isArray( TODO ) ) },
 
+    $errorReported: { parser: true, kind: true, test: isString },     // to avoid duplicate messages
     $duplicates: { parser: true, kind: true, test: TODO }, // array of arts or true
     $extension: { kind: true, test: TODO }, // TODO: introduce $applied instead or $status
-    $inferred: { parser: true, kind: true, test: isString },
+    $inferred: {
+      parser: true,
+      kind: true,
+      test: isOneOf([
+        // Uppercase values are used in logic, lowercase value are "just for us", i.e.
+        // debugging or to add non-enumerable properties such as $generated in Universal CSN.
+        // However, that is no longer true. For example, `autoexposed` is used in populate.js
+        // as well.
+        'IMPLICIT',
+        'REDIRECTED',
+
+        '$autoElement', // for magicVars: $user is automatically changed to $user.id
+        '$generated', // compiler generated annotations, e.g. @Core.Computed
+        '*', // inferred from query wildcard
+        'as', // query alias name
+        'aspect-composition',
+        'autoexposed', // for auto-exposed entities (they can't be referred to)
+        'cast', // type from cast() function
+        'composition-entity',
+        'copy', // only used in rewriteCondition(): On-condition is copied
+        'duplicate-autoexposed', // just like `autoexposed`, but with `duplicate` error.
+        'expand-element', // expanded elements
+        'expand-param',  // expanded params (difference to expand-element only for debugging)
+        'include', // through includes, e.g. `entity E : F {}`
+        'keys',
+        'localized', // e.g. compiler-generated elements for localized: `text` assoc, etc.
+        'localized-entity', // `.texts` entity
+        'nav', // only used for MASKED, TODO(v4): Remove
+        'none', // only used in ensureColumnName(): Used in object representing empty alias
+        'query', // inferred query properties, e.g. `key`
+        'rewrite', // on-conditions or FKeys are rewritten
+      ]),
+    },
 
     // Helper property for the XSN-to-CSN transformation, see function setExpandStatus():
     // client, universal: render expanded elements?  gensrc: produce annotate statements?
-    $expand: { kind: true, test: isString }, // TODO: rename it to $elementsExpand ?
+    // TODO: rename it to $elementsExpand ?
+    $expand: {
+      kind: true,
+      // See description of `setExpandStatus()` of in `lib/compiler/utils.js`.
+      test: isOneOf([ 'origin', 'annotate', 'target' ]),
+    },
 
     $autoexpose: { kind: [ 'entity' ], test: isBoolean, also: [ null, 'Composition' ] },
-    $a2j: { kind: true, enumerable: true, test: TODO },
     $extra: { parser: true, test: TODO },   // for unexpected properties in CSN
     $withLocalized: { test: isBoolean },
     $sources: { parser: true, test: isArray( isString ) },
-    $expected: { parser: true, test: isString },
+    $expected: { parser: true, test: isOneOf([ 'approved-exists', 'exists' ]) },
     $messageFunctions: { test: TODO },
     $functions: { test: TODO },
     $volatileFunctions: { test: TODO },
@@ -854,6 +904,13 @@ function assertConsistency( model, stage ) {
       isString(node, parent, prop, spec);
   }
 
+  function isOneOf(values) {
+    return function isOneOfInner( node, parent, prop ) {
+      if (!values.includes(node))
+        throw new Error( `Unexpected value '${ node }', expected ${ JSON.stringify(values) }${ at( [ node, parent ], prop ) }` );
+    };
+  }
+
   function isString( node, parent, prop, spec ) {
     if (typeof node !== 'string')
       throw new Error( `Expected string${ at( [ node, parent ], prop ) }` );

package/lib/compiler/base.js

@@ -16,16 +16,18 @@ const kindProperties = {
   namespace: { artifacts: true }, // on-the-fly context
   context: { artifacts: true, normalized: 'namespace' },
   service: { artifacts: true, normalized: 'namespace' },
-  entity: { elements: true, actions: true, params: () => false },
+  entity: {
+    elements: true, actions: true, params: () => false, include: true,
+  },
   select: { normalized: 'select', elements: true },
   $join: { normalized: 'select' },
   $tableAlias: { normalized: 'alias' }, // table alias in select
   $self: { normalized: 'alias' }, // table alias in select
   $navElement: { normalized: 'element' },
   $inline: { normalized: 'element' }, // column with inline property
-  event: { elements: true },
-  type: { elements: propExists, enum: propExists },
-  aspect: { elements: propExists },
+  event: { elements: true, include: true },
+  type: { elements: propExists, enum: propExists, include: true },
+  aspect: { elements: propExists, actions: true, include: true },
   annotation: { elements: propExists, enum: propExists },
   enum: { normalized: 'element' },
   element: { elements: propExists, enum: propExists, dict: 'elements' },

package/lib/compiler/builtins.js

@@ -1,7 +1,7 @@
 // The builtin artifacts of CDS
 
 // TODO: split this file
-// - in base/: common definitions
+// - in base/: common definitions, datetime formats
 // - in compiler/: XSN-specific
 // - in ?: CSN-specific
 
@@ -76,19 +76,94 @@ const functionsWithoutParens = [
   'CURRENT_USER', 'SESSION_USER', 'SYSTEM_USER',
 ];
 
-const specialFunctions = {
+const specialFunctions = compileFunctions( {
+  '': [                         // the default
+    {
+      intro: [ 'ALL', 'DISTINCT' ],
+      introMsg: [],             // do not list them in code completion
+    },
+    {},
+  ],
   ROUND: [
     null, null, {               // 3rd argument: rounding mode
-      ROUND_HALF_UP: 'argFull',
-      ROUND_HALF_DOWN: 'argFull',
-      ROUND_HALF_EVEN: 'argFull',
-      ROUND_UP: 'argFull',
-      ROUND_DOWN: 'argFull',
-      ROUND_CEILING: 'argFull',
-      ROUND_FLOOR: 'argFull',
+      expr: [ 'ROUND_HALF_UP', 'ROUND_HALF_DOWN', 'ROUND_HALF_EVEN',
+        'ROUND_UP', 'ROUND_DOWN', 'ROUND_CEILING', 'ROUND_FLOOR' ],
     },
   ],
-};
+  TRIM: [
+    {
+      intro: [ 'LEADING', 'TRAILING', 'BOTH' ],
+      expr: [ 'LEADING', 'TRAILING', 'BOTH' ],
+      separator: [ 'FROM' ],
+    },
+  ],
+  EXTRACT: [
+    {
+      expr: [ 'YEAR', 'MONTH', 'DAY', 'HOUR', 'MINUTE', 'SECOND' ],
+      separator: [ 'FROM' ],
+    },
+  ],
+  COUNT: [
+    {
+      expr: [ '*' ],
+      intro: [ 'ALL', 'DISTINCT' ],
+    },
+  ],
+  MIN: 'COUNT',
+  MAX: 'COUNT',
+  SUM: 'COUNT',
+  AVG: 'COUNT',
+  STDDDEV: 'COUNT',
+  VAR: 'COUNT',
+  LOCATE_REGEXPR: [
+    {
+      intro: [ 'START', 'AFTER' ],
+      separator: [ 'FLAG', 'IN', 'FROM', 'OCCURRENCE', 'GROUP' ],
+    },
+  ],
+  OCCURRENCES_REGEXPR: [
+    {
+      separator: [ 'FLAG', 'IN', 'FROM' ],
+    },
+  ],
+  REPLACE_REGEXPR: [
+    {
+      separator: [ 'FLAG', 'IN', 'WITH', 'FROM', 'OCCURRENCE' ],
+      expr: [ 'ALL' ],
+    },
+  ],
+  SUBSTRING_REGEXPR: [
+    {
+      separator: [ 'FLAG', 'IN', 'FROM', 'OCCURRENCE', 'GROUP' ],
+    },
+  ],
+} );
+
+function compileFunctions( special ) {
+  const compiled = {};
+  for (const [ name, val ] of Object.entries( special ))
+    compiled[name] = (typeof val === 'string' ? special[val] : val).map( compileArg );
+  return compiled;
+}
+
+function compileArg( src ) {
+  if (!src)
+    return src;
+  const tgt = {
+    intro: src.intro || [],
+    expr: src.expr || [],
+    separator: src.separator || [],
+  };
+  for (const generic of [ 'intro', 'expr', 'separator' ]) {
+    // intro before expr: if both intro and expr, tag as 'expr'
+    for (const token of src[generic] || [])
+      tgt[token] = generic;
+  }
+  // As GenericIntro is always together with GenericExpr, only mention those
+  // which are not already proposed for GenericExpr:
+  tgt.introMsg = src.introMsg || tgt.intro.filter( token => tgt[token] === 'intro' );
+  return tgt;
+}
 
 /**
  * Variables that have special meaning in CDL/CSN.
@@ -106,17 +181,106 @@ const magicVariables = {
     elements: {
       from: {}, to: {},
     },
+    // Require that elements are accessed, i.e. no $at, only $at.<element>.
+    $requireElementAccess: true,
   },
   $now: {}, // Dito
   $session: {
     // In ABAP CDS session variables are accessed in a generic way via
     // the pseudo variable $session.
     $uncheckedElements: true,
+    $requireElementAccess: true,
   },
 };
 
 // see lib/render/renderUtil.js for DB-specific magic vars, specified in CAP Cds via function
 
+/**
+ * Patterns for literal token tests and creation.  The value is a map from the
+ * `prefix` argument of function `quotedliteral` to the following properties:
+ *  - `test_msg`: error message which is issued if `test_fn` fails.
+ *  - `test_fn`: function called with argument `value`, fails falsy return value
+ *  - `unexpected_msg`: error message which is issued if `unexpected_char` matches
+ *  - `unexpected_char`: regular expression matching an illegal character in `value`,
+ *    the error location is only correct for a literal <prefix>'<value>'
+ *  - `literal`: the value which is used instead of `prefix` in the AST
+ * TODO: we might do a range check (consider leap seconds, i.e. max value 60),
+ *       but always allow Feb 29 (no leap year computation)
+ * Notes:
+ *  - Dates/Times as defined in ISO 8601, see <https://en.wikipedia.org/wiki/ISO_8601>
+ */
+const quotedLiteralPatterns = {
+  x: {
+    test_variant: 'uneven-hex',
+    test_fn: (str => Number.isInteger(str.length / 2)),
+    unexpected_variant: 'invalid-hex',
+    unexpected_char: /[^0-9a-f]/i,
+    json_type: 'string',
+  },
+  time: {
+    test_variant: 'time',
+    test_fn: (x) => {
+      // Leading `T` allowed in ISO 8601.
+      const match = x.match( /^T?(\d{1,2}):(\d{1,2})(?::(\d{1,2}))?$/ );
+      return match !== null && checkTime( match[1], match[2], match[3] );
+    },
+    json_type: 'string',
+  },
+  date: {
+    test_variant: 'date',
+    test_fn: (x) => {
+      const match = x.match( /^(-?\d{4})-(\d{1,2})-(\d{1,2})$/ );
+      return match !== null && checkDate( match[1], match[2], match[3] );
+    },
+    json_type: 'string',
+  },
+  timestamp: {
+    test_variant: 'timestamp',
+    test_fn: (x) => {
+      // eslint-disable-next-line max-len
+      const match = x.match( /^(-?\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2})(\.\d{1,7})?)?$/ );
+      return match !== null && checkDate( match[1], match[2], match[3] ) &&
+        checkTime( match[4], match[5], match[6] );
+    },
+    json_type: 'string',
+  },
+};
+
+/**
+ * Check that the given date is within boundaries.
+ * We can't use Date.parse() since that also allows non-standard values (2022-02-31 for example).
+ * Checks according to ISO 8601.
+ *
+ * @returns {boolean} True if the date is valid.
+ */
+function checkDate(year, month, day) {
+  // Negative years are allowed
+  year = Math.abs(Number.parseInt(year, 10));
+  month = Number.parseInt(month, 10);
+  day = Number.parseInt(day, 10);
+  // If any is NaN, the condition will be false.
+  // Year 0 does not exist, but ISO 8601 allows it and defines it as 1 BC.
+  return !Number.isNaN(year) && month > 0 && month < 13 && day > 0 && day < 32;
+}
+
+/**
+ * Check that the given time is within boundaries.
+ * Checks according to ISO 8601.
+ *
+ * @returns {boolean} True if the date is valid.
+ */
+function checkTime(hour, minutes, seconds) {
+  hour = Number.parseInt(hour, 10);
+  minutes = Number.parseInt(minutes, 10);
+  seconds = seconds ? Number.parseInt(seconds, 10) : 0;
+  if (hour === 24) // allow 24:00:00 (ISO 8601 version earlier than 2019)
+    return minutes === 0 && seconds === 0;
+  // If any is NaN, the condition will be false.
+  return hour >= 0 && hour < 24 &&
+    minutes >= 0 && minutes < 60 &&
+    seconds >= 0 && seconds < 61; // we allow 60 for lead seconds
+}
+
 /** All types belong to one category. */
 const typeCategories = {
   string: [],
@@ -286,6 +450,8 @@ function initBuiltins( model ) {
         art.$autoElement = magic.$autoElement;
       if (magic.$uncheckedElements)
         art.$uncheckedElements = magic.$uncheckedElements;
+      if (magic.$requireElementAccess)
+        art.$requireElementAccess = magic.$requireElementAccess;
 
       createMagicElements( art, magic.elements );
       if (options.variableReplacements)
@@ -325,6 +491,7 @@ module.exports = {
   typeParameters,
   functionsWithoutParens,
   specialFunctions,
+  quotedLiteralPatterns,
   initBuiltins,
   isInReservedNamespace,
   isBuiltinType,

package/lib/compiler/checks.js

@@ -414,7 +414,7 @@ function check( model ) {       // = XSN
     }
   }
 
-  // TODO: make this part of the the name resolution in the compiler
+  // TODO: make this part of the name resolution in the compiler
   // Check that queries in 'art' do not contain unmanaged associations in GROUP BY or ORDER BY
   function checkNoUnmanagedAssocsInGroupByOrderBy( query ) {
     const art = query._main;    // TODO - remove, use query for semantic location

package/lib/compiler/define.js

@@ -109,7 +109,7 @@
 
 'use strict';
 
-const { isDeprecatedEnabled, forEachGeneric, forEachInOrder } = require('../base/model');
+const { forEachGeneric, forEachInOrder } = require('../base/model');
 const {
   dictAdd, dictAddArray, dictForEach, pushToDict,
 } = require('../base/dictionaries');
@@ -147,6 +147,7 @@ function define( model ) {
   } = model.$messageFunctions;
   const {
     resolveUncheckedPath,
+    checkAnnotate,
     defineAnnotations,
   } = model.$functions;
 
@@ -197,11 +198,12 @@ function define( model ) {
   }
 
   // Phase 1: ----------------------------------------------------------------
+  // Functions called from top-level: addSource()
 
   /**
    * Add definitions of the given source AST, both CDL and CSN
    *
-   * @param {XSN.AST} src
+   * @param {XSN.SourceAst} src
    */
   function addSource( src ) {
     // handle sub model from parser
@@ -266,7 +268,7 @@ function define( model ) {
       return;
     }
     setLink( art, '_block', block );
-    // dictAdd might set $duplicates to true
+    // dictAdd might set $duplicates
     dictAdd( model.definitions, absolute, art );
   }
 
@@ -306,7 +308,7 @@ function define( model ) {
    * declaration.
    *
    * @param {XSN.Using} decl Node to be expanded and added to `src`
-   * @param {XSN.AST} src
+   * @param {XSN.SourceAst} src
    */
   function addUsing( decl, src ) {
     if (decl.usings) {
@@ -390,14 +392,17 @@ function define( model ) {
     setLink( vocab, '_block', block );
     const { name } = vocab;
     if (!name.absolute)
-      name.absolute = prefix + name.path.map( id => id.id ).join('.');
+      name.absolute = prefix + pathName( name.path );
     dictAdd( model.vocabularies, name.absolute, vocab );
   }
 
   // Phase 2 ("init") --------------------------------------------------------
+  // Functions called from top-level: initNamespaceAndUsing(), initArtifact(),
+  // initVocabulary()
 
   function checkRedefinition( art ) {
-    if (!art.$duplicates)
+    if (!art.$duplicates || art.$errorReported === 'syntax-duplicate-extend' ||
+        art.$errorReported === 'syntax-duplicate-annotate')
       return;
     if (art._main) {
       error( 'duplicate-definition', [ art.name.location, art ], {
@@ -504,18 +509,6 @@ function define( model ) {
       definitions[prefix] = parent;
       initParentLink( parent, definitions );
     }
-    if (art.kind !== 'namespace' &&
-        isDeprecatedEnabled( options, 'generatedEntityNameWithUnderscore' )) {
-      let p = parent;
-      while (p && kindProperties[p.kind].artifacts)
-        p = p._parent;
-      if (p) {
-        error( 'subartifacts-not-supported', [ art.name.location, art ],
-               { art: p, prop: 'deprecated.generatedEntityNameWithUnderscore' },
-               // eslint-disable-next-line max-len
-               'With the option $(PROP), no sub artifact can be defined for a non-context/service $(ART)' );
-      }
-    }
     setLink( art, '_parent', parent );
     if (!parent._subArtifacts)
       setLink( parent, '_subArtifacts', Object.create(null) );
@@ -611,7 +604,17 @@ 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 ); // TODO: complain with inline
+        defineAnnotations( col, col, parent._block );
+        if (col.inline) { // `@anno elem.{ * }` does not work
+          if (col.doc)
+            warning( 'syntax-anno-ignored', [ col.doc.location, col ], { '#': 'doc' } );
+
+          // col.$annotations no available for CSN input, have to search.
+          // Warning about first annotation should be enough to avoid spam.
+          const firstAnno = Object.keys(col).find(key => key.startsWith('@'));
+          if (firstAnno)
+            warning( 'syntax-anno-ignored', [ col[firstAnno].name.location, col ] );
+        }
         // TODO: allow sub queries? at least in top-level expand without parallel ref
         if (columns)
           initExprForQuery( col.value, parent );
@@ -670,6 +673,8 @@ function define( model ) {
    * @param {object} exprOrPathElement starts w/ an expr but then subelem from .path or .where.args
    */
   function approveExistsInChildren(exprOrPathElement) {
+    if (!exprOrPathElement) // may be null in case of parse error
+      return;
     if (exprOrPathElement.$expected === 'exists')
       exprOrPathElement.$expected = 'approved-exists';
     // Drill down
@@ -880,9 +885,7 @@ function define( model ) {
 
   /**
    * Set property `_parent` for all elements in `parent` to `parent` and do so
-   * recursively for all sub elements.  Also set the property
-   * `name.component` of the element with the help of argument `prefix`
-   * (which is basically the component name of the `parent` element plus a dot).
+   * recursively for all sub elements.
    */
   // If not for extensions: construct === parent
   function initMembers( construct, parent, block, initExtensions = false ) {
@@ -1014,6 +1017,8 @@ function define( model ) {
       setMemberParent( elem, name, parent, construct !== parent && prop );
       // console.log(message( null, elem.location, elem, {}, 'Info', 'INIT').toString())
       checkRedefinition( elem );
+      if (elem.kind === 'annotate')
+        checkAnnotate( elem, elem );
       defineAnnotations( elem, elem, bl );
       initMembers( elem, elem, bl, initExtensions );
 
@@ -1125,7 +1130,7 @@ function mergeI18nBlocks( model ) {
    * Add the source's translations to the model. Warns if the sources translations
    * do not match the ones from previous sources.
    *
-   * @param {XSN.AST} src
+   * @param {XSN.SourceAst} src
    */
   function initI18nFromSource( src ) {
     for (const langKey of Object.keys( src.i18n )) {