@sap/cds-compiler 2.13.8 → 3.0.0

package/lib/compiler/resolve.js

@@ -49,12 +49,13 @@ const { dictAdd } = require('../base/dictionaries');
 const { dictLocation } = require('../base/location');
 const { searchName, weakLocation } = require('../base/messages');
 const { combinedLocation } = require('../base/location');
-const { forEachValue } = require('../utils/objectUtils');
+const { typeParameters } = require('./builtins');
 
 const { kindProperties } = require('./base');
 const {
   setLink,
   setArtifactLink,
+  annotationHasEllipsis,
   pathName,
   linkToOrigin,
   setMemberParent,
@@ -72,9 +73,6 @@ const layers = require('./moduleLayers');
 
 const $location = Symbol.for('cds.$location');
 
-const annotationPriorities = {
-  define: 1, extend: 2, annotate: 2, edmx: 3,
-};
 const $inferred = Symbol.for('cds.$inferred');
 
 // Export function of this file.  Resolve type references in augmented CSN
@@ -89,13 +87,13 @@ function resolve( model ) {
   } = model.$messageFunctions;
   const {
     resolvePath,
-    resolveTypeArguments,
     defineAnnotations,
     attachAndEmitValidNames,
     lateExtensions,
     effectiveType,
     directType,
     resolveType,
+    resolveTypeArgumentsUnchecked,
     populateQuery,
   } = model.$functions;
   const { environment } = model.$volatileFunctions;
@@ -106,7 +104,7 @@ function resolve( model ) {
   /** @type {any} may also be a boolean */
 
   // behavior depending on option `deprecated`:
-  const enableExpandElements = !isDeprecatedEnabled( options, 'noElementsExpansion' );
+  const enableExpandElements = !isDeprecatedEnabled( options, '_noElementsExpansion' );
   // TODO: we should get rid of noElementsExpansion soon; both
   // beta.nestedProjections and beta.universalCsn do not work with it.
 
@@ -210,9 +208,9 @@ function resolve( model ) {
       info( 'query-from-many', [ toMany.location, query ], { art: toMany },
             {
               // eslint-disable-next-line max-len
-              std: 'Selecting from to-many association $(ART) - key properties are not propagated',
+              std: 'Key properties are not propagated because a to-many association $(ART) is selected',
               // eslint-disable-next-line max-len
-              element: 'Selecting from to-many association $(MEMBER) of $(ART) - key properties are not propagated',
+              element: 'Key properties are not propagated because a to-many association $(MEMBER) of $(ART) is selected',
             } );
     }
     // Check that all keys from the source are projected:
@@ -371,8 +369,8 @@ function resolve( model ) {
       // console.log(obj.name,obj._origin.name)
       if (obj._origin && obj._origin.$inferred === 'REDIRECTED')
         resolveTarget( art, obj._origin );
-      // console.log(message( null, obj.location, obj, {target:obj.target}, 'Info','TARGET')
-      //             .toString(), obj.target.$inferred)
+      // console.log(error( 'test-target', [ obj.location, obj ],
+      //   { target: obj.target, kind: obj.kind }, 'Target: $(TARGET), Kind $(KIND)'));
       if (!obj.target.$inferred || obj.target.$inferred === 'aspect-composition')
         resolveTarget( art, obj );
       else
@@ -448,8 +446,10 @@ function resolve( model ) {
   // 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) {
+    while (type && !cyclic.has(type)) {
+      cyclic.add(type);
       if (type.on || type.foreignKeys || type.targetAspect)
         return type;
       type = directType( type );
@@ -464,7 +464,7 @@ function resolve( model ) {
       // op.val is also correctly set with CSN input
       elem.type = { ...type, $inferred: 'cast' };
       setArtifactLink( elem.type, type._artifact );
-      for (const prop of [ 'length', 'precision', 'scale', 'srid' ]) {
+      for (const prop of typeParameters.list) {
         if (elem.value[prop])
           elem[prop] = { ...elem.value[prop], $inferred: 'cast' };
       }
@@ -711,241 +711,219 @@ function resolve( model ) {
   }
 
   function chooseAssignment( annoName, art ) {
-    // TODO: getPath an all names
-    const anno = art[annoName];
-    if (!Array.isArray(anno)) { // just one assignment -> use it
-      if (removeEllipsis( anno )) {
-        error( 'anno-unexpected-ellipsis',
-               [ anno.name.location, art ], { code: '...' } );
+    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;
+        }
       }
-      return;
-    }
-    // sort assignment according to layer
-    const layerAnnos = Object.create(null);
-    for (const a of anno) {
-      const layer = layers.layer( a._block );
+      if (issue) {
+        // eslint-disable-next-line no-nested-ternary
+        const msg = (issue === true)
+          ? 'anno-duplicate'
+          : (index >= 0) ? 'anno-duplicate-unrelated-layer' : 'anno-unstable-array';
+        for (const a of assignments) {
+          if (!a.$errorReported)
+            message( msg, [ a.name.location, art ], { 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 );
+  }
+
+  // Group assignments by their layers.  An assignment provided with a definition
+  // is considered to be provided in a layer named '', the lowest layer.
+  // TODO: make this usable for extend (elements), too =
+  // do not use $priority, make assignments on define do not have own _block
+  function layeredAssignments( assignment ) {
+    const layered = Object.create(null);
+    for (const a of assignment) {
+      const layer = a.$priority && layers.layer( a );
+      // just consider layer if Extend/Annotate, not Define
       const name = (layer) ? layer.realname : '';
-      const done = layerAnnos[name];
+      const done = layered[name];
       if (done)
-        done.annos.push( a );
+        done.assignments.push( a );
       else
-        layerAnnos[name] = { layer, annos: [ a ] };
+        layered[name] = { name, layer, assignments: [ a ] };
+      // TODO: file - if set: unique in layer
     }
-    mergeArrayInSCCs();
-    art[annoName] = mergeLayeredArrays( findLayerCandidate( ) );
-    return;
+    return layered;
+  }
 
-    // Merge annotations in each layer, i.e. multiple annotations in the same layer are
-    // stored in an array and need to be merged before different layers can be merged.
-    function mergeArrayInSCCs( ) {
-      let pos = 0;
-      forEachValue(layerAnnos, (layer) => {
-        const mergeSource = layer.annos.find(v => (v.$priority === undefined ||
-           annotationPriorities[v.$priority] === annotationPriorities.define));
-        if (mergeSource) {
-          // If the source annotation (at 'define' level) contains an ellipsis,
-          // there is no base to apply to.
-          if (removeEllipsis( mergeSource )) {
-            error( 'anno-unexpected-ellipsis',
-                   [ mergeSource.name.location, art ], { code: '...' } );
-          }
-          // merge source into ellipsis array annotates
-          layer.annos.forEach( (mergeTarget) => {
-            if (mergeTarget.$priority &&
-                annotationPriorities[mergeTarget.$priority] > annotationPriorities.define) {
-              pos = findEllipsis( mergeTarget );
-              if (pos > -1) {
-                if (mergeSource.literal !== 'array') {
-                  error( 'anno-mismatched-ellipsis',
-                         [ mergeSource.name.location, art ], { code: '...' } );
-                  return;
-                }
-                mergeTarget.val = mergeArrayValues( mergeSource.val, mergeTarget.val );
-              }
-            }
-          });
-        }
-      });
-    }
-
-    function mergeLayeredArrays( mergeTarget ) {
-      if (mergeTarget.literal === 'array') {
-        let layer = layers.layer( mergeTarget._block );
-        delete layerAnnos[(layer) ? layer.realname : ''];
-        let pos = findEllipsis( mergeTarget );
-        let hasRun = false;
-        while (pos > -1 && Object.keys( layerAnnos ).length ) {
-          hasRun = true;
-          const mergeSource = findLayerCandidate();
-          if (mergeSource.literal !== 'array') {
-            error( 'anno-mismatched-ellipsis',
-                   [ mergeSource.name.location, art ], { code: '...' } );
-            return mergeTarget;
-          }
-          mergeTarget.val = mergeArrayValues( mergeSource.val, mergeTarget.val );
-          layer = layers.layer( mergeSource._block );
-          delete layerAnnos[(layer) ? layer.realname : ''];
-          pos = findEllipsis( mergeTarget );
-        }
-        // All layers were processed. Remove excess ellipsis.
-        if (removeEllipsis( mergeTarget, pos ) && hasRun) {
-          // There shouldn't be any ellipsis or we don't have a base annotation.
-          // But only if the loop above has run. Otherwise the in-layer merge
-          // already warned about this case.
-          message( 'anno-unexpected-ellipsis-layers',
-                   [ mergeTarget.name.location, art ], { code: '...' } );
-        }
+  // Return assignments of the highest layers.
+  // Also return whether there could be an issue:
+  // - false: there is just one assignment
+  // - 'unrelated': there is just one assignment per layer
+  // - true: there is at least one layer with two or more assignments
+  // TODO: make this usable for extend (elements), too
+  function assignmentsOfHighestLayers( layeredAnnos ) {
+    const layerNames = Object.keys( layeredAnnos );
+    // console.log('HIB:',layerNames)
+    if (layerNames.length <= 1) {
+      const name = layerNames[0];
+      const { assignments } = layeredAnnos[name] || { assignments: [] };
+      delete layeredAnnos[name];
+      return { assignments, issue: assignments.length > 1 };
+    }
+
+    // collect all layers which are lower than another layer
+    const allExtends = Object.create(null);
+    allExtends[''] = {};        // the "Define" layer
+    for (const name of layerNames) {
+      if (name)                 // not the "Define" layer
+        Object.assign( allExtends, layeredAnnos[name].layer._layerExtends );
+    }
+    // console.log('HIE:',Object.keys(allExtends))
+    const assignments = [];
+    const highest = [];
+    for (const name of layerNames) {
+      if (!(name in allExtends)) {
+        const layer = layeredAnnos[name];
+        delete layeredAnnos[name];
+        highest.push( layer );
+        assignments.push( ...layer.assignments );
       }
-      return mergeTarget;
     }
+    assignments.sort( compareAssignments );
+    const good = highest.every( layer => layer.assignments.length === 1 );
+    // TODO: use layer.file instead
+    const issue = !good || highest.length > 1 && 'unrelated';
+    // console.log('HI:',highest.map(l=>l.name),issue,issue&&assignments)
+    return { assignments, issue };
+  }
 
-    function mergeArrayValues( previousValue, arraySpec ) {
-      let prevPos = 0;
-      const result = [];
-      for (const item of arraySpec) {
-        const ell = item && item.literal === 'token' && item.val === '...';
-        if (!ell) {
-          result.push( item );
-        }
-        else {
-          let upToSpec = item.upTo && checkUpToSpec( item.upTo, true );
-          while (prevPos < previousValue.length) {
-            const prevItem = previousValue[prevPos++];
-            result.push( prevItem );
-            if (upToSpec && prevItem && equalUpTo( prevItem, item.upTo)) {
-              upToSpec = false;
-              break;
-            }
-          }
-          if (upToSpec) {       // non-matched UP TO
-            warning( null, [ item.upTo.location, art ], { anno: annoName, code: '... up to' },
-                     'The $(CODE) value does not match any item in the base annotation $(ANNO)' );
+  function compareAssignments( a, b ) {
+    const fileA = layers.realname( a._block );
+    const fileB = layers.realname( b._block );
+    if (fileA !== fileB)
+      return (fileA > fileB) ? 1 : -1;
+    return (a?.location?.line || 0) - (b?.location?.line || 0) ||
+           (a?.location?.col || 0) - (b?.location?.col || 0);
+  }
+
+  function applyAssignment( previousAnno, anno, art, annoName ) {
+    if (!previousAnno) {
+      if (!annotationHasEllipsis( anno ))
+        return anno;
+      if (anno.$priority) {   // already complained about with Define
+        message( 'anno-unexpected-ellipsis-layers', // TODO: better location
+                 [ anno.name.location, art ], { code: '...' } );
+      }
+      previousAnno = { val: [] };
+    }
+    else if (previousAnno.literal !== 'array') {
+      error( 'anno-mismatched-ellipsis', // TODO: better location
+             [ 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) {       // non-matched UP TO
+          warning( null, [ item.upTo.location, art ], { anno: annoName, code: '... up to' },
+                   'The $(CODE) value does not match any item in the base annotation $(ANNO)' );
+        }
       }
-      return result;
     }
+    // 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, trueIfFullUpTo ) {
-      const { literal } = upToSpec;
-      if (trueIfFullUpTo !== true) { // inside struct of UP TO
-        if (literal !== 'struct' && literal !== 'array' )
-          return true;
-      }
-      else if (literal === 'struct') {
-        return Object.values( upToSpec.struct ).every( checkUpToSpec );
-      }
-      else if (literal !== 'array' && literal !== 'boolean' && literal !== 'null') {
+  function checkUpToSpec( upToSpec, art, annoName, isFullUpTo ) {
+    const { literal } = upToSpec;
+    if (!isFullUpTo) {          // inside struct of UP TO
+      if (literal !== 'struct' && literal !== 'array' )
         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;
     }
+    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 ) );
-      }
+  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();
     }
-
-    function normalizeRef( node ) { // see to-csn.js
-      const ref = pathName( node.path );
-      return node.variant ? `${ ref }#${ node.variant.id }` : ref;
-    }
-
-    function removeEllipsis(a, pos = findEllipsis( a )) {
-      let count = 0;
-      while (a.literal === 'array' && pos > -1) {
-        count++;
-        a.val.splice(pos, 1);
-        pos = findEllipsis( a );
-      }
-      return count;
-    }
-
-    function findEllipsis(a) {
-      return (a.literal === 'array' && a.val)
-        ? a.val.findIndex(v => v.literal === 'token' && v.val === '...') : -1;
+    else if (upToSpec.path) {
+      return previousItem.path && normalizeRef( previousItem ) === normalizeRef( upToSpec );
     }
-
-    function findLayerCandidate() {
-      // collect assignments of upper layers (are in no _layerExtends)
-      const exts = Object.keys( layerAnnos ).map( layerExtends );
-      const allExtends = Object.assign( Object.create(null), ...exts );
-      const collected = [];
-      for (const name in layerAnnos) {
-        if (!(name in allExtends))
-          collected.push( prioritizedAnnos( layerAnnos[name].annos ) );
-      }
-      // inspect collected assignments - choose the one or signal error
-      const justOnePerLayer = collected.every( annos => annos.length === 1);
-      if (!justOnePerLayer || collected.length > 1) {
-        for (const annos of collected) {
-          for (const a of annos ) {
-          // Only the message ID is different.
-            if (justOnePerLayer) {
-              message( 'anno-duplicate-unrelated-layer',
-                       [ a.name.location, art ], { anno: annoName },
-                       'Duplicate assignment with $(ANNO)' );
-            }
-            else {
-              message( 'anno-duplicate', [ a.name.location, art ], { anno: annoName } );
-            }
-          }
-        }
-      }
-      return collected[0][0];  // just choose any one with error
+    else if (upToSpec.sym) {
+      return previousItem.sym && previousItem.sym.id === upToSpec.sym.id;
     }
-
-    function layerExtends( name ) {
-      const { layer } = layerAnnos[name];
-      return layer && layer._layerExtends;
+    else if (upToSpec.struct && previousItem.struct) {
+      return Object.entries( upToSpec.struct )
+        .every( ([ n, v ]) => equalUpTo( previousItem.struct[n], v ) );
     }
+    return false;
   }
 
-  function prioritizedAnnos( annos ) {
-    let prio = 0;
-    let r = [];
-    for (const a of annos) {
-      const p = annotationPriorities[a.$priority] || annotationPriorities.define;
-      if (p === prio) {
-        r.push(a);
-      }
-      else if (p > prio) {
-        r = [ a ];
-        prio = p;
-      }
-    }
-    return r;
+  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 --------------------------------------
@@ -1026,6 +1004,15 @@ function resolve( model ) {
       return;
     }
     const target = resolvePath( obj.target, 'target', art );
+
+    if (obj._pathHead && obj.type && !obj.type.$inferred && art._main && art._main.query) {
+      // New association inside expand/inline: The on-condition can't be properly checked,
+      // so abort early. See #8797
+      error( 'query-unexpected-assoc', [ obj.name.location, art ], {},
+             'Unexpected new association in expand/inline' );
+      return; // avoid subsequent errors
+    }
+
     if (obj.on) {
       if (!art._main || !art._parent.elements && !art._parent.items && !art._parent.targetAspect) {
         // TODO: test of .items a bit unclear - we should somehow restrict the
@@ -1057,20 +1044,29 @@ function resolve( model ) {
     else if (art.kind === 'mixin') {
       error( 'assoc-in-mixin', [ obj.target.location, art ], {},
              'Managed associations are not allowed for MIXIN elements' );
+      return; // avoid subsequent errors
+    }
+    else if (obj.type && !obj.type.$inferred && art._parent && art._parent.kind === 'select') {
+      // New association in views, i.e. parent is a query.
+      error( 'query-expected-on-condition', [ obj.target.location, art ], {},
+             'Expected on-condition for published association' );
+      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.$inferred || obj.target.$inferred) { // REDIRECTED
-        resolveRedirected( art, target );
-      }
-      else if (obj.type._artifact && obj.type._artifact.internal) { // cds.Association, ...
+      else if (obj.type && obj.type._artifact && obj.type._artifact.internal) {
+        // cds.Association, ...
         addImplicitForeignKeys( art, obj, target );
       }
-      // else console.log( message( null,obj.location,obj, {target}, 'Info','NOTARGET').toString())
     }
-    // else console.log( message( null, obj.location, obj, {target}, 'Info','NORE').toString())
+
+    if (target && !target.$inferred) {
+      if (!obj.type || obj.type.$inferred || obj.target.$inferred) { // REDIRECTED
+        resolveRedirected( art, target );
+      }
+    }
   }
 
   function addImplicitForeignKeys( art, obj, target ) {
@@ -1130,7 +1126,9 @@ function resolve( model ) {
     const assoc = directType( elem );
     const origType = assoc && effectiveType( assoc );
     if (!origType || !origType.target) {
-      error( 'redirected-no-assoc', [ elem.target.location, elem ], {},
+      const path = (elem.value && elem.value.path);
+      const loc = (path && path[path.length - 1] || elem.value || elem).location;
+      error( 'redirected-no-assoc', [ loc, elem ], {},
              'Only an association can be redirected' );
       return;
     }
@@ -1138,7 +1136,7 @@ function resolve( model ) {
     //             .toString(), elem.value)
     const nav = elem._main && elem._main.query && elem.value && pathNavigation( elem.value );
     if (nav && nav.item !== elem.value.path[elem.value.path.length - 1]) {
-      if (origType.on) {
+      if (!elem.on && origType.on) {
         error( 'rewrite-not-supported', [ elem.target.location, elem ], {},
                // TODO: Better text ?
                'The ON condition is not rewritten here - provide an explicit ON condition' );
@@ -1151,7 +1149,9 @@ function resolve( model ) {
 
     const chain = [];
     if (target === origTarget) {
-      if (!elem.target.$inferred) {
+      if (!elem.target.$inferred && !elem.on && !elem.foreignKeys) {
+        // Only a managed redirection gets this info message.  Because otherwise
+        // we'd have to check whether on-condition/foreignKeys are the same.
         info( 'redirected-to-same', [ elem.target.location, elem ], { art: target },
               'The redirected target is the original $(ART)' );
       }
@@ -1265,8 +1265,71 @@ function resolve( model ) {
   // Resolve the type and its arguments if applicable.
   function resolveTypeExpr( art, user ) {
     const typeArt = resolveType( art.type, user );
-    if (typeArt)
-      resolveTypeArguments( art, typeArt, user );
+    if (typeArt) {
+      resolveTypeArgumentsUnchecked( art, typeArt, user );
+      checkTypeArguments( art );
+    }
+  }
+
+  /**
+   * Check the type arguments on `artWithType`.
+   * If the effective type is an array or structured type, an error is emitted.
+   */
+  function checkTypeArguments( artWithType ) {
+    // 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 );
+    while (effectiveTypeArt && effectiveTypeArt.enum && !cyclic.has(effectiveTypeArt)) {
+      cyclic.add(effectiveTypeArt);
+      const underlyingEnumType = directType(effectiveTypeArt);
+      if (underlyingEnumType)
+        effectiveTypeArt = effectiveType(underlyingEnumType);
+      else
+        break;
+    }
+
+    if (!effectiveTypeArt)
+      return; // e.g. illegal definition references
+
+    const params = effectiveTypeArt.parameters &&
+      effectiveTypeArt.parameters.map(p => p.name || p) || [];
+
+    for (const param of typeParameters.list) {
+      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);
+
+          let variant;
+          if (type.builtin)
+          // `.type` is already a builtin: use a nicer message.
+            variant = 'builtin';
+          else if (effectiveTypeArt.builtin)
+          // base type is a builtin, i.e. a scalar
+            variant = 'type';
+          else
+          // effectiveType is not a builtin -> array or structured
+            variant = 'non-scalar';
+
+          error('type-unexpected-argument', [ artWithType[param].location, artWithType ], {
+            '#': variant, prop: param, art: artWithType.type, type: effectiveTypeArt,
+          });
+          break; // Avoid spam: Only emit the first error.
+        }
+        else if (!typeParameters.expectedLiteralsFor[param].includes(artWithType[param].literal)) {
+          error('type-unexpected-argument', [ artWithType[param].location, artWithType ], {
+            '#': 'incorrect-type',
+            prop: param,
+            code: artWithType[param].literal,
+            names: typeParameters.expectedLiteralsFor[param],
+          });
+          break; // Avoid spam: Only emit the first error.
+        }
+      }
+    }
   }
 
   function resolveExpr( expr, expected, user, extDict, expandOrInline) {