@sap/cds-compiler 3.6.2 → 3.7.2

package/lib/compiler/propagator.js

@@ -14,7 +14,12 @@ const {
   forEachGeneric,
   isDeprecatedEnabled,
 } = require( '../base/model');
-const { setLink, linkToOrigin, withAssociation } = require('./utils');
+const {
+  setLink,
+  linkToOrigin,
+  withAssociation,
+  viewFromPrimary,
+} = require('./utils');
 const $inferred = Symbol.for('cds.$inferred');
 // const { refString } = require( '../base/messages')
 
@@ -81,7 +86,7 @@ function propagate( model ) {
   function run( art ) {
     if (!art)
       return;
-    if (!checkAndSetStatus( art )) {
+    if (!checkAndSetStatus( art ) || art.kind === 'select') {
       runMembers( art );
       return;
     }
@@ -254,7 +259,8 @@ function propagate( model ) {
   }
 
   function onlyViaArtifact( prop, target, source ) {
-    const from = target._from && target._from[0].path;
+    const from = viewFromPrimary( target )?.path;
+    // do not propagate from member / if follow assoc in from:
     if (!(from ? from[from.length - 1]._artifact : source)._main)
       annotation( prop, target, source );
   }
@@ -280,7 +286,7 @@ function propagate( model ) {
     if (!viaType)
       always( prop, target, source );
     else if (!oldVirtualNotNullPropagation) // NULL would block strange propagation to sub element
-      target[prop] = { $inferred: 'NULL', val: undefined }; // set null value in Univeral CSN
+      target[prop] = { $inferred: 'NULL', val: undefined }; // set null value in Universal CSN
   }
 
   function checkVirtual( view ) {
@@ -331,18 +337,14 @@ function targetMinZero( art ) {
 }
 
 function getOrigin( art ) {
-  if (art._origin)
+  let origin = art._origin;
+  while (origin?.kind === 'select')
+    origin = origin._origin;
+  if (origin)
     // Do not consider _origin if due to expand of table alias ref
-    return (!art.expand || art._origin.kind === 'element') && art._origin;
+    return (!art.expand || origin.kind === 'element') && origin;
   // Remark: a column with an 'inline' is never an element -> no need to check
   // art.inline
-  if (art._from && art._from.length) { // query
-    const tabref = art._from[0]._artifact;
-    return (tabref && tabref.kind === 'element')
-      ? tabref._effectiveType && tabref._effectiveType.target &&
-        tabref._effectiveType.target._artifact
-      : tabref;
-  }
 
   return (art.type && (!art.type.$inferred || art.type.$inferred === 'cast'))
     ? art.type._artifact

package/lib/compiler/resolve.js

@@ -52,11 +52,9 @@ const { typeParameters } = require('./builtins');
 
 const { kindProperties } = require('./base');
 const {
+  pushLink,
   setLink,
   setArtifactLink,
-  annotationHasEllipsis,
-  pathName,
-  linkToOrigin,
   setMemberParent,
   withAssociation,
   storeExtension,
@@ -69,7 +67,6 @@ const {
 } = require('./utils');
 
 const detectCycles = require('./cycle-detector');
-const { CompilerAssertion } = require('../base/error');
 
 const $location = Symbol.for('cds.$location');
 
@@ -94,12 +91,11 @@ function resolve( model ) {
     lateExtensions,
     applyTypeExtensions,
     effectiveType,
-    directType,
+    getOrigin,
+    chooseAnnotationsInArtifact,
+    extensionFor,
     resolveType,
     resolveTypeArgumentsUnchecked,
-    populateQuery,
-    layeredAssignments,
-    assignmentsOfHighestLayers,
   } = model.$functions;
   const { environment } = model.$volatileFunctions;
   Object.assign( model.$functions, {
@@ -117,7 +113,11 @@ function resolve( model ) {
     // addImplicitForeignKeys() in populate.js, as we might need to know the
     // foreign keys in populate.js (foreign key access w/o JOINs).
 
-    // Phase 3: calculate keys along simple queries in collected views:
+    // Phase 2+3: calculate keys along simple queries in collected views:
+    model._entities = Object.values( model.definitions )
+      .filter( art => art.$effectiveSeqNo )
+      .sort( (x, y) => x.$effectiveSeqNo - y.$effectiveSeqNo );
+    model._entities.forEach( setNavigationProjections );
     model._entities.forEach( propagateKeyProps );
     // While most dependencies leading have been added at this point, new
     // cycles could be added later (e.g. via assocs in where conditions),
@@ -146,9 +146,38 @@ function resolve( model ) {
   }
 
   //--------------------------------------------------------------------------
-  // Phase 3: calculate propagated KEYs
+  // Phase 2+3: calculate propagated KEYs
   //--------------------------------------------------------------------------
 
+  function setNavigationProjections( view ) {
+    if (!view.$queries)
+      return;
+    for (const query of view.$queries) {
+      forEachGeneric( query, 'elements', ( elem ) => {
+        if (!elem._origin || elem.expand || !elem.value)
+          return;
+        // TODO: what about elements where _origin is set without value?
+        // TODO: or should we push elems with `expand` sibling to extra list for
+        // better messages?  (Whatever that means exaclty.)
+        const nav = pathNavigation( elem.value );
+        const { path } = elem.value;
+        const item = path[path.length - 1];
+        if (nav.navigation && nav.item === item) {
+          // sourceElem, alias.sourceElem, mixin:
+          // redirectImplicitly( elem, origin );
+          pushLink( nav.navigation, '_projections', elem );
+        }
+        else if (elem._pathHead?.kind === '$inline' && path.length === 1) {
+          const hpath = elem._pathHead.value?.path;
+          const head = hpath?.length === 1 && hpath[0]._navigation;
+          // Alias .{ elem } - but not with Alias.{ $magic }: consider for ON-rewrite
+          if (head?.kind === '$tableAlias' && item.id.charAt(0) !== '$')
+            pushLink( head.elements[item.id], '_projections', elem );
+        }
+      } );
+    }
+  }
+
   function propagateKeyProps( view ) {
     // Second argument true ensure that `key` is only propagated along simple
     // view, i.e. ref or subquery in FROM, not UNION or JOIN.
@@ -293,16 +322,17 @@ function resolve( model ) {
   function resolveRefs( art ) {
     if (art.builtin)
       return;
-    // console.log(message( null, art.location, art, {}, 'Info','REFS').toString())
-    // console.log(message( null, art.location, art, {target:art.target}, 'Info','RR').toString())
+    // console.log(info( null, [ art.location, art ], {}, 'REFS').toString());
+    // console.log(info( null, [ art.location, art ], { art: art.target || 'none' },
+    //   'RR: $(ART)').toString());
     const parent = art._parent;
     const allowedInMain = [ 'entity', 'aspect', 'event' ].includes( adHocOrMainKind( art ) );
     const isTopLevelElement = parent && (parent.kind !== 'element' || parent.targetAspect);
-    if (art.key && art.key.val && !art.key.$inferred && !(allowedInMain && isTopLevelElement)) {
+    if (art.key?.val && !art.key.$inferred && !(allowedInMain && isTopLevelElement)) {
       warning( 'unexpected-key', [ art.key.location, art ],
-               { '#': allowedInMain ? 'sub' : 'std' }, {
-                 std: 'KEY is only supported for elements in an entity or an aspect',
-                 sub: 'KEY is only supported for top-level elements',
+               { '#': allowedInMain ? 'sub' : 'std', keyword: 'key' }, {
+                 std: '$(KEYWORD) is only supported for elements in an entity or an aspect',
+                 sub: '$(KEYWORD) is only supported for top-level elements',
                });
     }
     if (art.targetAspect && !(allowedInMain && isTopLevelElement)) {
@@ -348,7 +378,7 @@ function resolve( model ) {
       if (elemtype && effectiveType( elemtype )) {
         const assocType = getAssocSpec( elemtype ) || {};
         if (assocType.on && !obj.on)
-          obj.on = { $inferred: 'rewrite' };
+          obj.on = { $inferred: 'rewrite' }; // TODO: no extra rewrite here
         if (assocType.targetAspect) {
           error( 'composition-as-type-of', [ obj.type.location, art ], {},
                  'A managed aspect composition element can\'t be used as type' );
@@ -406,9 +436,7 @@ function resolve( model ) {
     if (art.$queries)
       art.$queries.forEach( resolveQuery );
 
-    if (obj.type || obj._origin || obj.value && obj.value.path || obj.elements) // typed artifacts
-      effectiveType(obj);  // set _effectiveType if appropriate, (future?): copy elems if extended
-
+    // TODO: or should we set silent dependencies in init()?
     if (obj.elements) {           // silent dependencies
       forEachGeneric( obj, 'elements', elem => dependsOnSilent( art, elem ) );
     }
@@ -424,11 +452,14 @@ function resolve( model ) {
 
     resolveExpr( art.default, 'default', art );
     resolveExpr( art.value, 'expr', art, undefined, art.expand || art.inline );
-    if (art.value && !art.type && !art.target && !art.elements)
-      inferTypeFromCast( art );
-
-    if (art.kind === 'element' || art.kind === 'mixin')
-      effectiveType( art );
+    if (art.type?.$inferred === 'cast')
+      inferTypePropertiesFromCast( art );
+    if (art.value) {
+      if (art.$syntax === 'calc')
+        checkCalculatedElement(art);
+      else if (art.type && !art.$inferred )
+        checkStructureCast(art);
+    }
 
     annotateMembers( art );     // TODO recheck - recursively, but also forEachMember below
     chooseAnnotationsInArtifact( art );
@@ -452,36 +483,86 @@ function resolve( model ) {
     }
   }
 
+  function checkCalculatedElement( art ) {
+    const loc = [ art.value.location, art ];
+    if (art._parent.kind === 'element') {
+      // TODO: Support calculated elements in structures.
+      //       The checks below are already aware of those.
+      message( 'def-unsupported-calc-elem', loc, { '#': 'nested' } );
+    }
+
+    const allowedInKind = [ 'entity', 'aspect', 'element' ];
+    let parent = art._parent;
+    while (parent.kind === 'element')
+      parent = parent._parent;
+
+    if (!allowedInKind.includes(art._main.kind)) {
+      error( 'def-invalid-calc-elem', loc, { '#': art._main.kind } );
+    }
+    else if (!allowedInKind.includes(parent.kind)) {
+      error( 'def-invalid-calc-elem', loc, { '#': parent.kind } );
+    }
+    else if (effectiveType(art)?.elements) {
+      if (art.type)
+        error( 'type-unexpected-structure', [ art.type.location, art ], { '#': 'calc' } );
+      else
+        error( 'ref-unexpected-structured', [ art.value.location, art ], { '#': 'expr' } );
+    }
+    else {
+      const noTruthyAllowed = [ 'localized', 'key', 'virtual' ];
+      for (const prop of noTruthyAllowed) {
+        if (art[prop]?.val) {
+          // probably better than a parse error (which is good for DEFAULT vs calc),
+          // also appears with parse-cdl:
+          error('def-invalid-calc-elem', loc, { '#': prop });
+          return; // one error is enough
+        }
+      }
+    }
+  }
+
+  function checkStructureCast( art ) {
+    const elem = (art.value.op?.val === 'cast')
+      ? art.value.args[0]?._artifact
+      : art.value._artifact;
+    if (elem && art.type) { // has explicit type
+      if (art.type._artifact?.elements) {
+        error('type-cast-to-structured', [ art.type.location, art ], {},
+              'Can\'t cast to structured element');
+      }
+      else if (elem.elements) { // TODO: calc elements
+        error('type-cast-structured', [ art.type.location, art ], {},
+              'Structured elements can\'t be cast to a different type');
+      }
+    }
+  }
+
   // Return type containing the assoc spec (keys, on); note that no
   // propagation/rewrite has been done yet, cyclic dependency must have been
   // checked before!
   function getAssocSpec( type ) {
-    const cyclic = new Set(); // TODO(#8942): May not be necessary if effectiveType() is adapted.
     // only to be called without cycles
-    while (type && !cyclic.has(type)) {
-      cyclic.add(type);
-      if (type.on || type.foreignKeys || type.targetAspect)
+    let unmanaged = null;
+    while (type) {
+      if (type.on)              // if unmanaged, continue trying to find targetAspect
+        unmanaged = type;
+      else if (type.foreignKeys || type.targetAspect)
         return type;
-      type = directType( type );
+      type = getOrigin( type );
     }
-    return null;
+    return unmanaged;
   }
 
-  function inferTypeFromCast( elem ) {
-    // TODO: think about CAST checks in checks.js
-    const { op, type } = elem.value;
-    if (op && op.val === 'cast' && type && type._artifact) {
-      // op.val is also correctly set with CSN input
-      elem.type = { ...type, $inferred: 'cast' };
-      setArtifactLink( elem.type, type._artifact );
-      for (const prop of typeParameters.list) {
-        if (elem.value[prop])
-          elem[prop] = { ...elem.value[prop], $inferred: 'cast' };
-      }
+  function inferTypePropertiesFromCast( elem ) {
+    for (const prop of typeParameters.list) {
+      if (elem.value[prop])
+        elem[prop] = { ...elem.value[prop], $inferred: 'cast' };
     }
   }
 
   // Phase 4 - annotations ---------------------------------------------------
+  // Some functions remain here for the moment, as resolve functionality is called
+  // from annotate functions, which should not be the case (TODO!)
 
   function annotateUnknown( ext ) {
     // extensions may have annotations for elements/actions/... which may
@@ -577,16 +658,10 @@ function resolve( model ) {
       }
     }
     if (art?._annotate) {
-      if (art.kind === 'action' || art.kind === 'function') {
-        expandParameters( art );
-        if (art.returns)
-          effectiveType( art.returns );
-      }
       const aor = art.returns || art;
       const obj = aor.items || aor.targetAspect || aor;
       // Currently(?), effectiveType() does not calculate the effective type of
       // its line item:
-      effectiveType( obj );
       if (art._annotate.elements) // explicit $expand on aor needed
         setExpandStatusAnnotate( aor, 'annotate' );
       annotate( obj, 'element', 'elements', 'enum', art );
@@ -628,259 +703,13 @@ function resolve( model ) {
     }
   }
 
-  function expandParameters( action ) {
-    // see also expandElements()
-    if (!effectiveType( action ))
-      return;
-    const chain = [];
-    // Should we be able to consider params and returns separately?
-    // Probably not, let to-csn omit unchanged params/returns.
-    while (action._origin && !action.params) {
-      chain.push( action );
-      action = action._origin;
-    }
-    chain.reverse();
-    for (const art of chain) {
-      const origin = art._origin;
-      if (!art.params && origin.params) {
-        for (const name in origin.params) {
-          // TODO: we could check _annotate here to decide whether we really
-          // not to create proxies
-          const orig = origin.params[name];
-          linkToOrigin( orig, name, art, 'params', weakLocation( orig.location ), true )
-            .$inferred = 'expanded';
-        }
-      }
-      if (!art.returns && origin.returns) {
-        // TODO: make linkToOrigin() work for returns, kind/name?
-        const location = weakLocation( origin.returns.location );
-        art.returns = {
-          name: Object.assign( {}, art.name, { id: '', param: '', location } ),
-          kind: 'param',
-          location,
-          $inferred: 'expanded',
-        };
-        setLink( art.returns, '_parent', art );
-        setLink( art.returns, '_main', art._main || art );
-        setLink( art.returns, '_origin', origin.returns );
-      }
-    }
-  }
-
-  function extensionFor( art ) {
-    if (art.kind === 'annotate')
-      return art;
-    if (art._extension)
-      return art._extension;
-
-    // $extension means: already applied
-    const ext = {
-      kind: art.kind,           // set kind for setMemberParent()
-      $extension: 'exists',
-      location: art.location,    // location( extension to existing art ) = location(art)
-    };
-    const { location } = art.name;
-    if (!art._main) {
-      ext.name = {
-        path: [ { id: art.name.absolute, location } ],
-        location,
-        absolute: art.name.absolute,
-      };
-      if (model.extensions)
-        model.extensions.push(ext);
-      else
-        model.extensions = [ ext ];
-    }
-    else {
-      ext.name = { id: art.name.id, location };
-      const parent = extensionFor( art._parent );
-      const kind = kindProperties[art.kind].normalized || art.kind;
-      // enums would be first in elements
-      if ( parent[kindProperties[kind].dict] &&
-           parent[kindProperties[kind].dict][art.name.id] )
-        throw new CompilerAssertion(art.name.id);
-      setMemberParent( ext, art.name.id, parent, kindProperties[kind].dict );
-    }
-    ext.kind = 'annotate';    // after setMemberParent()!
-    setLink( art, '_extension', ext );
-    setArtifactLink( ext.name, art );
-    if (art.returns)
-      ext.$syntax = 'returns';
-    return ext;
-  }
-
-  /**
-   * Goes through all (applied) annotations in the given artifact and chooses one
-   * if multiple exist according to the module layer.
-   *
-   * @param {XSN.Artifact} art
-   */
-  function chooseAnnotationsInArtifact( art ) {
-    for (const prop in art) {
-      if (prop.charAt(0) === '@')
-        chooseAssignment( prop, art );
-    }
-    if (art.doc)
-      chooseAssignment( 'doc', art );
-  }
-
-  function chooseAssignment( annoName, art ) {
-    let anno = art[annoName];
-    if (!Array.isArray( anno )) { // just one assignment -> use it
-      if (!annotationHasEllipsis( anno ))
-        return;
-      anno = [ anno ];
-    }
-    // console.log('ASSIGN:',art.name.absolute,annoName)
-    const scheduledAssignments = [];
-    // sort assignment according to layer (define is bottom layer):
-    const layeredAnnos = layeredAssignments( anno );
-    let cont = true;
-    while (cont) {
-      const { assignments, issue } = assignmentsOfHighestLayers( layeredAnnos );
-      let index = assignments.length;
-      cont = !!index;           // safety
-      while (--index >= 0) {
-        const a = assignments[index];
-        scheduledAssignments.push( a );
-        if (!annotationHasEllipsis( a )) {
-          cont = false;
-          break;
-        }
-      }
-      if (issue) {
-        // eslint-disable-next-line no-nested-ternary
-        const msg = (issue === true)
-          ? 'anno-duplicate'
-          : (index >= 0) ? 'anno-duplicate-unrelated-layer' : 'anno-unstable-array';
-        const variant = annoName === 'doc' ? 'doc' : 'std';
-        for (const a of assignments) {
-          if (!a.$errorReported) {
-            message( msg, [ a.name?.location || a.location, art ],
-                     { '#': variant, anno: annoName } );
-          }
-        }
-      }
-      // else if (index > 0)  -- if we allow multiple assignments in one file - the last wins
-    }
-    // Now apply the assignments - all but the first have a '...'
-    let result = null;
-    scheduledAssignments.reverse();
-    for (const a of scheduledAssignments)
-      result = applyAssignment( result, a, art, annoName );
-    art[annoName] = result.name ? result
-      : Object.assign( {}, scheduledAssignments[scheduledAssignments.length - 1], result );
-  }
-
-  function applyAssignment( previousAnno, anno, art, annoName ) {
-    const hasBase = previousAnno?.literal === 'array';
-    if (!previousAnno) {
-      const firstEllipsis = annotationHasEllipsis( anno );
-      if (!firstEllipsis)
-        return anno;
-      if (anno.$priority) {   // already complained about with Define
-        const loc = firstEllipsis.location || anno.name.location;
-        message( 'anno-unexpected-ellipsis-layers', [ loc, art ], { code: '...' } );
-      }
-      previousAnno = { val: [] };
-    }
-    else if (previousAnno.literal !== 'array') {
-      // TODO: If we introduce sub-messages, point to the non-array base value.
-      error( 'anno-mismatched-ellipsis', [ anno.name.location, art ], { code: '...' } );
-      previousAnno = { val: [] };
-    }
-    const previousValue = previousAnno.val;
-    let prevPos = 0;
-    const result = [];
-    for (const item of anno.val) {
-      const ell = item && item.literal === 'token' && item.val === '...';
-      if (!ell) {
-        result.push( item );
-      }
-      else {
-        let upToSpec = item.upTo && checkUpToSpec( item.upTo, art, annoName, true );
-        while (prevPos < previousValue.length) {
-          const prevItem = previousValue[prevPos++];
-          result.push( prevItem );
-          if (upToSpec && prevItem && equalUpTo( prevItem, item.upTo)) {
-            upToSpec = false;
-            break;
-          }
-        }
-        if (upToSpec && hasBase) {
-          // non-matched UP TO; if there is no base to apply to, there is already an error.
-          warning( null, [ item.upTo.location, art ], { anno: annoName, code: '... up to' },
-                   'The $(CODE) value does not match any item in the base annotation $(ANNO)' );
-        }
-      }
-    }
-    // console.log('TP:',previousValue.map(se),anno.val.map(se),'->',result.map(se))
-    return { val: result, literal: 'array' };
-  }
-  // function se(a) { return a.upTo ? [a.val,a.upTo.val] : a.val ; }
-
-  function checkUpToSpec( upToSpec, art, annoName, isFullUpTo ) {
-    const { literal } = upToSpec;
-    if (!isFullUpTo) {          // inside struct of UP TO
-      if (literal !== 'struct' && literal !== 'array' )
-        return true;
-    }
-    else if (literal === 'struct') {
-      return Object.values( upToSpec.struct ).every( v => checkUpToSpec( v, art, annoName ) );
-    }
-    else if (literal !== 'array' && literal !== 'boolean' && literal !== 'null') {
-      return true;
-    }
-    error( null, [ upToSpec.location, art ],
-           { anno: annoName, code: '... up to', '#': literal },
-           {
-             std: 'Unexpected $(CODE) value type in the assignment of $(ANNO)',
-             array: 'Unexpected array as $(CODE) value in the assignment of $(ANNO)',
-             // eslint-disable-next-line max-len
-             struct: 'Unexpected structure as $(CODE) structure property value in the assignment of $(ANNO)',
-             boolean: 'Unexpected boolean as $(CODE) value in the assignment of $(ANNO)',
-             null: 'Unexpected null as $(CODE) value in the assignment of $(ANNO)',
-           } );
-    return false;
-  }
-
-  function equalUpTo( previousItem, upToSpec ) {
-    if (!previousItem)
-      return false;
-    if ('val' in upToSpec) {
-      if (previousItem.val === upToSpec.val) // enum, struct and ref have no val
-        return true;
-      const typeUpTo = typeof upToSpec.val;
-      const typePrev = typeof previousItem.val;
-      if (typeUpTo === 'number')
-        return typePrev === 'string' && previousItem.val === upToSpec.val.toString();
-      if (typePrev === 'number')
-        return typeUpTo === 'string' && upToSpec.val === previousItem.val.toString();
-    }
-    else if (upToSpec.path) {
-      return previousItem.path && normalizeRef( previousItem ) === normalizeRef( upToSpec );
-    }
-    else if (upToSpec.sym) {
-      return previousItem.sym && previousItem.sym.id === upToSpec.sym.id;
-    }
-    else if (upToSpec.struct && previousItem.struct) {
-      return Object.entries( upToSpec.struct )
-        .every( ([ n, v ]) => equalUpTo( previousItem.struct[n], v ) );
-    }
-    return false;
-  }
-
-  function normalizeRef( node ) { // see to-csn.js
-    const ref = pathName( node.path );
-    return node.variant ? `${ ref }#${ node.variant.id }` : ref;
-  }
-
   // Phase 4 - queries and associations --------------------------------------
 
   function resolveQuery( query ) {
-    if (!query._main)           // parse error
+    if (!query._main || !query._effectiveType) // parse error
       return;
-    traverseQueryPost( query, null, populateQuery ); // TODO: still necessary?
+    // TODO: or set silent dependencies in init?
+    forEachGeneric( query, 'elements', elem => dependsOnSilent( query, elem ) );
     forEachGeneric( query, '$tableAliases', ( alias ) => {
       // console.log( info( null, [alias.location,alias], 'SQA:' ).toString() );
       if (alias.kind === 'mixin')
@@ -889,6 +718,7 @@ function resolve( model ) {
         // pure path has been resolved, resolve args and filter now:
         resolveExpr( alias, 'from', query._parent );
     } );
+    // if (!query.$inlines) console.log('RQ:',query)
     for (const col of query.$inlines)
       resolveExpr( col.value, 'expr', col, undefined, true );
     // for (const col of query.$inlines)
@@ -1002,13 +832,9 @@ function resolve( model ) {
       return; // avoid subsequent errors
     }
     else if (target && !obj.foreignKeys && target.kind === 'entity') {
-      if (obj.$inferred === 'REDIRECTED') {
-        addImplicitForeignKeys( art, obj, target );
-      }
-      else if (obj.type && obj.type._artifact && obj.type._artifact.internal) {
-        // cds.Association, ...
+      // redirected or explicit type cds.Association, ...
+      if (obj.$inferred === 'REDIRECTED' || obj.type?._artifact?.internal)
         addImplicitForeignKeys( art, obj, target );
-      }
     }
 
     if (target && !target.$inferred) {
@@ -1072,8 +898,10 @@ function resolve( model ) {
   // TODO: add this somehow to tweak-assocs.js ?
   function resolveRedirected( elem, target ) {
     setLink( elem, '_redirected', null ); // null = do not touch path steps after assoc
-    const assoc = directType( elem );
+    const assoc = getOrigin( elem );
     const origType = assoc && effectiveType( assoc );
+    if (origType === 0)
+      return;
     if (!origType || !origType.target) {
       const path = (elem.value && elem.value.path);
       const loc = (path && path[path.length - 1] || elem.value || elem).location;
@@ -1240,11 +1068,12 @@ function resolve( model ) {
     //       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.
+    // TODO: this is wrong - we must check typeArt.enum, not its effectiveType
     const cyclic = new Set();
     let effectiveTypeArt = effectiveType( typeArt );
     while (effectiveTypeArt && effectiveTypeArt.enum && !cyclic.has(effectiveTypeArt)) {
       cyclic.add(effectiveTypeArt);
-      const underlyingEnumType = directType(effectiveTypeArt);
+      const underlyingEnumType = getOrigin(effectiveTypeArt);
       if (underlyingEnumType)
         effectiveTypeArt = effectiveType(underlyingEnumType);
       else
@@ -1261,7 +1090,7 @@ function resolve( model ) {
       if (artWithType[param] !== undefined) {
         if (!params.includes(param)) {
           // Whether the type ref itself is a builtin or a custom type with a builtin as base.
-          const type = directType(artWithType);
+          const type = getOrigin(artWithType);
 
           let variant;
           if (type.builtin)
@@ -1274,6 +1103,7 @@ function resolve( model ) {
             // effectiveType is not a builtin -> array or structured
             variant = 'non-scalar';
 
+          // console.log(typeArt.name,artWithType.name,effectiveTypeArt.name)
           error('type-unexpected-argument', [ artWithType[param].location, artWithType ], {
             '#': variant, prop: param, art: artWithType.type, type: effectiveTypeArt,
           });