Fix X1019: Added special-cases handling to correctly validate types convertible to IEnumerable<T[]> (#199)

Author: fnipo

src/xunit.analyzers.tests/Analyzers/X1000/MemberDataShouldReferenceValidMemberTests.cs

@@ -203,16 +203,44 @@ public async ValueTask V2_and_V3()
 				#pragma warning disable xUnit1053
 
 				using System;
+				using System.Collections;
 				using System.Collections.Generic;
 				using System.Threading.Tasks;
 				using Xunit;
 
+				public class NamedTypeForIEnumerableStringArray : IEnumerable<string[]>
+				{
+				    private readonly List<string[]> _items = new List<string[]>();
+
+				    public void Add(string sdl)
+				    {
+				        _items.Add(new string[] { sdl });
+				    }
+
+				    public IEnumerator<string[]> GetEnumerator()
+				    {
+				        return _items.GetEnumerator();
+				    }
+
+				    IEnumerator IEnumerable.GetEnumerator()
+				    {
+				        return GetEnumerator();
+				    }
+				}
+
+				public class NamedSubtypeForIEnumerableStringArray : NamedTypeForIEnumerableStringArray {}
+
 				public class TestClass {
 					public static IEnumerable<object> ObjectSource;
 					public static object NakedObjectSource;
 					public static object[] NakedObjectArraySource;
+					public static object[][] NakedObjectMatrixSource;
 
 					public static IEnumerable<object[]> ObjectArraySource;
+					public static IEnumerable<string[]> StringArraySource;
+					public static NamedTypeForIEnumerableStringArray NamedTypeForIEnumerableStringArraySource;
+					public static NamedSubtypeForIEnumerableStringArray NamedSubtypeForIEnumerableStringArraySource;
+
 					public static Task<IEnumerable<object[]>> TaskObjectArraySource;
 					public static ValueTask<IEnumerable<object[]>> ValueTaskObjectArraySource;
 
@@ -243,8 +271,13 @@ public class TestClass {
 					[{|#0:MemberData(nameof(ObjectSource))|}]
 					[{|#1:MemberData(nameof(NakedObjectSource))|}]
 					[{|#2:MemberData(nameof(NakedObjectArraySource))|}]
+					[MemberData(nameof(NakedObjectMatrixSource))]
 
 					[MemberData(nameof(ObjectArraySource))]
+					[MemberData(nameof(StringArraySource))]
+					[MemberData(nameof(NamedTypeForIEnumerableStringArraySource))]
+					[MemberData(nameof(NamedSubtypeForIEnumerableStringArraySource))]
+
 					[{|#10:MemberData(nameof(TaskObjectArraySource))|}]
 					[{|#11:MemberData(nameof(ValueTaskObjectArraySource))|}]
 
@@ -1397,6 +1430,7 @@ public void TestMethod1(int _) { }
 					[{|#1:MemberData(nameof(PropertyUntypedData))|}]
 					[{|#2:MemberData(nameof(MethodUntypedData))|}]
 					[{|#3:MemberData(nameof(MethodWithArgsUntypedData), 42)|}]
+
 					public void TestMethod2(int _) { }
 				}
 				""";

src/xunit.analyzers/X1000/MemberDataShouldReferenceValidMember.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
@@ -290,6 +291,42 @@ static bool IsInitialized(
 		return null;
 	}
 
+	static ITypeSymbol? FindTypeArgumentFromIEnumerable(
+		ITypeSymbol? start,
+		Compilation compilation)
+	{
+		if (start is not INamedTypeSymbol namedStart)
+			return null;
+
+		var iEnumerableOfT = TypeSymbolFactory.IEnumerableOfT(compilation);
+		if (iEnumerableOfT is null)
+			return null;
+
+		var current = namedStart;
+		while (current != null)
+		{
+			// If this class implements IEnumerable<T>, return T type argument
+			foreach (var iface in current.AllInterfaces)
+				if (SymbolEqualityComparer.Default.Equals(iface.OriginalDefinition, iEnumerableOfT))
+					return iface.TypeArguments.FirstOrDefault();
+
+			// Navigate to its Base types to investigate if they implement IEnumerable,
+			// attempt to resolve the base type from the source syntax (handles `: ValidExamples`).
+			var declaredBase = ResolveDeclaredBaseTypeFromSyntax(current, compilation) as INamedTypeSymbol;
+
+			// Prefer declaredBase when available; otherwise fall back to the BaseType symbol.
+			var next = declaredBase ?? current.BaseType;
+
+			// Stop if we reached object
+			if (next?.SpecialType == SpecialType.System_Object)
+				break;
+
+			current = next;
+		}
+
+		return null;
+	}
+
 	public static (INamedTypeSymbol? TestClass, ITypeSymbol? MemberClass) GetClassTypesForAttribute(
 		AttributeArgumentListSyntax attributeList,
 		SemanticModel semanticModel,
@@ -318,7 +355,7 @@ public static (INamedTypeSymbol? TestClass, ITypeSymbol? MemberClass) GetClassTy
 		List<AttributeArgumentSyntax> arguments, SemanticModel semanticModel)
 	{
 		if (arguments.Count > 1)
-			return arguments.Select(a => a.Expression).ToList();
+			return [.. arguments.Select(a => a.Expression)];
 		if (arguments.Count != 1)
 			return null;
 
@@ -672,6 +709,52 @@ static void ReportUseNameof(
 		);
 	}
 
+	/// <summary>
+	/// Resolve declared base type and find the first base class that implements IEnumerable
+	/// (e.g. "ValidExample" from "class SubtypeValidExample : ValidExample {}")
+	/// </summary>
+	static ITypeSymbol? ResolveDeclaredBaseTypeFromSyntax(
+		ITypeSymbol type,
+		Compilation compilation)
+	{
+		if (type is null)
+			return null;
+
+		// Look through source declarations for an explicit base type in the syntax.
+		foreach (var declaringReference in type.DeclaringSyntaxReferences)
+		{
+			var syntax = declaringReference.GetSyntax();
+			if (syntax is ClassDeclarationSyntax cls && cls.BaseList is not null && cls.BaseList.Types.Count > 0)
+			{
+				var baseTypeSyntax = cls.BaseList.Types.First().Type;
+				var baseTypeName = baseTypeSyntax.ToString(); // may be qualified
+
+				// Try direct metadata lookup first (works for namespace-qualified names)
+				var byMetadata = compilation.GetTypeByMetadataName(baseTypeName);
+				if (byMetadata is not null)
+					return byMetadata;
+
+				// Fallback: search symbols by the simple name and try to match fully-qualified textual form.
+				var simpleName = baseTypeName.Split('.').Last();
+				var candidates =
+					compilation
+						.GetSymbolsWithName(n => n == simpleName, SymbolFilter.Type)
+						.OfType<INamedTypeSymbol>()
+						.ToList();
+
+				// Prefer exact textual match of declared name (handles namespace-qualified baseTypeSyntax)
+				var exact = candidates.FirstOrDefault(c => string.Equals(c.ToDisplayString(), baseTypeName, StringComparison.Ordinal));
+				if (exact is not null)
+					return exact;
+
+				// Otherwise return the first candidate in the current compilation with the simple name
+				return candidates.FirstOrDefault();
+			}
+		}
+
+		return null;
+	}
+
 	static void VerifyDataMethodParameterUsage(
 		SemanticModel semanticModel,
 		SyntaxNodeAnalysisContext context,
@@ -801,6 +884,13 @@ static bool VerifyDataSourceReturnType(
 
 		var valid = iEnumerableOfObjectArrayType.IsAssignableFrom(memberType);
 
+		// Special‑case handling for IEnumerable<T> where T is not object[]. If T is any array type, it is assignable to object[] and therefore valid.
+		var memberEnumerableType = memberType.GetEnumerableType();
+		if (!valid && memberEnumerableType is not null)
+		{
+			valid = memberEnumerableType.TypeKind == TypeKind.Array;
+		}
+
 		if (!valid && v3 && iAsyncEnumerableOfObjectArrayType is not null)
 			valid = iAsyncEnumerableOfObjectArrayType.IsAssignableFrom(memberType);
 
@@ -816,6 +906,15 @@ static bool VerifyDataSourceReturnType(
 		if (!valid && v3 && iAsyncEnumerableOfTupleType is not null)
 			valid = iAsyncEnumerableOfTupleType.IsAssignableFrom(memberType);
 
+		// If still invalid and the member is a class, check whether it implements IEnumerable<T> and verify that T is an array type.
+		// This ensures the data can be safely converted to IEnumerable<object[]>.
+		if (!valid && memberType.TypeKind == TypeKind.Class)
+		{
+			var resolvedIEnumerableTypeArgument = FindTypeArgumentFromIEnumerable(memberType, compilation);
+			if (resolvedIEnumerableTypeArgument is not null)
+				valid = (resolvedIEnumerableTypeArgument.TypeKind == TypeKind.Array);
+		}
+
 		if (!valid)
 			ReportIncorrectReturnType(
 				context,