@sap/cds-compiler 4.0.2 → 4.2.2

package/lib/compiler/classes.js

@@ -0,0 +1,62 @@
+// Base classes used as prototypes for XSN definitions, elements, etc.
+// The goal is to have named classes that can be seen in performance analyses, e.g.
+// by using the [DeOpt Explorer][1].
+// All classes should also be constructible using `{ __proto__: Class, …}`, i.e.
+// their constructors must not do anything besides assigning properties.
+//
+// Refer to these resources:
+// - <https://mathiasbynens.be/notes/shapes-ics>
+// - <https://v8.dev/blog/fast-properties>
+//
+// Before adding new properties, evaluate whether it has any performance
+// impact.  Too many properties that are rarely used could reduce performance,
+// but too few could lead to inconsistent object shapes for commonly
+// used properties.
+//
+// Use [DeOpt Explorer][1] to see the different object Maps by v8.
+//
+// [1]: https://devblogs.microsoft.com/typescript/introducing-deopt-explorer/
+
+'use strict';
+
+class XsnSource {
+  kind = 'source';
+  location;
+  usings = [];
+  dependencies = [];
+  artifacts = Object.create( null );
+  vocabularies = Object.create( null );
+  extensions = [];
+}
+
+class XsnArtifact {
+  location;
+  name;
+  kind;
+}
+
+class XsnName {
+  location;
+}
+
+class CsnLocation {
+  file;
+  line;
+  col;
+  endLine;
+  endCol;
+  constructor(file, line, col, endLine, endCol) {
+    this.file = file;
+    this.line = line;
+    this.col = col;
+    this.endLine = endLine;
+    this.endCol = endCol;
+  }
+}
+
+module.exports = {
+  XsnSource,
+  XsnArtifact,
+  XsnName,
+  CsnLocation,
+};

package/lib/compiler/cycle-detector.js

@@ -30,15 +30,15 @@ function detectCycles( definitions, reportCycle, cbScc ) {
 
   for (const name in definitions) {
     const a = definitions[name];
-    if (Array.isArray(a))
+    if (Array.isArray( a ))
       a.forEach( strongConnectRec );
     else
       strongConnectRec( a );
   }
   // now the cleanup
-  let nodes = Object.getOwnPropertyNames(definitions).map( n => definitions[n] );
+  let nodes = Object.getOwnPropertyNames( definitions ).map( n => definitions[n] );
   while (nodes.length) {        // still nodes to cleaned
-    nodes = cleanup(nodes);
+    nodes = cleanup( nodes );
   }
   return;
 
@@ -46,7 +46,7 @@ function detectCycles( definitions, reportCycle, cbScc ) {
     if (a._scc)                 // already processed
       return;
     while (a)
-      a = strongConnect(a);
+      a = strongConnect( a );
   }
 
   // Try to build a SCC starting from the node `v`.
@@ -60,18 +60,18 @@ function detectCycles( definitions, reportCycle, cbScc ) {
         onStack: true,
         depIndex: 0,
       } );
-      stack.push(v);
+      stack.push( v );
       // console.log('PUSH: ', v.kind,v.name)
     }
     if (!v._deps)               // builtins, otherwise forgotten (TODO: assert in --test-mode)
-      setProp(v, '_deps', []);
+      setProp( v, '_deps', [] );
     // assert( v._scc.onStack );
 
     // Now consider successors of v (called w):
     while (v._scc.depIndex < v._deps.length) {
       const w = v._deps[v._scc.depIndex++].art;
       if (!w._scc) {            // node has not yet been visited
-        setProp(w, '_sccCaller', v);
+        setProp( w, '_sccCaller', v );
         // console.log('CALL: ', v._scc.depIndex )
         return w;               // recursive call with w in recursive algorithm
       }
@@ -112,7 +112,7 @@ function detectCycles( definitions, reportCycle, cbScc ) {
   function defaultCb( w, v, r ) {
     for (const dep of w._deps) {
       if (dep.art._scc.lowlink === w._scc.lowlink) // in same SCC
-        reportCycle( w, dep.art, dep.location );
+        reportCycle( w, dep.art, dep.location, dep.semanticLoc );
     }
     return r;
   }
@@ -127,7 +127,7 @@ function detectCycles( definitions, reportCycle, cbScc ) {
         delete v._sccCaller;
         for (const w of v._deps) {
           if (w.art._scc)
-            todos.push(w.art);
+            todos.push( w.art );
         }
       }
     }

package/lib/compiler/define.js

@@ -141,7 +141,8 @@ const {
 const { compareLayer } = require('./moduleLayers');
 const { initBuiltins, isInReservedNamespace } = require('./builtins');
 
-const $location = Symbol.for('cds.$location');
+const $location = Symbol.for( 'cds.$location' );
+const $inferred = Symbol.for( 'cds.$inferred' );
 
 /**
  * Export function of this file.  Transform argument `sources` = dictionary of
@@ -172,6 +173,7 @@ function define( model ) {
     initArtifact,
     initMembers,
     checkDefinitions,           // TODO: remove
+    initSelectItems,
   } );
 
   let boundSelfParamType = true; // special `$self` for binding param must still be initialised
@@ -192,11 +194,11 @@ function define( model ) {
                  beta: 'With option $(PROP), beta features and many other newer features are disabled',
                } );
     }
-    model.definitions = Object.create(null);
+    model.definitions = Object.create( null );
     setLink( model, '_entities', [] ); // for entities with includes
     model.$entity = 0;
-    model.$compositionTargets = Object.create(null);
-    model.$collectedExtensions = Object.create(null);
+    model.$compositionTargets = Object.create( null );
+    model.$collectedExtensions = Object.create( null );
 
     initBuiltins( model );
     const sourceNames = shuffleArray( Object.keys( model.sources ) );
@@ -226,7 +228,7 @@ function define( model ) {
 
     let namespace = src.namespace && src.namespace.path;
     let prefix = namespace ? `${ pathName( namespace ) }.` : '';
-    if (isInReservedNamespace(prefix)) {
+    if (isInReservedNamespace( prefix )) {
       error( 'reserved-namespace-cds', [ src.namespace.location, src.namespace ], { name: 'cds' },
              'The namespace $(NAME) is reserved for CDS builtins' );
       namespace = null;
@@ -239,7 +241,7 @@ function define( model ) {
         addPathPrefixes( src.artifacts, prefix ); // before addUsing
       }
       else if (src.usings || src.namespace) {
-        src.artifacts = Object.create(null);
+        src.artifacts = Object.create( null );
       }
       if (src.usings)
         shuffleArray( src.usings ).forEach( u => addUsing( u, src ) );
@@ -252,11 +254,11 @@ function define( model ) {
     }
     else if (src.definitions) {      // CSN input
       prefix = '';
-      dictForEach( shuffleDict( src.definitions ), v => addDefinition( v, src ) );
+      dictForEach( shuffleDict( src.definitions ), def => addDefinition( def, src, prefix ) );
     }
     if (src.vocabularies) {
       if (!model.vocabularies)
-        model.vocabularies = Object.create(null);
+        model.vocabularies = Object.create( null );
       dictForEach( shuffleDict( src.vocabularies ), v => addVocabulary( v, src, prefix ) );
     }
     if (src.extensions) {       // requires using to be known!
@@ -264,10 +266,14 @@ function define( model ) {
     }
   }
 
-  function addDefinition( art, block ) {
+  function addDefinition( art, block, prefix ) {
+    if (!art.name.absolute) {
+      // TODO: art.name.absolute = art.name.id || …
+      art.name.absolute = (!art.name.path) ? art.name.id : prefix + pathName( art.name.path );
+    }
     const { absolute } = art.name;
     // TODO: check reserved, see checkName()/checkLocalizedObjects() of checks.js
-    if (absolute === 'cds' || isInReservedNamespace(absolute)) {
+    if (absolute === 'cds' || isInReservedNamespace( absolute )) {
       error( 'reserved-namespace-cds', [ art.name.location, art ], { name: 'cds' },
              'The namespace $(NAME) is reserved for CDS builtins' );
       const builtin = model.definitions[absolute];
@@ -292,7 +298,7 @@ function define( model ) {
   function addPathPrefixes( artifacts, prefix ) {
     for (const name in artifacts) {
       const d = artifacts[name];
-      const a = Array.isArray(d) ? d[0] : d;
+      const a = Array.isArray( d ) ? d[0] : d;
       if (!a.name.absolute)
         a.name.absolute = prefix + name;
       const index = name.indexOf( '.' );
@@ -357,7 +363,7 @@ function define( model ) {
     // create using for own namespace:
     const last = path[path.length - 1];
     const { id } = last;
-    if (src.artifacts[id] || last.id.includes('.'))
+    if (src.artifacts[id] || last.id.includes( '.' ))
       // not used as we have a definition/using with that name, or dotted last path id
       return;
     src.artifacts[id] = {
@@ -373,8 +379,7 @@ function define( model ) {
   function addArtifact( art, block, prefix ) {
     if (art.kind === 'using')
       return;
-    art.name.absolute = prefix + pathName( art.name.path );
-    addDefinition( art, block );
+    addDefinition( art, block, prefix );
     if (art.artifacts) {
       const p = `${ art.name.absolute }.`;
       // path prefixes (usings) must be added before extensions in artifacts:
@@ -444,8 +449,12 @@ function define( model ) {
   function addVocabulary( vocab, block, prefix ) {
     setLink( vocab, '_block', block );
     const { name } = vocab;
-    if (!name.absolute)
-      name.absolute = prefix + pathName( name.path );
+    if (!name.absolute) {
+      // TODO: art.name.absolute = vocab.name.id || …
+      vocab.name.absolute = (!vocab.name.path)
+        ? vocab.name.id
+        : prefix + pathName( vocab.name.path );
+    }
     dictAdd( model.vocabularies, name.absolute, vocab );
   }
 
@@ -454,8 +463,8 @@ function define( model ) {
    */
   function addI18nBlocks() {
     // TODO: the sequence should be in sync with extend / annotate / future $sources
-    const sortedSources = Object.keys(model.sources)
-      .filter(name => !!model.sources[name].i18n)
+    const sortedSources = Object.keys( model.sources )
+      .filter( name => !!model.sources[name].i18n )
       .sort( (a, b) => compareLayer( model.sources[a], model.sources[b] ) );
 
     if (sortedSources.length === 0)
@@ -550,7 +559,7 @@ function define( model ) {
       return;
     for (const name in src.artifacts) {
       const entry = src.artifacts[name];
-      if (!Array.isArray(entry)) // no local name duplicate
+      if (!Array.isArray( entry )) // no local name duplicate
         continue;
       for (const decl of entry) {
         if (!decl.$duplicates) { // do not have two duplicate messages
@@ -574,7 +583,7 @@ function define( model ) {
     if (!art.query)
       return;
     art.$queries = [];
-    setLink( art, '_from', [] ); // for sequence of resolve steps
+    setLink( art, '_from', [] ); // for sequence of resolve steps - TODO: remove
     if (!setLink( art, '_leadingQuery', initQueryExpression( art.query, art ) ) )
       return;                   // null or undefined in case of parse error
     // if (art._leadingQuery !== art.$queries [0]) throw Error('FOO');
@@ -596,7 +605,7 @@ function define( model ) {
   function initArtifactParentLink( art, definitions ) {
     setLink( art, '_parent', null );
     const { absolute } = art.name;
-    const dot = absolute.lastIndexOf('.');
+    const dot = absolute.lastIndexOf( '.' );
     if (dot < 0)
       return;
     art.name.id = absolute.substring( dot + 1 ); // XSN TODO: remove name.id for artifacts
@@ -610,7 +619,7 @@ function define( model ) {
     }
     setLink( art, '_parent', parent );
     if (!parent._subArtifacts)
-      setLink( parent, '_subArtifacts', Object.create(null) );
+      setLink( parent, '_subArtifacts', Object.create( null ) );
     if (art.$duplicates !== true) // no redef or "first def"
       parent._subArtifacts[absolute.substring( dot + 1 )] = art; // not dictAdd()
   }
@@ -631,7 +640,7 @@ function define( model ) {
     setLink( self, '_parent', art );
     setLink( self, '_main', art ); // used on main artifact
     setLink( self, '_origin', art );
-    art.$tableAliases = Object.create(null);
+    art.$tableAliases = Object.create( null );
     art.$tableAliases[selfname] = self;
   }
 
@@ -695,13 +704,17 @@ function define( model ) {
       for (const q of query.args.slice(1))
         initQueryExpression( q, art );
       setLink( query, '_leadingQuery', leading );
-      if (leading && query.orderBy) {
-        if (leading.$orderBy)
+      if (leading) {
+        if (query.orderBy) {
+          leading.$orderBy ??= [ ];
           leading.$orderBy.push( ...query.orderBy );
-        else
-          leading.$orderBy = [ ...query.orderBy ];
+        }
+        if (query.limit) {
+          leading.$limit ??= [ ];
+          leading.$limit.push( query.limit );
+        }
       }
-      // ORDER BY to be evaluated in leading query (LIMIT is literal)
+      // ORDER BY and LIMIT to be evaluated in leading query
     }
     else { // with parse error (`select from <EOF>`, `select from E { *, ( select }`)
       return undefined;
@@ -711,7 +724,7 @@ function define( model ) {
     function initQuery() {
       const main = art._main || art;
       setLink( query, '_$next',
-               (art.kind === '$tableAlias' ? art._parent._$next : art) );
+               (art.kind === '$tableAlias' ? art._parent._$next : art ) );
       setLink( query, '_block', art._block );
       query.kind = 'select';
       query.name = { location: query.location };
@@ -735,7 +748,7 @@ function define( model ) {
         return;
       if (!table.name) {
         const last = table.path[table.path.length - 1];
-        const dot = last?.id?.lastIndexOf('.');
+        const dot = last?.id?.lastIndexOf( '.' );
         const id = (dot >= 0) ? last.id.substring( dot + 1 ) : last.id || '';
         // TODO: if we have too much time, we can calculate the real location with '.'
         table.name = { $inferred: 'as', id, location: last.location };
@@ -788,6 +801,7 @@ function define( model ) {
         // (internal) query, should only be relevant for --raw-output, not for
         // user messages or references - TODO: correct if join on left?
         table.name.param = aliases[1] || aliases[0] || '<unknown>';
+        setLink( table, '_user', query ); // TODO: do not set kind/name
         setLink( table, '_$next', query._$next );
         // TODO: probably set this to query if we switch to name restriction in JOIN
       }
@@ -802,7 +816,7 @@ function define( model ) {
         if (tableAlias.$inferred === '$internal') {
           const semanticLoc = tableAlias.query?.name ? tableAlias.query : tableAlias;
           error( 'name-missing-alias', [ tableAlias.location, semanticLoc ],
-                 { '#': 'duplicate', code: 'as ‹alias›' });
+                 { '#': 'duplicate', code: 'as ‹alias›' } );
         }
         else {
           error( 'duplicate-definition', [ loc, table ], { name, '#': 'alias' } );
@@ -838,7 +852,7 @@ function define( model ) {
 
   function initExprForQuery( expr, query ) {
     // TODO: use traverseExpr()
-    if (Array.isArray(expr)) { // TODO: old-style $parens ?
+    if (Array.isArray( expr )) { // TODO: old-style $parens ?
       expr.forEach( e => initExprForQuery( e, query ) );
     }
     else if (!expr) {
@@ -848,13 +862,13 @@ function define( model ) {
       initQueryExpression( expr.query, query );
     }
     else if (expr.args) {
-      const args = Array.isArray(expr.args) ? expr.args : Object.values( expr.args );
+      const args = Array.isArray( expr.args ) ? expr.args : Object.values( expr.args );
       args.forEach( e => initExprForQuery( e, query ) );
     }
     else if (expr.path && expr.$expected === 'exists') {
       // TODO: does really the parser has to set $expected?
       expr.$expected = 'approved-exists';
-      approveExistsInChildren(expr);
+      approveExistsInChildren( expr );
     }
   }
 
@@ -880,9 +894,9 @@ function define( model ) {
     }
   }
 
-  function initSelectItems( parent, columns, user ) {
-    // TODO: forbid expand/inline with :param, global:true, in ref-where, outside queries (CSN), ...
-    let wildcard = null;
+  function initSelectItems( parent, columns, user, inExtension = false ) {
+    let wildcard = !!inExtension; // no `extend … with columns { * }`
+    // TODO: forbid expand/inline in ref-where, outside queries (CSN), ...
     let hasItems = false;
     for (const col of columns || parent.expand || parent.inline || []) {
       if (!col)                 // parse error
@@ -898,6 +912,11 @@ function define( model ) {
         if (!wildcard) {
           wildcard = col;
         }
+        else if (wildcard === true) { // in `extend … with columns {…}`
+          error( 'ext-unexpected-wildcard', [ col.location, parent ], { code: '*' },
+                 'Unexpected $(CODE) (wildcard) in an extension' );
+          col.val = null;       // do not consider it for expandWildcard()
+        }
         else {
           // a late syntax error (this code also runs with parse-cdl), i.e.
           // no semantic loc (wouldn't be available for expand/inline anyway)
@@ -917,7 +936,8 @@ 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 );
+        if (!col._block)
+          setLink( col, '_block', parent._block );
         if (col.inline) { // `@anno elem.{ * }` does not work
           if (col.doc) {
             warning( 'syntax-ignoring-anno', [ col.doc.location, col ],
@@ -925,30 +945,25 @@ function define( model ) {
           }
           // 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('@'));
+          const firstAnno = Object.keys( col ).find( key => key.startsWith( '@' ) );
           if (firstAnno) {
             warning( 'syntax-ignoring-anno', [ col[firstAnno].name.location, col ],
                      { code: '.{ ‹inline› }' } );
           }
         }
         // TODO: allow sub queries? at least in top-level expand without parallel ref
-        if (columns)
+        if (columns && !inExtension) // not (yet) in `extend … with columns {…}`
           initExprForQuery( col.value, parent );
-        initSelectItems( col, null, user );
+        initSelectItems( col, null, user ); // TODO: use col as user (i.e. remove param)
       }
     }
 
-    if (hasItems && !wildcard && parent.excludingDict) {
-      // TODO: Better way to get source file?
-      let block = parent;
-      while (block._block)
-        block = block._block;
-
-      if (block.$frontend === 'cdl') {
-        warning('query-ignoring-exclude', [ parent.excludingDict[$location], user ],
-                { prop: '*' },
-                'Excluding elements without wildcard $(PROP) has no effect');
-      }
+    if (hasItems && !wildcard && parent.excludingDict && !options.$recompile) {
+      // TODO: the SQL backend should probably delete `excluding` when expanding `*`
+      // TODO: use `parent` for semantic location, use `-excluding`
+      warning( 'query-ignoring-exclude', [ parent.excludingDict[$location], user ],
+               { prop: '*' },
+               'Excluding elements without wildcard $(PROP) has no effect' );
     }
   }
 
@@ -975,11 +990,11 @@ function define( model ) {
       exprOrPathElement.$expected = 'approved-exists';
     // Drill down
     if (exprOrPathElement.args)
-      exprOrPathElement.args.forEach(elem => approveExistsInChildren(elem));
+      exprOrPathElement.args.forEach( elem => approveExistsInChildren( elem ) );
     else if (exprOrPathElement.where && exprOrPathElement.where.args)
-      exprOrPathElement.where.args.forEach(elem => approveExistsInChildren(elem));
+      exprOrPathElement.where.args.forEach( elem => approveExistsInChildren( elem ) );
     else if (exprOrPathElement.path)
-      exprOrPathElement.path.forEach(elem => approveExistsInChildren(elem));
+      exprOrPathElement.path.forEach( elem => approveExistsInChildren( elem ) );
   }
   // TODO: we might issue 'expr-unexpected-exists' and 'expr-no-subquery' already in
   // define.js (using a to-be-written expression traversal function in utils.js)
@@ -1016,13 +1031,13 @@ function define( model ) {
     const { targetAspect } = obj;
     if (targetAspect) {
       if (obj.foreignKeys) {
-        error( 'unexpected-keys-for-composition', [ obj.foreignKeys[$location], construct ],
+        error( 'type-unexpected-foreign-keys', [ obj.foreignKeys[$location], construct ],
                {},
                'A managed aspect composition can\'t have a foreign keys specification' );
         delete obj.foreignKeys; // continuation semantics: not specified
       }
       if (obj.on && !obj.target) {
-        error( 'unexpected-on-for-composition', [ obj.on.location, construct ],
+        error( 'type-unexpected-on-condition', [ obj.on.location, construct ],
                {},
                'A managed aspect composition can\'t have a specified ON-condition' );
         delete obj.on;          // continuation semantics: not specified
@@ -1056,30 +1071,33 @@ function define( model ) {
 
     function initElementsAsEnum() {
       // in extensions, extended enums are represented as elements
-      let firstEnum = null;
+      let hasElement = false;
       for (const n in obj.elements) {
         const e = obj.elements[n];
-        if (e.kind === 'element') {
-          // An "element" has `$syntax: 'enum'` if it could also be an enum
-          if (e.$syntax === 'enum') { // TODO: what about "just name"? (current forbidden)
-            e.kind = 'enum';
-            firstEnum = firstEnum || e;
-          }
-          else {
-            // We do not want to complain separately about all element properties:
-            error( 'ext-unexpected-element', [ e.location, construct ],
-                   { name: e.name.id, code: 'extend … with enum' },
-                   // eslint-disable-next-line max-len
-                   'Unexpected elements like $(NAME) in an extension for an enum. Additionally, use $(CODE) when extending enums' );
-            return;
-          }
+        if (e.kind === 'extend')
+          continue;
+        const noVal = e.value?.val === undefined && e.value?.sym === undefined;
+        // TODO: forbid #symbol as enum value
+        if (e.$syntax === 'element' || // `extend … with elements` or `extend with { element … }`
+            noVal && e.$syntax !== 'enum' || // no value in CDL input
+            e.virtual || e.key || e.masked || e.type || e.elements || e.items || e.stored) {
+          // We do not want to complain separately about all element properties:
+          error( 'ext-unexpected-element', [ e.location, construct ],
+                 { name: e.name.id, code: 'extend … with enum' },
+                 // eslint-disable-next-line max-len
+                 'Unexpected elements like $(NAME) in an extension for an enum. Additionally, use $(CODE) when extending enums' );
+          // Don't emit 'ext-expecting-enum' if this error is emitted.
+          return;
         }
+        e.kind = 'enum';
+        if (noVal || e.$syntax !== 'enum')
+          hasElement = true;    // warning with CDL input or `name: {}` in CSN input
       }
-      if (firstEnum && block.$frontend !== 'json') {
-        // Don't emit this message if `ext-unexpected-element` was already emitted.
-        // This message is similar to the one above.  In v5/6, we could probably remove the warning
-        // and always emit the error.
-        warning( 'ext-expecting-enum', [ firstEnum.location, construct ],
+      if (hasElement) {
+        // This message is similar to the one above.  In v5/6, we could probably
+        // turn this warning into an error, remove `$syntax: 'element' (also in
+        // language.g4), and use the above `ext-unexpected-element` only for CSN input.
+        warning( 'ext-expecting-enum', [ obj.elements[$location], construct ],
                  { code: 'extend … with enum' }, 'Use $(CODE) when extending enums' );
       }
       forEachGeneric( { enum: obj.elements }, 'enum', init );
@@ -1208,18 +1226,25 @@ function define( model ) {
     // - artifacts (CDL-only anyway) only inside [extend] context|service
     if (!dict)
       return false;
-    const names = Object.keys( dict );
-    if (!names.length) // TODO: re-check - really allow empty dict if no other?
-      return false;
     const feature = kindProperties[parent.kind][prop];
     if (feature &&
         (feature === true || construct.kind !== 'extend' || feature( prop, parent )))
       return true;
     const location = dict[$location];
+
+    // TODO: a bit inconsistent = not a simple switch on `prop`…
     if (prop === 'actions') {
-      error( 'def-unexpected-actions', [ location, construct ], {},
-             'Actions and functions only exist top-level and for entities' );
+      if (Object.keys( dict ).length) {
+        error( 'def-unexpected-actions', [ location, construct ], {}, // TODO: ext-
+               'Actions and functions only exist top-level and for entities' ); // or aspects
+      }
+      else {
+        warning( 'ext-ignoring-actions', [ location, construct ], {},
+                 'Actions and functions only exist top-level and for entities' );
+        return false;
+      }
     }
+    //
     else if (parent.kind === 'action' || parent.kind === 'function') {
       error( 'ext-unexpected-action', [ construct.location, construct ], { '#': parent.kind }, {
         std: 'Actions and functions can\'t be extended, only annotated',
@@ -1231,7 +1256,7 @@ function define( model ) {
       if (!feature) {
         // Note: This error can't be triggered at the moment.  But as we likely want to
         //       allow extensions with params in the future, we keep the code.
-        error( 'unexpected-params', [ location, construct ], {},
+        error( 'def-unexpected-params', [ location, construct ], {},
                'Parameters only exist for entities, actions or functions' );
       }
       else {
@@ -1241,10 +1266,15 @@ function define( model ) {
       }
     }
     else if (feature) {         // allowed in principle, but not with extend
-      if (parent.$inferred === 'include') { // special case for better error message
+      if (!Object.keys( dict ).length) {
+        warning( 'ext-ignoring-elements', [ location, construct ], {},
+                 'Only structures with directly specified elements can be extended by elements' );
+        return false;
+      }
+      else if (parent.$inferred === 'include') { // special case for better error message
         const variant = (construct.enum || construct.elements) ? 'elements' : 'std';
         error( 'ref-expected-direct-structure', [ location, construct ],
-               { '#': variant, art: parent });
+               { '#': variant, art: parent } );
       }
       else {
         error( 'extend-type', [ location, construct ], {},
@@ -1252,7 +1282,7 @@ function define( model ) {
       }
     }
     else if (prop === 'elements') {
-      error( 'unexpected-elements', [ location, construct ], {},
+      error( 'def-unexpected-elements', [ location, construct ], {},
              'Elements only exist in entities, types or typed constructs' );
     }
     else if (prop === 'columns') {
@@ -1265,19 +1295,23 @@ function define( model ) {
     return construct === parent;
   }
 
-  // Return whether the `target` is actually a `targetAspect`
-  // TODO: really do that here and not in kick-start.js?
+  /**
+   * Return whether the `target` is actually a `targetAspect`
+   * TODO: really do that here and not in kick-start.js?
+   */
   function targetIsTargetAspect( elem ) {
     const { target } = elem;
     if (target.elements) {
-      // TODO: error if CSN has both target.elements and targetAspect.elements -> delete target
+      // TODO: error if CSN has both target.elements and targetAspect.elements
+      // -> delete target
       return true;
     }
     if (elem.targetAspect || options.parseCdl || !isDirectComposition( elem ))
       return false;
     const name = resolveUncheckedPath( target, 'target', elem );
     const aspect = name && model.definitions[name];
-    return aspect && (aspect.kind === 'aspect' || aspect.kind === 'type'); // type is sloppy
+    return (aspect?.kind === 'aspect' || aspect?.kind === 'type') && // type is sloppy
+      aspect.elements && !aspect.elements[$inferred];
   }
 }