fix: harden type-set dependency targets after review

- Normalize the resolved target set via the shared StripElementTypes, so
  array/by-ref/pointer types in a target selection match their element
  type, mirroring the specific-type overloads (an array target in
  DoesNotDependOn no longer passes silently).
- Report type-set violations deduplicated by type identity and qualify
  distinct violators sharing a simple name with their namespace, so they
  no longer collapse into one indistinguishable entry.
- Validate widening targets fully before mutating the shared options and
  report the actual parameter name of the caller (additional/targets).
- Share the violation-collection core and the framework/own-namespace
  exemption predicate between the namespace-based and type-set-based
  helpers, so the two families cannot drift apart.
- Factor the null-item predicates of the type-set collection constraints
  into static helpers, mirroring the namespace-based siblings.

Author: vbreuss

Source/aweXpect.Reflection/Helpers/TypeHelpers.cs

@@ -788,10 +788,11 @@ internal static bool MatchesType(Type dependency, Type target)
 	///     element type.
 	/// </summary>
 	/// <remarks>
-	///     Shared between dependency unwrapping (<see cref="Unwrap" />) and target matching
-	///     (<see cref="MatchesType" />), so that the two sides of the documented symmetry cannot drift apart.
+	///     Shared between dependency unwrapping (<see cref="Unwrap" />), target matching
+	///     (<see cref="MatchesType" />) and target-set resolution (<see cref="TypeSetDependencyOptions.Resolve" />),
+	///     so that the sides of the documented symmetry cannot drift apart.
 	/// </remarks>
-	private static Type StripElementTypes(Type type)
+	internal static Type StripElementTypes(Type type)
 	{
 		while (type.HasElementType && type.GetElementType() is { } elementType)
 		{
@@ -877,17 +878,12 @@ private static bool IsFrameworkDependency(this Type type, string[] excludedPrefi
 	internal static IReadOnlyList<string> GetDependencyNamespaceViolations(
 		this Type type, NamespaceDependencyOptions allowed)
 	{
-		string? ownNamespace = type.Namespace;
-		string[] excludedPrefixes = Customize.aweXpect.Reflection().ExcludedAssemblyPrefixes.Get();
 		List<string> violations = [];
 		HashSet<string> seen = new(StringComparer.Ordinal);
-		foreach (Type dependency in type.ResolveDependencies())
+		foreach (Type dependency in type.GetDependencyViolations(
+			         (dependency, ownNamespace, excludedPrefixes)
+				         => IsDependencyViolation(dependency, ownNamespace, allowed, excludedPrefixes)))
 		{
-			if (!IsDependencyViolation(dependency, ownNamespace, allowed, excludedPrefixes))
-			{
-				continue;
-			}
-
 			string display = dependency.Namespace ?? GlobalNamespaceDisplay;
 			if (seen.Add(display))
 			{
@@ -908,24 +904,45 @@ internal static IReadOnlyList<string> GetDependencyNamespaceViolations(
 	///     a verdict and not the violation list.
 	/// </remarks>
 	internal static bool HasDependencyNamespaceViolations(this Type type, NamespaceDependencyOptions allowed)
-	{
-		string? ownNamespace = type.Namespace;
-		string[] excludedPrefixes = Customize.aweXpect.Reflection().ExcludedAssemblyPrefixes.Get();
-		return type.ResolveDependencies()
-			.Any(dependency => IsDependencyViolation(dependency, ownNamespace, allowed, excludedPrefixes));
-	}
+		=> type.GetDependencyViolations(
+			(dependency, ownNamespace, excludedPrefixes)
+				=> IsDependencyViolation(dependency, ownNamespace, allowed, excludedPrefixes)).Any();
 
 	private static bool IsDependencyViolation(
 		Type dependency, string? ownNamespace, NamespaceDependencyOptions allowed, string[] excludedPrefixes)
-	{
-		if (dependency.IsFrameworkDependency(excludedPrefixes))
-		{
-			return false;
-		}
+		=> !IsExemptDependency(dependency, ownNamespace, allowed.IncludeOwnSubNamespaces, excludedPrefixes) &&
+		   !allowed.Matches(dependency.Namespace);
+
+	/// <summary>
+	///     Checks the exemptions shared by all only-on rules: framework dependencies and dependencies in the
+	///     type's own namespace are always allowed.
+	/// </summary>
+	/// <remarks>
+	///     Shared between the namespace-based and type-set-based violation predicates, so that a future rule
+	///     change cannot be applied to one family and missed in the other.
+	/// </remarks>
+	private static bool IsExemptDependency(
+		Type dependency, string? ownNamespace, bool includeOwnSubNamespaces, string[] excludedPrefixes)
+		=> dependency.IsFrameworkDependency(excludedPrefixes) ||
+		   IsOwnNamespace(dependency.Namespace, ownNamespace, includeOwnSubNamespaces);
 
-		string? dependencyNamespace = dependency.Namespace;
-		return !IsOwnNamespace(dependencyNamespace, ownNamespace, allowed.IncludeOwnSubNamespaces) &&
-		       !allowed.Matches(dependencyNamespace);
+	/// <summary>
+	///     Enumerates the <paramref name="type" />'s dependencies that the <paramref name="isViolation" />
+	///     predicate flags as violations, supplying the type's own namespace and the configured excluded
+	///     assembly prefixes.
+	/// </summary>
+	/// <remarks>
+	///     Shared core of the namespace-based and type-set-based violation helpers, so that the two families
+	///     cannot drift apart in how the dependencies are walked. Lazy, so verdict-only callers stop at the
+	///     first violation.
+	/// </remarks>
+	private static IEnumerable<Type> GetDependencyViolations(
+		this Type type, Func<Type, string?, string[], bool> isViolation)
+	{
+		string? ownNamespace = type.Namespace;
+		string[] excludedPrefixes = Customize.aweXpect.Reflection().ExcludedAssemblyPrefixes.Get();
+		return type.ResolveDependencies()
+			.Where(dependency => isViolation(dependency, ownNamespace, excludedPrefixes));
 	}
 
 	private static bool IsOwnNamespace(string? dependencyNamespace, string? ownNamespace, bool includeSubNamespaces)
@@ -940,26 +957,30 @@ private static bool IsOwnNamespace(string? dependencyNamespace, string? ownNames
 	/// <remarks>
 	///     Same framework and own-namespace rules as <see cref="GetDependencyNamespaceViolations" />, but the allowed
 	///     set is a concrete set of types, so the violations are reported as formatted type names instead of
-	///     namespaces. Requires <see cref="TypeSetDependencyOptions.Resolve" /> to have been awaited before.
+	///     namespaces. Distinct violators sharing a formatted name (the same simple name in different namespaces)
+	///     are qualified by their namespace, so they do not collapse into one indistinguishable entry.
+	///     Requires <see cref="TypeSetDependencyOptions.Resolve" /> to have been awaited before.
 	/// </remarks>
 	internal static IReadOnlyList<string> GetDependencyTypeSetViolations(
 		this Type type, TypeSetDependencyOptions allowed)
 	{
-		string? ownNamespace = type.Namespace;
-		string[] excludedPrefixes = Customize.aweXpect.Reflection().ExcludedAssemblyPrefixes.Get();
 		List<string> violations = [];
-		HashSet<string> seen = new(StringComparer.Ordinal);
-		foreach (Type dependency in type.ResolveDependencies())
-		{
-			if (!IsDependencyTypeSetViolation(dependency, ownNamespace, allowed, excludedPrefixes))
+		foreach (IGrouping<string, Type> sameName in type.GetDependencyViolations(
+				         (dependency, ownNamespace, excludedPrefixes)
+					         => IsDependencyTypeSetViolation(dependency, ownNamespace, allowed, excludedPrefixes))
+			         .Distinct()
+			         .GroupBy(dependency => Formatter.Format(dependency), StringComparer.Ordinal))
+		{
+			Type[] violators = sameName.ToArray();
+			if (violators.Length == 1)
 			{
-				continue;
+				violations.Add(sameName.Key);
 			}
-
-			string display = Formatter.Format(dependency);
-			if (seen.Add(display))
+			else
 			{
-				violations.Add(display);
+				violations.AddRange(violators.Select(violator => violator.Namespace is null
+					? sameName.Key
+					: $"{violator.Namespace}.{sameName.Key}"));
 			}
 		}
 
@@ -976,24 +997,14 @@ internal static IReadOnlyList<string> GetDependencyTypeSetViolations(
 	///     a verdict and not the violation list.
 	/// </remarks>
 	internal static bool HasDependencyTypeSetViolations(this Type type, TypeSetDependencyOptions allowed)
-	{
-		string? ownNamespace = type.Namespace;
-		string[] excludedPrefixes = Customize.aweXpect.Reflection().ExcludedAssemblyPrefixes.Get();
-		return type.ResolveDependencies()
-			.Any(dependency => IsDependencyTypeSetViolation(dependency, ownNamespace, allowed, excludedPrefixes));
-	}
+		=> type.GetDependencyViolations(
+			(dependency, ownNamespace, excludedPrefixes)
+				=> IsDependencyTypeSetViolation(dependency, ownNamespace, allowed, excludedPrefixes)).Any();
 
 	private static bool IsDependencyTypeSetViolation(
 		Type dependency, string? ownNamespace, TypeSetDependencyOptions allowed, string[] excludedPrefixes)
-	{
-		if (dependency.IsFrameworkDependency(excludedPrefixes))
-		{
-			return false;
-		}
-
-		return !IsOwnNamespace(dependency.Namespace, ownNamespace, true) &&
-		       !allowed.Matches(dependency);
-	}
+		=> !IsExemptDependency(dependency, ownNamespace, true, excludedPrefixes) &&
+		   !allowed.Matches(dependency);
 
 	/// <summary>
 	///     Resolves the dependencies of the <paramref name="type" /> through which all assertions and filters go,

Source/aweXpect.Reflection/Options/TypeSetDependencyOptions.cs

@@ -34,7 +34,7 @@ public TypeSetDependencyOptions(Filtered.Types target, Filtered.Types[] addition
 				"The additional target collections of types must not be null.");
 		}
 
-		Add(additional);
+		Add(additional, nameof(additional));
 	}
 
 	private TypeSetDependencyOptions(IEnumerable<Filtered.Types> targets)
@@ -61,17 +61,18 @@ public void OrOn(Filtered.Types[] targets)
 			throw new ArgumentException("At least one collection of types must be specified.");
 		}
 
-		Add(targets);
+		Add(targets, nameof(targets));
 	}
 
-	private void Add(Filtered.Types[] targets)
+	private void Add(Filtered.Types[] targets, string paramName)
 	{
-		foreach (Filtered.Types target in targets)
+		// Fully validate before mutating, so that a failed widening leaves the shared instance untouched.
+		if (targets.Contains(null!))
 		{
-			_targets.Add(target ?? throw new ArgumentNullException(nameof(targets),
-				"The target collections of types must not contain null."));
+			throw new ArgumentNullException(paramName, "The target collections of types must not contain null.");
 		}
 
+		_targets.AddRange(targets);
 		// Widening invalidates a previously resolved set.
 		_resolved = null;
 	}
@@ -80,6 +81,11 @@ private void Add(Filtered.Types[] targets)
 	///     Resolves the target collections once into their union set; subsequent <see cref="Matches" /> /
 	///     <see cref="IsMatchedBy" /> calls use this set.
 	/// </summary>
+	/// <remarks>
+	///     Each member is normalized via <see cref="TypeHelpers.StripElementTypes" />: dependencies are stored
+	///     element-stripped at collection time, so array/by-ref/pointer targets must be unwrapped symmetrically
+	///     (mirroring <see cref="TypeHelpers.MatchesType" /> in the specific-type overloads).
+	/// </remarks>
 #if NET8_0_OR_GREATER
 	public async ValueTask Resolve()
 	{
@@ -93,7 +99,7 @@ public async ValueTask Resolve()
 		{
 			await foreach (Type type in target)
 			{
-				resolved.Add(type);
+				resolved.Add(TypeHelpers.StripElementTypes(type));
 			}
 		}
 
@@ -107,7 +113,10 @@ public Task Resolve()
 			HashSet<Type> resolved = [];
 			foreach (Filtered.Types target in _targets)
 			{
-				resolved.UnionWith(target);
+				foreach (Type type in target)
+				{
+					resolved.Add(TypeHelpers.StripElementTypes(type));
+				}
 			}
 
 			_resolved = resolved;

Source/aweXpect.Reflection/ThatTypes.DependOn.cs

@@ -176,6 +176,14 @@ private static bool DependsOnNamespace(Type? type, NamespaceDependencyOptions op
 	private static bool DoesNotDependOnNamespace(Type? type, NamespaceDependencyOptions options)
 		=> type is not null && !options.IsMatchedBy(type);
 
+	private static bool DependsOnTypeSet(Type? type, TypeSetDependencyOptions options)
+		=> type is not null && options.IsMatchedBy(type);
+
+	// A null item's dependencies cannot be verified, so it fails the negative assertion just like the
+	// positive one (and like DependOnlyOn), instead of slipping through as "does not depend".
+	private static bool DoesNotDependOnTypeSet(Type? type, TypeSetDependencyOptions options)
+		=> type is not null && !options.IsMatchedBy(type);
+
 	private sealed class DependOnConstraint(
 		string it,
 		ExpectationGrammars grammars,
@@ -264,14 +272,14 @@ private sealed class DependOnTypeSetConstraint(
 		public async Task<ConstraintResult> IsMetBy(IAsyncEnumerable<Type?> actual, CancellationToken cancellationToken)
 		{
 			await options.Resolve();
-			return await SetAsyncValue(actual, type => type is not null && options.IsMatchedBy(type));
+			return await SetAsyncValue(actual, type => DependsOnTypeSet(type, options));
 		}
 #endif
 
 		public async Task<ConstraintResult> IsMetBy(IEnumerable<Type?> actual, CancellationToken cancellationToken)
 		{
 			await options.Resolve();
-			return SetValue(actual, type => type is not null && options.IsMatchedBy(type));
+			return SetValue(actual, type => DependsOnTypeSet(type, options));
 		}
 
 		protected override void AppendNormalExpectation(StringBuilder stringBuilder, string? indentation = null)
@@ -307,18 +315,14 @@ private sealed class DoNotDependOnTypeSetConstraint(
 		public async Task<ConstraintResult> IsMetBy(IAsyncEnumerable<Type?> actual, CancellationToken cancellationToken)
 		{
 			await options.Resolve();
-			// A null item's dependencies cannot be verified, so it fails the negative assertion just like the
-			// positive one (and like DependOnlyOn), instead of slipping through as "does not depend".
-			return await SetAsyncValue(actual, type => type is not null && !options.IsMatchedBy(type));
+			return await SetAsyncValue(actual, type => DoesNotDependOnTypeSet(type, options));
 		}
 #endif
 
 		public async Task<ConstraintResult> IsMetBy(IEnumerable<Type?> actual, CancellationToken cancellationToken)
 		{
 			await options.Resolve();
-			// A null item's dependencies cannot be verified, so it fails the negative assertion just like the
-			// positive one (and like DependOnlyOn), instead of slipping through as "does not depend".
-			return SetValue(actual, type => type is not null && !options.IsMatchedBy(type));
+			return SetValue(actual, type => DoesNotDependOnTypeSet(type, options));
 		}
 
 		protected override void AppendNormalExpectation(StringBuilder stringBuilder, string? indentation = null)

Tests/aweXpect.Reflection.Tests/TestHelpers/Dependencies/DependencyFixtures.cs

@@ -231,6 +231,14 @@ public class ViaLayer1GenericConstruction
 		private TargetGeneric<TargetB> _target;
 	}
 
+	// Two distinct disallowed dependencies share the simple name "AmbiguousTarget"; the violation list
+	// must keep them apart by qualifying each with its namespace.
+	public class WithSameNamedDependencies
+	{
+		private AmbiguousA.AmbiguousTarget _a;
+		private AmbiguousB.AmbiguousTarget _b;
+	}
+
 	public class WithAsyncMethod
 	{
 		public static async void MethodAsync() => await Task.CompletedTask;
@@ -329,3 +337,15 @@ public class CovariantReturnDerived : CovariantReturnBase
 	}
 #endif
 }
+
+// Two namespaces deliberately declaring the same simple type name, so that violation messages must
+// disambiguate (see WithSameNamedDependencies above).
+namespace aweXpect.Reflection.Tests.TestHelpers.Dependencies.AmbiguousA
+{
+	public class AmbiguousTarget;
+}
+
+namespace aweXpect.Reflection.Tests.TestHelpers.Dependencies.AmbiguousB
+{
+	public class AmbiguousTarget;
+}

Tests/aweXpect.Reflection.Tests/ThatType.DependsOn.Tests.cs

@@ -534,6 +534,19 @@ async Task Act()
 				await That(Act).DoesNotThrow();
 			}
 
+			[Fact]
+			public async Task WhenTargetCollectionContainsArrayType_ShouldMatchElementTypeDependency()
+			{
+				// Dependencies are stored element-stripped, so an array target matches like its element
+				// type, mirroring the specific-type overload DependsOn(typeof(TargetA[])).
+				Type subject = typeof(ViaField);
+
+				async Task Act()
+					=> await That(subject).DependsOn(In.Type(typeof(TargetA[])));
+
+				await That(Act).DoesNotThrow();
+			}
+
 			[Fact]
 			public async Task WhenTargetCollectionContainsFrameworkTypes_ShouldMatchThem()
 			{
@@ -606,8 +619,11 @@ async Task Act()
 					=> await That(subject)
 						.DependsOn(Types.InNamespace(Layer1Namespace), (Filtered.Types)null!, (Filtered.Types)null!);
 
+				// The localized paramName suffix differs between frameworks ("(Parameter 'additional')" vs
+				// "Parametername: additional"), so only the shared part is matched.
 				await That(Act).Throws<ArgumentNullException>()
-					.WithMessage("The target collections of types must not contain null.*").AsWildcard();
+					.WithMessage("The target collections of types must not contain null.*additional*")
+					.AsWildcard();
 			}
 
 			[Fact]

Tests/aweXpect.Reflection.Tests/ThatType.DependsOnlyOn.Tests.cs

@@ -1,4 +1,5 @@
 using aweXpect.Reflection.Tests.TestHelpers.Dependencies.Consumers;
+using aweXpect.Reflection.Tests.TestHelpers.Dependencies.Synthetic;
 using Xunit.Sdk;
 
 namespace aweXpect.Reflection.Tests;
@@ -224,6 +225,20 @@ async Task Act()
 				await That(Act).DoesNotThrow();
 			}
 
+			[Fact]
+			public async Task WhenDistinctViolatorsShareTheSimpleName_ShouldQualifyThemByNamespace()
+			{
+				// Both AmbiguousTarget dependencies are disallowed; they must stay apart in the message
+				// instead of collapsing into one indistinguishable "AmbiguousTarget" entry.
+				Type subject = typeof(WithSameNamedDependencies);
+
+				async Task Act()
+					=> await That(subject).DependsOnlyOn(In.Namespace(Layer1Namespace));
+
+				await That(Act).Throws<XunitException>()
+					.WithMessage("*AmbiguousA.AmbiguousTarget*AmbiguousB.AmbiguousTarget*").AsWildcard();
+			}
+
 			[Fact]
 			public async Task WhenTargetCollectionIsEmpty_ShouldStillAllowFrameworkDependencies()
 			{