@sap/cds-compiler 3.0.0 → 3.1.2

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 )) {

package/lib/compiler/extend.js

@@ -33,6 +33,7 @@ function extend( model ) {
   const {
     resolvePath,
     resolveUncheckedPath,
+    checkAnnotate,
     defineAnnotations,
     attachAndEmitValidNames,
     checkDefinitions,
@@ -179,6 +180,10 @@ function extend( model ) {
       checkDefinitions( ext, art, 'actions');
       checkDefinitions( ext, art, 'params');
       checkDefinitions( ext, art, 'columns');
+      if (ext.includes)
+        applyIncludes( ext, art ); // emits error if `includes` is set
+      if (ext.kind === 'annotate')
+        checkAnnotate( ext, art );
       defineAnnotations( ext, art, ext._block, ext.kind );
     }
     return true;
@@ -238,6 +243,8 @@ function extend( model ) {
             art.includes = [ ...ext.includes ];
           applyIncludes( ext, art );
         }
+        if (ext.kind === 'annotate')
+          checkAnnotate( ext, art );
         defineAnnotations( ext, art, ext._block, ext.kind );
         // TODO: do we allow to add elements with array of {...}?  If yes, adapt
         initMembers( ext, art, ext._block ); // might set _extend, _annotate
@@ -389,9 +396,13 @@ function extend( model ) {
         for (const ext of exts) {
           delete ext.name.path[0]._artifact;      // get message for root
           // TODO: make resolvePath('extend'/'annotate') ignore namespaces
-          if (resolvePath( ext.name, ext.kind, ext )) { // should issue error/info
+          // Don't try to apply annotations in the `localized.` namespace.
+          // That's done in `localized.js`.
+          if (!name.startsWith('localized.') &&
+            resolvePath( ext.name, ext.kind, ext )) { // should issue error/info
             // should issue error for cds extensions (annotate ok)
             if (art.kind === 'namespace') {
+              // TODO: Emit error if namespace is extended by non-definitions.
               info( 'anno-namespace', [ ext.name.location, ext ], {},
                     'Namespaces can\'t be annotated' );
             }
@@ -451,6 +462,12 @@ function extend( model ) {
    * @param {XSN.Artifact} art
    */
   function applyIncludes( ext, art ) {
+    if (kindProperties[art.kind].include !== true) {
+      error('extend-unexpected-include', [ ext.includes[0]?.location, ext ], { kind: art.kind },
+            'Can\'t extend $(KIND) with includes');
+      return;
+    }
+
     if (!art._ancestors)
       setLink( art, '_ancestors', [] ); // recursive array of includes
     for (const ref of ext.includes) {
@@ -512,9 +529,7 @@ function extend( model ) {
     const fioriAnno = art['@fiori.draft.enabled'];
     const fioriEnabled = fioriAnno && (fioriAnno.val === undefined || fioriAnno.val);
 
-    const textsName = (isDeprecatedEnabled( options, '_generatedEntityNameWithUnderscore' ))
-      ? `${ art.name.absolute }_texts`
-      : `${ art.name.absolute }.texts`;
+    const textsName = `${ art.name.absolute }.texts`;
     const textsEntity = model.definitions[textsName];
     const localized = localizedData( art, textsEntity, fioriEnabled );
     if (!localized)
@@ -657,8 +672,6 @@ function extend( model ) {
       };
       dictAdd( art.elements, 'ID_texts', textId );
     }
-    if (isDeprecatedEnabled( options, '_generatedEntityNameWithUnderscore' ))
-      setLink( art, '_base', base );
 
     dictAdd( art.elements, 'locale', locale );
     if (addTextsLanguageAssoc) {
@@ -831,9 +844,7 @@ function extend( model ) {
         target = resolvePath( origin.targetAspect, 'compositionTarget', origin );
       if (!target || !target.elements)
         return;
-      const entityName = (isDeprecatedEnabled( options, '_generatedEntityNameWithUnderscore' ))
-        ? `${ base.name.absolute }_${ elem.name.id }`
-        : `${ base.name.absolute }.${ elem.name.id }`;
+      const entityName = `${ base.name.absolute }.${ elem.name.id }`;
       const entity = allowAspectComposition( target, elem, keys, entityName ) &&
             createTargetEntity( target, elem, keys, entityName, base );
       elem.target = {
@@ -965,8 +976,6 @@ function extend( model ) {
       // even if target cardinality is 1..1
       up.notNull = { location, val: true };
     }
-    if (isDeprecatedEnabled( options, '_generatedEntityNameWithUnderscore' ))
-      setLink( art, '_base', base._base || base );
 
     dictAdd( art.elements, 'up_', up);
     addProxyElements( art, target.elements, 'aspect-composition', target.name && location );

package/lib/compiler/finalize-parse-cdl.js

@@ -82,8 +82,12 @@ function finalizeParseCdl( model ) {
     for (const include of artifact.includes || [])
       resolveUncheckedPath(include, 'include', main);
 
+    // define.js takes care that `target` is a ref and
+    // `targetAspect` is a structure.
     if (artifact.target)
       resolveUncheckedPath(artifact.target, 'target', main);
+    if (artifact.targetAspect)
+      resolveTypesForParseCdl(artifact.targetAspect, main);
 
     if (artifact.from) {
       const { from } = artifact;
@@ -93,12 +97,6 @@ function finalizeParseCdl( model ) {
       resolveTypesForParseCdl(from, main);
     }
 
-    if (artifact.targetAspect) {
-      if (artifact.targetAspect.path)
-        resolveUncheckedPath(artifact.targetAspect, 'target', main);
-      resolveTypesForParseCdl(artifact.targetAspect, main);
-    }
-
     // Recursively go through all XSN properties.  There are a few that need to be
     // handled specifically.  Refer to the code below this loop for details.
     for (const prop in artifact) {
@@ -158,8 +156,6 @@ function finalizeParseCdl( model ) {
    * @param {XSN.Artifact} user
    */
   function resolveTypeUnchecked(artWithType, user) {
-    if (!artWithType.type)
-      return;
     const root = artWithType.type.path && artWithType.type.path[0];
     if (!root) // parse error
       return;
@@ -187,7 +183,7 @@ function finalizeParseCdl( model ) {
       let struct = artWithType;
       while (struct.kind === 'element')
         struct = struct._parent;
-      if (struct.kind === 'select' || struct !== user._main) {
+      if (struct.kind === 'select' || struct.kind === 'annotation' || struct !== user._main) {
         message( 'type-unexpected-typeof', [ artWithType.type.location, user ],
                  { keyword: 'type of', '#': struct.kind } );
         return;

package/lib/compiler/index.js

@@ -84,6 +84,8 @@ function parseX( source, filename, options = {}, messageFunctions = null ) {
     return parseCsn.parse( source, filename, options, messageFunctions );
   if (options.fallbackParser)   // any other value: like 'cdl' (historic reasons)
     return parseLanguage( source, filename, options, messageFunctions );
+  if (source.startsWith('{')) // Source may be JSON.
+    return parseCsn.parse( source, filename, options, messageFunctions );
 
   const model = { location: { file: filename } };
   messageFunctions.error( 'file-unknown-ext', emptyWeakLocation(filename),

package/lib/compiler/populate.js

@@ -73,14 +73,8 @@ function populate( model ) {
   /** @type {any} may also be a boolean */
   let newAutoExposed = [];
 
-  // behavior depending on option `deprecated`:
-  const enableExpandElements = !isDeprecatedEnabled( options, '_noElementsExpansion' );
-  // TODO: we should get rid of noElementsExpansion soon; both
-  // beta.nestedProjections and beta.universalCsn do not work with it.
   const scopedRedirections
-        = enableExpandElements &&
-          !isDeprecatedEnabled( options, '_generatedEntityNameWithUnderscore' ) &&
-          !isDeprecatedEnabled( options, '_shortAutoexposed' ) &&
+        = !isDeprecatedEnabled( options, '_shortAutoexposed' ) &&
           !isDeprecatedEnabled( options, '_longAutoexposed' ) &&
           !isDeprecatedEnabled( options, '_noInheritedAutoexposeViaComposition' ) &&
           !isDeprecatedEnabled( options, '_noScopedRedirections' );
@@ -109,6 +103,8 @@ function populate( model ) {
   function traverseElementEnvironments( art ) {
     populateView( art );
     environment( art );
+    if (art.elements$)
+      mergeSpecifiedElements(art);
     forEachMember( art, traverseElementEnvironments );
   }
 
@@ -165,7 +161,7 @@ function populate( model ) {
     // console.log(message( null, art.location, art, {}, 'Info','FT').toString())
     const chain = [];
     while (art && !('_effectiveType' in art) &&
-           (art.type || art._origin || art.value && art.value.path) &&
+           (art.type || art._origin || art.value?.path || art.value?.type) &&
            // TODO: really stop at art.enum? See #8942
            !art.target && !art.enum && !art.elements && !art.items) {
       chain.push( art );
@@ -195,7 +191,7 @@ function populate( model ) {
       let eType = art;
       if (eType._outer)
         eType = effectiveType( eType._outer );
-      // collect the "latest" cardinality (calculate lazyly if necessary)
+      // collect the "latest" cardinality (calculate lazily if necessary)
       let cardinality = art.cardinality ||
           art._effectiveType && (() => getCardinality( art._effectiveType ));
       let prev = art;
@@ -222,10 +218,12 @@ function populate( model ) {
       return art._origin;
     if (art.type)
       return resolveType( art.type, art );
+    if (art.value?.type)
+      return resolveType( art.value.type, art );
     // console.log( 'EXPR-IN', art.kind, refString(art.name) )
     if (!art._main || !art.value || !art.value.path)
       return undefined;
-    if (art._pathHead && art.value) {
+    if (art._pathHead && art.value.path) {
       setLink( art, '_origin', resolvePath( art.value, 'expr', art, null ) );
       return art._origin;
     }
@@ -246,7 +244,9 @@ function populate( model ) {
       let struct = user;
       while (struct.kind === 'element')
         struct = struct._parent;
-      if (struct.kind === 'select') {
+      if (struct.kind === 'select' || struct.kind === 'annotation') {
+        // `type of` in annotation definitions can't work, because csn type refs
+        // always refer to definitions.
         message( 'type-unexpected-typeof', [ ref.location, user ],
                  { keyword: 'type of', '#': struct.kind } );
         // we actually refer to an element in _combined; TODO: return null if
@@ -293,7 +293,7 @@ function populate( model ) {
 
 
   function expandItems( art, origin, eType ) {
-    if (!enableExpandElements || art.items)
+    if (art.items)
       return false;
     if (isInParents( art, eType )) {
       art.items = 0;            // circular
@@ -310,8 +310,6 @@ function populate( model ) {
   }
 
   function expandElements( art, struct, eType ) {
-    if (!enableExpandElements)
-      return false;
     if (art.elements || art.kind === '$tableAlias' ||
         // no element expansions for "non-proper" types like
         // entities (as parameter types) etc:
@@ -345,7 +343,7 @@ function populate( model ) {
   }
 
   function expandEnum( art, origin ) {
-    if (!enableExpandElements || art.enum)
+    if (art.enum)
       return false;
     const ref = art.type || art.value || art.name;
     const location = weakLocation( ref && ref.location || art.location );
@@ -425,8 +423,6 @@ function populate( model ) {
         setLink( view, '_status', '_query' );
         // must be run in order “sub query in FROM first”:
         traverseQueryPost( view.query, null, populateQuery );
-        if (view.elements$)     // specified elements
-          mergeSpecifiedElements( view );
         if (!view.$entity) {
           model._entities.push( view );
           view.$entity = ++model.$entity;
@@ -435,14 +431,25 @@ function populate( model ) {
     }
   }
 
-  function mergeSpecifiedElements( view ) {
+  /**
+   * Merge _specified_ elements with _inferred_ elements in the given view/element,
+   * where specified elements can appear through CSN.
+   *
+   * We only copy annotations, since they are not part of `columns`,
+   * but only appear in `elements` in CSN.
+   *
+   * This is important to ensure re-compilability.
+   *
+   * @param art
+   */
+  function mergeSpecifiedElements( art ) {
     // Later we use specified elements as proxies to inferred of leading query
     // (No, we probably do not.)
-    for (const id in view.elements) {
-      const ielem = view.elements[id];  // inferred element
-      const selem = view.elements$[id]; // specified element
+    for (const id in art.elements) {
+      const ielem = art.elements[id];  // inferred element
+      const selem = art.elements$[id]; // specified element
       if (!selem) {
-        info( 'query-missing-element', [ ielem.name.location, view ], { id },
+        info( 'query-missing-element', [ ielem.name.location, art ], { id },
               'Element $(ID) is missing in specified elements' );
       }
       else {
@@ -452,10 +459,14 @@ function populate( model ) {
             ielem[prop] = selem[prop];
         }
         selem.$replacement = true;
+        if (selem.elements) {
+          setLink(ielem, 'elements$', selem.elements);
+          delete selem.elements;
+        }
       }
     }
-    for (const id in view.elements$) {
-      const selem = view.elements$[id]; // specified element
+    for (const id in art.elements$) {
+      const selem = art.elements$[id]; // specified element
       if (!selem.$replacement) {
         error( 'query-unspecified-element', [ selem.name.location, selem ], { id },
                'Element $(ID) does not result from the query' );
@@ -472,8 +483,6 @@ function populate( model ) {
     forEachGeneric( query, '$tableAliases', resolveTabRef );
 
     initFromColumns( query, query.columns );
-    // TODO: already in definer: complain about EXCLUDING with no wildcard
-    // (would have been automatically with a good CDL syntax: `* without (...)`)
     if (query.excludingDict) {
       for (const name in query.excludingDict)
         resolveExcluding( name, query._combined, query.excludingDict, query );
@@ -1037,8 +1046,6 @@ function populate( model ) {
   // which is not a context/service/namespace, or the definition itself.
   // If inside service, it is the direct child of the (most inner) service.
   function definitionScope( art ) {
-    if (art._base)              // with deprecated.generatedEntityNameWithUnderscore
-      return art._base;
     let base = art;
     while (art._parent) {
       if (art._parent.kind === 'service')
@@ -1110,10 +1117,8 @@ function populate( model ) {
       // the name for dependent entities have already been created using `_` then
       return `${ service.name.absolute }.${ name }`;
     }
-    if (isDeprecatedEnabled( options, '_longAutoexposed' )) {
-      const dedot = isDeprecatedEnabled( options, '_generatedEntityNameWithUnderscore' );
-      return `${ service.name.absolute }.${ dedot ? absolute.replace( /\./g, '_' ) : absolute }`;
-    }
+    if (isDeprecatedEnabled( options, '_longAutoexposed' ))
+      return `${ service.name.absolute }.${ absolute }`;
     const base = definitionScope( target );
     if (base === target)
       return `${ service.name.absolute }.${ absolute.substring( absolute.lastIndexOf('.') + 1 ) }`;

package/lib/compiler/propagator.js

@@ -1,4 +1,10 @@
-//
+// Propagate properties in XSN
+
+// See also internalDoc/PropagatedCsn.md.
+// As opposed to that document, the propagator here works on XSN, not CSN.
+// We also do not deep-copy member dictionaries here, but create proxy members
+// which get their properties via propagation: we use function `onlyViaParent`
+// if that property would not be propagated otherwise.
 
 'use strict';
 
@@ -11,6 +17,7 @@ const {
 const { setLink, linkToOrigin, withAssociation } = require('./utils');
 // const { refString } = require( '../base/messages')
 
+// Note that propagation here is also used for deep-copying (function `onlyViaParent`)
 function propagate( model ) {
   const props = {
     '@com.sap.gtt.core.CoreModel.Indexable': never,
@@ -56,7 +63,6 @@ function propagate( model ) {
     returns,
   };
   const { options } = model;
-  const enableExpandElements = !isDeprecatedEnabled( options, '_noElementsExpansion' );
   // eslint-disable-next-line max-len
   const oldVirtualNotNullPropagation = isDeprecatedEnabled( options, '_oldVirtualNotNullPropagation' );
 
@@ -189,7 +195,7 @@ function propagate( model ) {
     if (!type || type._main)
       return false;
     // We do not consider the $expand status, as elements are already expanded
-    // by the resolve(), and if not due to deprecated._noElementsExpansion
+    // by the resolve()
     run( type );
     return type[prop];
   }
@@ -313,11 +319,10 @@ function propagate( model ) {
 
   function items( prop, target, source ) {
     // usually considered expensive, except:
-    // - array of Entity (smooth upgrade: array of String(3), array of DerivedScalar)
+    // - array of Entity
     const line = availableAtType( prop, target, source );
     if (!line ||
-        line.type && line.type._artifact && line.type._artifact.kind === 'entity' ||
-        !line.elements && !line.enum && !line.items && !enableExpandElements)
+        line.type && line.type._artifact && line.type._artifact.kind === 'entity')
       returns( prop, target, source, true );
   }
 }

package/lib/compiler/resolve.js

@@ -87,6 +87,7 @@ function resolve( model ) {
   } = model.$messageFunctions;
   const {
     resolvePath,
+    checkAnnotate,
     defineAnnotations,
     attachAndEmitValidNames,
     lateExtensions,
@@ -103,11 +104,6 @@ function resolve( model ) {
 
   /** @type {any} may also be a boolean */
 
-  // behavior depending on option `deprecated`:
-  const enableExpandElements = !isDeprecatedEnabled( options, '_noElementsExpansion' );
-  // TODO: we should get rid of noElementsExpansion soon; both
-  // beta.nestedProjections and beta.universalCsn do not work with it.
-
   return doResolve();
 
   function doResolve() {
@@ -314,7 +310,7 @@ function resolve( model ) {
     if (obj.type)             // TODO: && !obj.type.$inferred ?
       resolveTypeExpr( obj, art );
     const type = effectiveType( obj ); // make sure implicitly redirected target exists
-    if (!obj.items && type && type.items && enableExpandElements) {
+    if (!obj.items && type && type.items) {
       // TODO: shouldn't be this part of populate.js ?
       const items = {
         location: weakLocation( (obj.type || obj).location ),
@@ -327,8 +323,7 @@ function resolve( model ) {
     }
     if (obj.items) {            // TODO: make this a while in v2 (also items proxy)
       obj = obj.items || obj; // the object which has type properties
-      if (enableExpandElements)
-        effectiveType(obj);
+      effectiveType(obj);
     }
     if (obj.type) {             // TODO: && !obj.type.$inferred ?
       if (obj !== (art.returns || art)) // not already checked
@@ -481,10 +476,7 @@ function resolve( model ) {
     if (ext.$extension) // extension for known artifact -> already applied
       return;
     annotateMembers( ext );
-    for (const prop in ext) {
-      if (prop.charAt(0) === '@')
-        chooseAssignment( prop, ext );
-    }
+    chooseAnnotationsInArtifact( ext );
   }
 
   /**
@@ -519,6 +511,8 @@ function resolve( model ) {
       setArtifactLink( ext.name, art );
 
       if (art) {
+        if (art.kind === 'annotate')
+          checkAnnotate( ext, art );
         defineAnnotations( ext, art, ext._block, ext.kind );
         // eslint-disable-next-line no-shadow
         forEachMember( ext, ( elem, name, prop ) => {
@@ -541,7 +535,7 @@ function resolve( model ) {
         }
         else if (prop === 'actions') {
           if (!feature) {
-            warning( 'anno-unexpected-actions', [ ext.name.location, art ], {},
+            warning( 'anno-unexpected-actions', [ ext.name.location, art._parent || art ], {},
                      'Actions and functions only exist top-level and for entities' );
           }
           else {
@@ -572,7 +566,7 @@ function resolve( model ) {
       // Currently(?), effectiveType() does not calculate the effective type of
       // its line item:
       effectiveType( obj );
-      if (art._annotate.elements)
+      if (art._annotate.elements) // explicit $expand on aor needed
         setExpandStatusAnnotate( aor, 'annotate' );
       annotate( obj, 'element', 'elements', 'enum', art );
       annotate( art, 'action', 'actions' );
@@ -596,6 +590,8 @@ function resolve( model ) {
     // eslint-disable-next-line no-shadow
     function annotate( obj, kind, prop, altProp, parent = obj ) {
       const dict = art._annotate[prop];
+      if (dict && art._annotate[prop])
+        setExpandStatusAnnotate( art, 'annotate' );
       const env = obj[prop] || altProp && obj[altProp] || null;
       for (const n in dict)
         annotateMembers( env && env[n], dict[n], prop, n, parent, kind );
@@ -618,7 +614,7 @@ function resolve( model ) {
 
   function expandParameters( action ) {
     // see also expandElements()
-    if (!enableExpandElements || !effectiveType( action ))
+    if (!effectiveType( action ))
       return;
     const chain = [];
     // Should we be able to consider params and returns separately?
@@ -959,7 +955,7 @@ function resolve( model ) {
       resolveBy( query.$orderBy, 'order-by-union', query.elements, query._parent );
     if (query.orderBy) {       // ORDER BY
     // search in `query.elements` after having checked table aliases of the current query
-      resolveBy( query.orderBy, 'expr', query.elements );
+      resolveBy( query.orderBy, 'order-by', query.elements );
       // TODO: disallow resulting element ref if in expression!
       // Necessary to check it in the compiler as it might work with other semantics on DB!
       // (we could downgrade it to a warning if name is equal to unique source element name)
@@ -1267,7 +1263,7 @@ function resolve( model ) {
     const typeArt = resolveType( art.type, user );
     if (typeArt) {
       resolveTypeArgumentsUnchecked( art, typeArt, user );
-      checkTypeArguments( art );
+      checkTypeArguments( art, typeArt );
     }
   }
 
@@ -1275,13 +1271,13 @@ function resolve( model ) {
    * Check the type arguments on `artWithType`.
    * If the effective type is an array or structured type, an error is emitted.
    */
-  function checkTypeArguments( artWithType ) {
+  function checkTypeArguments( artWithType, typeArt ) {
     // Note: `_effectiveType` may point to `artWithType` itself, if the type is structured.
     //       Also: For enums, it points to the enum type, which is why this trick is needed.
     // TODO(#8942): May not be necessary if effectiveType() is adapted.  Furthermore, the enum
     //              trick may be removed if effectiveType() does not stop at enums.
     const cyclic = new Set();
-    let effectiveTypeArt = effectiveType( artWithType );
+    let effectiveTypeArt = effectiveType( typeArt );
     while (effectiveTypeArt && effectiveTypeArt.enum && !cyclic.has(effectiveTypeArt)) {
       cyclic.add(effectiveTypeArt);
       const underlyingEnumType = directType(effectiveTypeArt);