@sap/cds-compiler 5.3.2 → 5.4.2

package/CHANGELOG.md

@@ -7,6 +7,33 @@
 Note: `beta` fixes, changes and features are usually not listed in this ChangeLog but [here](doc/CHANGELOG_BETA.md).
 The compiler behavior concerning `beta` features can change at any time without notice.
 
+## Version 5.4.2 - 2024-11-06
+
+### Fixed
+
+- to.sql: For SQLite, map `cds.Map` to `JSON_TEXT` to ensure text affinity.
+
+## Version 5.4.0 - 2024-10-24
+
+### Added
+
+- to.edm(x): `cds.Map` as empty open complex type with name `cds_Map` or if the definition
+  has been assigned `@open: false` as empty open complex type `cds_Map_closed` in OData V4.
+
+### Changed
+
+- Update OData vocabularies: 'Capabilities', 'Common', 'Core', 'PersonalData', 'PDF', 'UI'.
+- to.cdl: Identifiers using non-ASCII unicode characters, as introduced in v4.4.0, are no longer quoted.
+- For propagated expressions as annotation values, the `=` is changed as well, if it is a simple identifier.
+
+### Fixed
+
+- compiler: Some invalid CDL snippets could crash the parser and compiler.
+- to.edm(x): OData V2: `Core.Links` watermark annotation has a `xmlns` attribute now.
+- for.seal: Remove unapplied extensions from CSN.
+- to.sql.migration: Handle `ALTER COLUMN` for columns with `NOT NULL` and a default value.
+
+
 ## Version 5.3.2 - 2024-10-08
 
 ### Fixed
@@ -19,8 +46,8 @@ The compiler behavior concerning `beta` features can change at any time without
 ### Added
 
 - compiler:
-  - A warning is emitted if a string enum's values are longer than the specified length.
-  - ON-condition rewriting has been improved and now supports secondary associations.
+  + A warning is emitted if a string enum's values are longer than the specified length.
+  + ON-condition rewriting has been improved and now supports secondary associations.
 - to.edm(x): Support optional action and function parameters in OData V4. The following rules apply:
   + A parameter declared `not null` without default value is mandatory.
   + A **function** parameter declared `null` without default value is mandatory.

package/bin/cdsc.js

@@ -370,7 +370,7 @@ async function executeCommandLine( command, options, args ) {
   }
 
   function forSeal( model ) {
-    const features = [ 'remapOdataAnnotations' ];
+    const features = [ 'remapOdataAnnotations', 'deriveAnalyticalAnnotations' ];
     for (const feature of features) {
       if (options[feature]) // map to boolean equivalent
         options[feature] = options[feature] === 'true';

package/doc/CHANGELOG_BETA.md

@@ -305,9 +305,9 @@ This is now the default - see CHANGELOG entry for 2.6.0
 - `toSql`/`toHdbcds`: omit constraint generation if the option `skipDbConstraints` is set
 - If the database constraints are switched off by the global option,
   render constraints nevertheless if an association / composition
-  is annotated with `@cds.persistency.assert.integrity: true`
+  is annotated with `@cds.persistence.assert.integrity: true`
 - omit constraint generation if an association / composition
-  is annotated with `@cds.persistency.assert.integrity: false`
+  is annotated with `@cds.persistence.assert.integrity: false`
   -> for managed compositions, the `up_` link in the compositions target entity
   will not result in a constraint if the composition is annotated as described
 

package/lib/api/options.js

@@ -54,6 +54,8 @@ const publicOptionsNewAPI = [
   'resolveProjections',
   'remapOdataAnnotations',
   'keepLocalized',
+  // for.seal
+  'deriveAnalyticalAnnotations',
   // to.sql.migration
   'script',
 ];
@@ -210,7 +212,7 @@ module.exports = {
       return translateOptions(options, defaultOptions, hardOptions, undefined, undefined, 'for.hana');
     },
     effective: (options) => {
-      const hardOptions = { addCdsPersistenceName: false };
+      const hardOptions = { addCdsPersistenceName: false, deriveAnalyticalAnnotations: false };
       const defaultOptions = {
         sqlMapping: 'plain', resolveSimpleTypes: true, resolveProjections: true, remapOdataAnnotations: false, keepLocalized: false,
       };
@@ -222,7 +224,7 @@ module.exports = {
       const hardOptions = {
         sqlMapping: 'plain', resolveSimpleTypes: true, resolveProjections: true, keepLocalized: false, addCdsPersistenceName: true,
       };
-      const defaultOptions = { remapOdataAnnotations: true };
+      const defaultOptions = { remapOdataAnnotations: true, deriveAnalyticalAnnotations: false };
       const processed = translateOptions(options, defaultOptions, hardOptions, null, [ 'sql-dialect-and-naming' ], 'for.effective');
 
       return Object.assign({}, processed);

package/lib/base/builtins.js

@@ -90,15 +90,6 @@ const xprInAnnoProperties = [
   'cast',
 ];
 
-/**
- * Functions without parentheses in CDL (common standard SQL-92 functions)
- * (do not add more - make it part of the SQL renderer to remove parentheses for
- * other funny SQL functions like CURRENT_UTCTIMESTAMP).
- */
-const functionsWithoutParens = [
-  'CURRENT_DATE', 'CURRENT_TIME', 'CURRENT_TIMESTAMP',
-  'CURRENT_USER', 'SESSION_USER', 'SYSTEM_USER',
-];
 
 /**
  * Return whether JSON object `val` is a representation for an annotation expression
@@ -110,7 +101,6 @@ function isAnnotationExpression( val ) {
 module.exports = {
   propagationRules,
   xprInAnnoProperties,
-  functionsWithoutParens,
   isInReservedNamespace,
   isBuiltinType,
   isMagicVariable,

package/lib/base/keywords.js

@@ -1,40 +1,12 @@
 'use strict';
 
-const { functionsWithoutParens } = require('./builtins');
+const { functionsWithoutParentheses, cdlKeywords } = require('../parsers/identifiers');
 
 module.exports = {
-  // CDL reserved keywords, used for automatic quoting in 'toCdl' renderer
-  // Keep in sync with reserved keywords in language.g4
-  cdl: [
-    'ALL',
-    'ANY',
-    'AS',
-    'BY',
-    'CASE',
-    'CAST',
-    'DISTINCT',
-    'EXISTS',
-    'EXTRACT',
-    'FALSE', // boolean
-    'FROM',
-    'IN',
-    'KEY',
-    'NEW',
-    'NOT',
-    'NULL',
-    'OF',
-    'ON',
-    'SELECT',
-    'SOME',
-    'TRIM',
-    'TRUE', // boolean
-    'WHEN',
-    'WHERE',
-    'WITH',
-  ],
+  cdl: cdlKeywords,
   // CDL functions, used for automatic quoting in 'toCdl' renderer,
   // only relevant for element references of path length 1.
-  cdl_functions: functionsWithoutParens,
+  cdl_functions: functionsWithoutParentheses,
   // SQLite keywords, used to warn in 'toSql' renderer with dialect 'sqlite'
   // Taken from http://www.sqlite.org/draft/lang_keywords.html
   // Better use keywords in tool/mkkeywordhash.c of a sqlite distribution.

package/lib/base/message-registry.js

@@ -533,6 +533,13 @@ const centralMessageTexts = {
     annotation: 'Annotation definitions can\'t have calculated elements',
     param: 'Parameters can\'t have calculated elements',
   },
+  'def-invalid-name': {
+    std: 'The character \'.\' is not allowed in identifiers',
+    element: 'The character \'.\' is not allowed in element names',
+    param: 'The character \'.\' is not allowed in parameter names',
+    action: 'The character \'.\' is not allowed in bound action names',
+    function: 'The character \'.\' is not allowed in bound function names',
+  },
   'ref-invalid-calc-elem': {
     std: 'Can\'t include artifact with calculated element',
     event: 'An event can\'t include an artifact with calculated elements',
@@ -579,6 +586,11 @@ const centralMessageTexts = {
     exists: 'With $(NAME), path steps must not start with $(ID)',
     'exists-filter': 'Unexpected $(ID) reference in filter of path $(ELEMREF) following “EXISTS” predicate',
   },
+  'ref-unexpected-map': {
+    std: 'Unexpected reference to an element of type $(TYPE)', // unused
+    keys: 'Unexpected reference to an element of type $(TYPE) in foreign keys',
+    onCond: 'Unexpected reference to an element of type $(TYPE) in an ON-condition',
+  },
   'ref-undefined-def': {
     std: 'Artifact $(ART) has not been found',
     // TODO: proposal 'No definition of $(NAME) found',
@@ -695,9 +707,10 @@ const centralMessageTexts = {
   },
   'ref-unsupported-type': {
     std: 'Type $(TYPE) is not supported',
+    dialect: 'Type $(TYPE) is not supported for SQL dialect $(VALUE)',
     hana: 'Type $(TYPE) is only supported for SQL dialect $(VALUE), not $(OTHERVALUE)',
     hdbcds:'Type $(TYPE) is not supported in HDBCDS',
-    odata: 'Type $(TYPE) is not supported for OData'
+    odata: 'Type $(TYPE) is not supported for OData $(VERSION)'
   },
   'ref-unexpected-var': {
     std: 'Variable $(NAME) can\'t be used here',
@@ -759,9 +772,10 @@ const centralMessageTexts = {
   'type-unexpected-default': {
     std: 'Unexpected $(KEYWORD) on an association/composition', // unused
     multi: 'Unexpected $(KEYWORD); expected exactly one foreign key in combination with default value, but found $(COUNT)',
-    structured: 'Unexpected $(KEYWORD) in combination with structured foreign key $(NAME); $(KEYWORD) requires a non-structured foreign key',
+    structuredKey: 'Unexpected $(KEYWORD) in combination with structured foreign key $(NAME); $(KEYWORD) requires a non-structured foreign key',
     'onCond': 'Unexpected $(KEYWORD) on an association/composition with ON-condition; $(KEYWORD) requires exactly one foreign key',
-    'targetAspect': 'Unexpected $(KEYWORD) on composition of aspect'
+    'targetAspect': 'Unexpected $(KEYWORD) on composition of aspect',
+    map: 'Unexpected $(KEYWORD) for type $(TYPE)',
   },
   'type-expecting-service-target': {
     std: 'Expecting service entity $(TARGET)',
@@ -823,6 +837,7 @@ const centralMessageTexts = {
     virtual: 'Unexpected $(PROP) for virtual element',
     // TODO: Better message?
     include: '$(ART) can\'t have additional keys (through include)',
+    invalidType: 'Unexpected $(PROP) for element of type $(TYPE)',
   },
   'def-unexpected-localized': {
     std: '$(ART) can\'t have localized elements',
@@ -890,7 +905,10 @@ const centralMessageTexts = {
   },
 
   'ref-expecting-$self': 'Use $(NEWCODE) instead of $(CODE) here or remove $(CODE) altogether if possible; the compiler has rewritten it to $(NEWCODE) in CSN',
-  'ref-expecting-assoc': 'Expecting path $(ELEMREF) following “EXISTS” predicate to end with association/composition, found $(TYPE)',
+  'ref-expecting-assoc': {
+    std: 'Expecting path $(ELEMREF) following “EXISTS” predicate to end with association/composition',
+    'with-type': 'Expecting path $(ELEMREF) following “EXISTS” predicate to end with association/composition, found $(TYPE)',
+  },
   'ref-expecting-const': 'A constant expression or variable is expected here',
   'ref-expecting-foreign-key': 'Expecting foreign key access after managed association $(NAME) in filter expression of $(ID), but found $(ALIAS)',
   'ref-invalid-target': {
@@ -1038,7 +1056,7 @@ const centralMessageTexts = {
   },
 
   'type-invalid-cast': {
-    std: 'Invalid cast to $(TYPE)', // unused
+    std: 'Can\'t cast to $(TYPE)',
     'to-structure': 'Can\'t cast to a structured type',
     'from-structure':  'Structured elements can\'t be cast to a different type',
     'expr-to-structure': 'Can\'t cast an expression to a structured type',

package/lib/base/messages.js

@@ -1486,7 +1486,7 @@ function homeName( art, absoluteOnly ) {
     return homeName( art.name._artifact, absoluteOnly ); // use corresponding definition
   let main = art._main || art;
   while (main._outer)           // anonymous aspect
-    main = main._outer._main;
+    main = main._outer._main || main._outer; // w/o `_main` if wrongly in `type`
   return (absoluteOnly) ? main.name.id : `${ main.kind }:${ artName( art ) }`;
 }
 

package/lib/checks/existsMustEndInAssoc.js

@@ -14,8 +14,13 @@ function existsMustEndInAssoc( parent, prop, expression, path ) {
       const next = expression[i + 1];
       const { _art } = next;
       const errorPath = path.concat([ prop, i ]);
-      if (!next.SELECT && !_art?.target)
-        this.error('ref-expecting-assoc', errorPath, { elemref: next, type: _art.type });
+      if (!next.SELECT && !_art?.target) {
+        this.error('ref-expecting-assoc', errorPath, {
+          '#': _art.type ? 'with-type' : 'std',
+          elemref: next,
+          type: _art.type,
+        });
+      }
     }
   }
 }

package/lib/checks/foreignKeys.js

@@ -51,13 +51,18 @@ function validateForeignKeys( member, memberName ) {
       handleStructured(mem);
     }
     else if (mem.type) {
-      const type = mem.type.ref
-        ? this.artifactRef(mem.type)
-        : this.csn.definitions[mem.type];
-      if (type && !type.$visited) {
-        setProp(type, '$visited', true);
-        checkForItemsOrMissingType(type, memName);
-        delete type.$visited;
+      if (mem.type === 'cds.Map') {
+        this.error(null, member.$path, { type: mem.type }, 'Unexpected type $(TYPE) in foreign key');
+      }
+      else {
+        const type = mem.type.ref
+          ? this.artifactRef(mem.type)
+          : this.csn.definitions[mem.type];
+        if (type && !type.$visited) {
+          setProp(type, '$visited', true);
+          checkForItemsOrMissingType(type, memName);
+          delete type.$visited;
+        }
       }
     }
     else if (mem && !mem.type && this.options.transformation !== 'odata') {

package/lib/compiler/assert-consistency.js

@@ -530,6 +530,8 @@ function assertConsistency( model, stage ) {
         // CSN parser may let these properties slip through to XSN, even if input is invalid.
         'args', 'op', 'func', 'suffix',
         '$invalidPaths', '$parens',
+        // for invalid CDL (parser issues)
+        'orderBy',
       ],
       // TODO: name requires if not in parser?
     },
@@ -857,9 +859,11 @@ function assertConsistency( model, stage ) {
       isObject( node, parent, prop, spec, idx );
 
       // eslint-disable-next-line no-nested-ternary
-      const choice = (node.from !== undefined || node.columns)
-        ? 'select'
-        : (node.op) ? 'union' : 'none'; // from: null from parse error
+      const choice = (!noSyntaxErrors())
+        ? 'none'
+        : (node.from !== undefined)
+          ? 'select'
+          : 'union';
       if (spec[choice])
         assertProp( node, parent, prop, spec[choice], choice );
       else
@@ -921,6 +925,10 @@ function assertConsistency( model, stage ) {
   }
 
   function expressionSpec( node ) {
+    // When a condition failure is ignored (TODO: we might test specifically
+    // against this), an expression could have properties for query clauses:
+    if (!noSyntaxErrors())
+      return 'none';
     if (node.path)
       return 'ref';
     else if (node.literal || node.val)

package/lib/compiler/builtins.js

@@ -33,6 +33,7 @@ const core = {
   Boolean: { category: 'boolean' },
   UUID: { category: 'string' },
   Vector: { parameters: [ 'length' /* , 'type' */ ], category: 'vector' },
+  Map: { category: 'map' },
   Association: { internal: true, category: 'relation' },
   Composition: { internal: true, category: 'relation' },
 };
@@ -336,6 +337,7 @@ const typeCategories = {
   relation: [],
   geo: [],
   vector: [],
+  map: [],
 };
 // Fill type categories with `cds.*` types
 Object.keys( core ).forEach( (type) => {

package/lib/compiler/checks.js

@@ -17,7 +17,6 @@ const {
   forEachMemberRecursively,
   isDeprecatedEnabled,
 } = require('../base/model');
-const { CompilerAssertion } = require('../base/error');
 const { typeParameters } = require('./builtins');
 const { propagationRules } = require('../base/builtins');
 
@@ -88,6 +87,7 @@ function check( model ) {
 
     checkTypeStructure( art );
     checkAssociation( art ); // type def could be assoc
+    checkDefaultValue( art );
     if (art.kind === 'enum')
       checkEnum( art );
     checkEnumType( art );
@@ -108,22 +108,29 @@ function check( model ) {
     forEachMember( member, m => checkMember( m, parentProps ) );
   }
 
-  function checkVirtualKey( elem, parentProps ) {
-    const isKey = parentProps.key?.val || elem.key?.val;
+  function checkKey( elem, parentProps ) {
+    const key = parentProps.key || elem.key;
+    if (!key?.val || key?.$inferred)
+      return;
+
     const isVirtual = parentProps.virtual?.val || elem.virtual?.val;
-    if (isKey && isVirtual) {
+    if (isVirtual) {
       error( 'def-unexpected-key', [ (parentProps.key || elem.key).location, elem ],
              { '#': 'virtual', prop: 'key' } );
     }
+    else if (elem._effectiveType?.name?.id === 'cds.Map') {
+      error( 'def-unexpected-key', [ elem.type?.location || elem.location, elem ],
+             { '#': 'invalidType', prop: 'key', type: 'cds.Map' } );
+    }
   }
 
   function checkElement( elem, parentProps ) {
     checkLocalizedSubElement( elem );
-    checkVirtualKey( elem, parentProps );
+    checkKey( elem, parentProps );
     checkLocalizedElement( elem );
 
     if (elem.value) {
-      if (elem._main.query)
+      if (elem._main?.query)
         checkSelectItemValue( elem );
       else if (elem.$syntax === 'calc')
         checkCalculatedElementValue( elem );
@@ -141,8 +148,8 @@ function check( model ) {
     //       Maybe remove the check? But consider runtimes that rely on '.' as element separator.
     if (construct.kind === 'element' || construct.kind === 'action' || construct.kind === 'param') {
       if (construct.name.id?.includes( '.' )) {
-        error( null, [ construct.name.location, construct ], {},
-               'The character \'.\' is not allowed in identifiers' );
+        error( 'def-invalid-name', [ construct.name.location, construct ],
+               { '#': construct.kind || 'std' } );
       }
     }
   }
@@ -238,13 +245,15 @@ function check( model ) {
   function checkTypeCast( xpr, user ) {
     const isCast = (xpr.op?.val === 'cast');
     const elem = isCast
-      ? xpr.args[0]?._artifact
+      ? xpr.args?.[0]?._artifact
       : xpr._artifact;
     const type = isCast ? xpr.type : user.type;
     if (!isCast && type.$inferred)
       return; // e.g. $inferred:'generated'
     if (elem && type) { // has explicit type
-      if (type._artifact?.elements)
+      if (type._artifact?._effectiveType?.name.id === 'cds.Map')
+        error( 'type-invalid-cast', [ type.location, user ], { '#': 'std', type: 'cds.Map' } );
+      else if (type._artifact?.elements)
         error( 'type-invalid-cast', [ type.location, user ], { '#': 'to-structure' } );
       else if (elem.elements) // TODO: calc elements
         error( 'type-invalid-cast', [ type.location, user ], { '#': 'from-structure' } );
@@ -259,8 +268,14 @@ function check( model ) {
   function checkLocalizedElement( elem ) {
     if (elem.localized?.val) {
       const type = elem._effectiveType;
-      // See discussion issue #6520: should we allow all scalar types?
-      if (!type || !type.builtin || type.category !== 'string') {
+      // TODO(v6): Also for ` || type?.elements`; (#13154)
+      if (type?.category === 'map') {
+        error( 'ref-unexpected-localized-map', [ elem.type?.location, elem ],
+               { keyword: 'localized' },
+               'Map types can\'t be used with $(KEYWORD)' );
+      }
+      else if (!type || !type.builtin || type.category !== 'string') {
+        // See discussion issue #6520: should we allow all scalar types?
         info( 'ref-expecting-localized-string', [ elem.type?.location, elem ],
               { keyword: 'localized' },
               'Expecting a string type in combination with keyword $(KEYWORD)' );
@@ -344,12 +359,22 @@ function check( model ) {
     if (!type || type.enum)
       return;
 
-    // All builtin types are allowed except binary and relational types.
+    // All builtin types are allowed except binary, structured (Map), and relational types.
     // The latter are "internal" types.
-    if (!type.builtin || type.internal || type.category === 'binary') {
+    // Structures/Arrays are not allowed.
+    // TODO(v6): Reverse coding: use allow-list approach; don't forget about geo, etc.
+    const invalidEnumBuiltins = {
+      __proto__: null,
+      structure: 'struct',
+      binary: 'binary',
+      relation: 'relation',
+      vector: 'vector',
+      map: 'map',
+    };
+    if (!type.builtin || type.internal || type.category in invalidEnumBuiltins) {
       let typeClass = 'std';
-      if (type.category === 'binary' || type.category === 'relation')
-        typeClass = type.category;
+      if (type.category in invalidEnumBuiltins)
+        typeClass = invalidEnumBuiltins[type.category];
       else if (type.elements)
         typeClass = 'struct';
       else if (type.items)
@@ -360,7 +385,9 @@ function check( model ) {
         binary: 'Binary types are not allowed as enums',
         relation: 'Relational types are not allowed as enums',
         struct: 'Structured types are not allowed as enums',
+        vector: 'Vector types are not allowed as enums',
         items: 'Arrayed types are not allowed as enums',
+        map: 'Map types are not allowed as enums',
       } );
       return;
     }
@@ -470,12 +497,14 @@ function check( model ) {
     const isLocalizedSubElement = element.localized?.val;
     if (isLocalizedSubElement || element.type?._artifact?.localized?.val) {
       const loc = isLocalizedSubElement ? element.localized.location : element.type.location;
-      warning( 'localized-sub-element', [ loc, element ],
-               { type: element.type, '#': isLocalizedSubElement ? 'std' : 'type' },
-               {
-                 std: 'Keyword "localized" is ignored for sub elements',
-                 type: 'Keyword "localized" in type $(TYPE) is ignored for sub elements',
-               } );
+      warning( 'localized-sub-element', [ loc, element ], {
+        type: element.type?._artifact || '',
+        '#': isLocalizedSubElement ? 'std' : 'type',
+        keyword: 'localized',
+      }, {
+        std: 'Keyword $(KEYWORD) is ignored for sub elements',
+        type: 'Keyword $(KEYWORD) in type $(TYPE) is ignored for sub elements',
+      } );
     }
   }
 
@@ -524,11 +553,14 @@ function check( model ) {
     if (elem.foreignKeys) {
       for (const k in elem.foreignKeys) {
         ++fkCount;
+        // Note: If the foreign key is structured, we don't check its elements!
         const key = elem.foreignKeys[k].targetElement;
         if (key && isVirtualElement( key._artifact ))
           error( 'ref-unexpected-virtual', [ key.location, elem ], { '#': 'fkey' } );
         else if (key._artifact?.$syntax === 'calc' && !key._artifact.value.stored?.val)
           error( 'ref-unexpected-calculated', [ key.location, elem ], { '#': 'fkey' } );
+        else if (key._artifact?._effectiveType?.name.id === 'cds.Map')
+          error( 'ref-unexpected-map', [ key.location, elem ], { '#': 'keys', type: 'cds.Map' } );
       }
     }
     if (elem.default?.val !== undefined) {
@@ -542,7 +574,7 @@ function check( model ) {
         const fkName = Object.keys( elem.foreignKeys )[0];
         if (elem.foreignKeys[fkName].targetElement._artifact?._effectiveType?.elements) {
           error( 'type-unexpected-default', [ elem.default.location, elem ], {
-            '#': 'structured', keyword: 'default', name: fkName,
+            '#': 'structuredKey', keyword: 'default', name: fkName,
           } );
         }
       }
@@ -551,6 +583,20 @@ function check( model ) {
     checkOnCondition( elem );
   }
 
+  function checkDefaultValue( art ) {
+    if (!art.default || !art._effectiveType)
+      return;
+    // TODO(v6): Also reject default for structures (#13154)
+    const isStructured = art._effectiveType?.name.id === 'cds.Map';
+    if (!isStructured)
+      return;
+    if (art.default?.val !== undefined) {
+      error( 'type-unexpected-default', [ art.default.location, art ], {
+        '#': 'map', keyword: 'default', type: 'cds.Map',
+      } );
+    }
+  }
+
   function getBinaryOp( cond ) {
     const { op, args } = cond;
     return op?.val === 'ixpr' && args?.length === 3 && args[1].literal === 'token' &&
@@ -579,6 +625,7 @@ function check( model ) {
                  'Used type $(TYPE) is not arrayed and conflicts with $(PROP) property' );
       }
       else if (artifact.elements && !finalType.elements) {
+        // TODO: Handle cds.Map!
         warning( 'type-elements-mismatch', [ artifact.type.location, artifact ],
                  { type: artifact.type, prop: 'elements' },
                  'Used type $(TYPE) is not structured and conflicts with $(PROP) property' );
@@ -686,18 +733,22 @@ function check( model ) {
   function checkOnCondition( elem ) {
     if (elem.$inferred === 'localized')
       return; // ignore
+    if (!elem.on || elem.on.$inferred)
+      return;
 
-    // TODO: Move to checkAssociation
-    if (elem.on && !elem.on.$inferred) {
-      visitExpression( elem.on, elem, (xpr, user) => {
-        checkExpressionNotVirtual( xpr, user );
-        checkExpressionAssociationUsage( xpr, user, true );
+    visitExpression( elem.on, elem, (xpr, user) => {
+      checkExpressionNotVirtual( xpr, user );
+      checkExpressionAssociationUsage( xpr, user, true );
+
+      if (xpr._artifact?._effectiveType?.name.id === 'cds.Map') {
+        error( 'ref-unexpected-map', [ xpr.location, user ], { '#': 'onCond', type: 'cds.Map' } );
+      }
+      else if (xpr._artifact?.$syntax === 'calc' && !xpr._artifact.value.stored?.val) {
         // Essential check. Dependency handling for `on` conditions must change if
         // this is allowed.  See test3/Associations/Dependencies/.
-        if (xpr._artifact?.$syntax === 'calc' && !xpr._artifact.value.stored?.val)
-          error( 'ref-unexpected-calculated', [ xpr.location, user ], { '#': 'on' } );
-      } );
-    }
+        error('ref-unexpected-calculated', [ xpr.location, user ], { '#': 'on' });
+      }
+    } );
   }
 
   function checkSelectItemValue( elem ) {
@@ -969,13 +1020,11 @@ function check( model ) {
       return;
     }
 
-    // Sanity checks
     if (!elementDecl._effectiveType)
-      throw new CompilerAssertion(`Expecting annotation declaration to have _finalType: ${ JSON.stringify( annoDecl ) }`);
-
+      return; // type resolution error
 
     // Must have literal or path unless it is a boolean
-    if (!anno.literal && !anno.path && elementDecl._effectiveType?.category !== 'boolean') {
+    if (!anno.literal && !anno.path && elementDecl._effectiveType.category !== 'boolean') {
       if (elementDecl.type?._artifact) {
         warning( 'anno-expecting-value', [ anno.location || anno.name.location, art, anno ],
                  { '#': 'type', type: elementDecl.type._artifact } );
@@ -1089,7 +1138,8 @@ function check( model ) {
       // TODO: complain at definition instead
     }
     else if (!type.enum) {
-      throw new CompilerAssertion(`Unknown primitive type name: ${ type.name.id }`);
+      // type error somewhere; ignore
+      return;
     }
 
     // Check enums
@@ -1167,7 +1217,7 @@ function checkSapCommonTextsAspects( model ) {
     if (locale._effectiveType !== model.definitions['cds.String']) {
       const hasCommonLocale = !!model.definitions['sap.common.Locale'];
       const { error } = model.$messageFunctions;
-      error( 'def-invalid-element-type', [ locale.type.location, locale ], {
+      error( 'def-invalid-element-type', [ (locale.type || locale.name).location, locale ], {
         '#': hasCommonLocale ? 'texts-aspect-locale' : 'std',
         art: name,
         elemref: 'locale',

package/lib/compiler/define.js

@@ -343,8 +343,8 @@ function define( model ) {
       decl.usings.forEach( u => addUsing( u, src ) );
       return;
     }
-    const { path } = decl.extern;
-    if (path.broken || !path[0]) // syntax error
+    const path = decl.extern?.path;
+    if (!path || path.broken || !path[0]) // syntax error
       return;
     decl.extern.id = pathName( path );
     if (!decl.name)