Add params argument support (#21)

* Add generator support for `params` parameter
* Update `Validator` analyzers
* Update `Validate` analyzer

Author: viceroypenguin

src/Immediate.Validations.Analyzers/ValidateClassAnalyzer.cs

@@ -66,7 +66,7 @@ public sealed class ValidateClassAnalyzer : DiagnosticAnalyzer
 		);
 
 	public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } =
-		ImmutableArray.Create<DiagnosticDescriptor>(
+		ImmutableArray.Create(
 		[
 			ValidateAttributeMissing,
 			IValidationTargetMissing,
@@ -83,15 +83,22 @@ public override void Initialize(AnalysisContext context)
 		context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
 		context.EnableConcurrentExecution();
 
-		context.RegisterSymbolAction(AnalyzeSymbol, SymbolKind.NamedType);
+		context.RegisterSyntaxNodeAction(
+			AnalyzeSymbol,
+			SyntaxKind.ClassDeclaration,
+			SyntaxKind.RecordDeclaration,
+			SyntaxKind.StructDeclaration,
+			SyntaxKind.RecordStructDeclaration,
+			SyntaxKind.InterfaceDeclaration
+		);
 	}
 
-	private static void AnalyzeSymbol(SymbolAnalysisContext context)
+	private static void AnalyzeSymbol(SyntaxNodeAnalysisContext context)
 	{
 		var token = context.CancellationToken;
 		token.ThrowIfCancellationRequested();
 
-		var symbol = (INamedTypeSymbol)context.Symbol;
+		var symbol = (INamedTypeSymbol)context.ContainingSymbol!;
 
 		var hasValidateAttribute = symbol
 			.GetAttributes()
@@ -280,88 +287,87 @@ CancellationToken token
 	}
 
 	private static void ValidateArguments(
-		SymbolAnalysisContext context,
+		SyntaxNodeAnalysisContext context,
 		List<IPropertySymbol> properties,
 		AttributeData attribute,
 		ImmutableArray<IParameterSymbol> validateParameterSymbols,
-		ITypeSymbol propertyType
+		ITypeSymbol typeArgumentType
 	)
 	{
 		var attributeSyntax = (AttributeSyntax)attribute.ApplicationSyntaxReference!.GetSyntax();
 		var argumentListSyntax = attributeSyntax.ArgumentList?.Arguments ?? [];
 
+		if (argumentListSyntax.Count == 0)
+			return;
+
 		var attributeParameters = attribute.AttributeConstructor!.Parameters;
-		var attributeArguments = attribute.ConstructorArguments;
-		var attributeNamedArguments = attribute.NamedArguments;
+		var attributeParameterIndex = 0;
+
 		List<IPropertySymbol>? attributeProperties = null;
 
 		for (var i = 0; i < argumentListSyntax.Count; i++)
 		{
 			switch (argumentListSyntax[i])
 			{
+				case { NameEquals.Name.Identifier.ValueText: var name }:
+				{
+					if (name is "Message")
+						break;
+
+					attributeProperties ??= attribute.AttributeClass!.GetMembers()
+						.OfType<IPropertySymbol>()
+						.ToList();
+					var property = attributeProperties.First(a => a.Name == name);
+
+					ValidateArgument(
+						context,
+						argumentListSyntax[i],
+						property,
+						validateParameterSymbols,
+						typeArgumentType,
+						properties
+					);
+
+					break;
+				}
+
 				case { NameColon.Name.Identifier.ValueText: var name }:
 				{
-					for (var j = 0; j < attributeArguments.Length; j++)
+					for (var j = 0; j < attributeParameters.Length; j++)
 					{
 						if (attributeParameters[j].Name == name)
 						{
 							ValidateArgument(
 								context,
 								argumentListSyntax[i],
 								attributeParameters[j],
-								attributeArguments[j],
 								validateParameterSymbols,
-								propertyType,
+								typeArgumentType,
 								properties
 							);
 
 							break;
 						}
 					}
 
+					attributeParameterIndex++;
 					break;
 				}
 
-				case { NameEquals.Name.Identifier.ValueText: var name }:
+				default:
 				{
-					if (name is "Message")
-						break;
-
-					var argument = attributeNamedArguments.First(a => a.Key == name).Value;
-
-					attributeProperties ??= attribute.AttributeClass!.GetMembers()
-						.OfType<IPropertySymbol>()
-						.ToList();
-					var property = attributeProperties.First(a => a.Name == name);
-
+					var attributeParameter = attributeParameters[attributeParameterIndex];
 					ValidateArgument(
 						context,
 						argumentListSyntax[i],
-						property,
-						argument,
+						attributeParameter,
 						validateParameterSymbols,
-						propertyType,
+						typeArgumentType,
 						properties
 					);
 
-					break;
-				}
-
-				default:
-				{
-					if (i < attributeParameters.Length
-						&& i < attributeArguments.Length)
-					{
-						ValidateArgument(
-							context,
-							argumentListSyntax[i],
-							attributeParameters[i],
-							attributeArguments[i],
-							validateParameterSymbols,
-							propertyType,
-							properties
-						);
-					}
+					if (!attributeParameter.IsParams)
+						attributeParameterIndex++;
 
 					break;
 				}
@@ -370,58 +376,62 @@ ITypeSymbol propertyType
 	}
 
 	private static void ValidateArgument(
-		SymbolAnalysisContext context,
+		SyntaxNodeAnalysisContext context,
 		AttributeArgumentSyntax syntax,
 		ISymbol parameter,
-		TypedConstant argument,
 		ImmutableArray<IParameterSymbol> validateParameterSymbols,
-		ITypeSymbol propertyType,
+		ITypeSymbol typeArgumentType,
 		List<IPropertySymbol> properties
 	)
 	{
-		if (parameter.IsTargetTypeSymbol()
-			&& argument.Type is not null
-		)
-		{
-			var validateParameter = validateParameterSymbols.First(p => p.Name == parameter.Name);
-			var targetType = validateParameter.Type;
-			if (targetType is ITypeParameterSymbol)
-				targetType = propertyType;
+		if (!parameter.IsTargetTypeSymbol())
+			return;
 
-			if (syntax.Expression.IsNameOfExpression(out var propertyName))
-			{
-				var property = properties
-					.FirstOrDefault(p => p.Name == propertyName);
+		var validateParameter = validateParameterSymbols.First(p => p.Name == parameter.Name);
+		var targetType = validateParameter.Type;
 
-				if (property is null)
-					return;
+		if (validateParameter.IsParams && targetType is IArrayTypeSymbol { ElementType: { } et })
+			targetType = et;
 
-				if (!context.Compilation.ClassifyConversion(property.Type, targetType).IsValidConversion())
-				{
-					context.ReportDiagnostic(
-						Diagnostic.Create(
-							ValidateParameterPropertyIncompatibleType,
-							syntax.GetLocation(),
-							parameter.Name,
-							property.Name,
-							targetType.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat)
-						)
-					);
-				}
+		if (targetType is ITypeParameterSymbol)
+			targetType = typeArgumentType;
+
+		if (syntax.Expression.IsNameOfExpression(out var propertyName))
+		{
+			var property = properties
+				.FirstOrDefault(p => p.Name == propertyName);
+
+			if (property is null)
+				return;
+
+			if (!context.Compilation.ClassifyConversion(property.Type, targetType).IsValidConversion())
+			{
+				context.ReportDiagnostic(
+					Diagnostic.Create(
+						ValidateParameterPropertyIncompatibleType,
+						syntax.GetLocation(),
+						parameter.Name,
+						property.Name,
+						targetType.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat)
+					)
+				);
 			}
-			else
+		}
+		else
+		{
+			if (context.SemanticModel.GetOperation(syntax.Expression)?.Type is not ITypeSymbol argumentType)
+				return;
+
+			if (!context.Compilation.ClassifyConversion(argumentType, targetType).IsValidConversion())
 			{
-				if (!context.Compilation.ClassifyConversion(argument.Type, targetType).IsValidConversion())
-				{
-					context.ReportDiagnostic(
-						Diagnostic.Create(
-							ValidateParameterIncompatibleType,
-							syntax.GetLocation(),
-							parameter.Name,
-							targetType.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat)
-						)
-					);
-				}
+				context.ReportDiagnostic(
+					Diagnostic.Create(
+						ValidateParameterIncompatibleType,
+						syntax.GetLocation(),
+						parameter.Name,
+						targetType.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat)
+					)
+				);
 			}
 		}
 	}
@@ -430,13 +440,10 @@ List<IPropertySymbol> properties
 file static class Extensions
 {
 	public static bool IsTargetTypeSymbol(this ISymbol symbol) =>
-		symbol is IParameterSymbol { Type.SpecialType: SpecialType.System_Object }
-			or IPropertySymbol { Type.SpecialType: SpecialType.System_Object }
-		&& symbol.GetAttributes().Any(a => a.AttributeClass.IsTargetTypeAttribute());
+		symbol.GetAttributes().Any(a => a.AttributeClass.IsTargetTypeAttribute());
 
 	public static bool IsNameOfExpression(this ExpressionSyntax syntax, out string? name)
 	{
-		name = null;
 		if (syntax is InvocationExpressionSyntax
 			{
 				Expression: SimpleNameSyntax { Identifier.ValueText: "nameof" },
@@ -449,6 +456,7 @@ public static bool IsNameOfExpression(this ExpressionSyntax syntax, out string?
 		}
 		else
 		{
+			name = null;
 			return false;
 		}
 	}

src/Immediate.Validations.Analyzers/ValidatorClassAnalyzer.cs

@@ -253,7 +253,10 @@ IMethodSymbol methodSymbol
 						break;
 				}
 
-				properties[i] = p;
+				if (i == properties.Count)
+					properties.Add(p);
+				else
+					properties[i] = p;
 			}
 		}
 
@@ -307,32 +310,44 @@ private static void CheckParameterAllowedType(
 		ITypeSymbol propertyType
 	)
 	{
-		if (
-			propertyType is not { SpecialType: SpecialType.System_Object }
-			|| !property.GetAttributes().Any(a => a.AttributeClass.IsTargetTypeAttribute())
+		var parameterType = parameter.Type;
+
+		if (parameter.IsParams
+			&& property is IParameterSymbol { IsParams: true }
 		)
 		{
-			if (!SymbolEqualityComparer.IncludeNullability.Equals(propertyType, parameter.Type))
-			{
-				context.ReportDiagnostic(
-					Diagnostic.Create(
-						ValidateMethodParameterIsIncorrectType,
-						parameter.Locations[0],
-						parameter.Name,
-						property.Name
-					)
-				);
+			propertyType = ((IArrayTypeSymbol)propertyType).ElementType;
+			parameterType = ((IArrayTypeSymbol)parameterType).ElementType;
+		}
 
-				context.ReportDiagnostic(
-					Diagnostic.Create(
-						ValidateMethodParameterIsIncorrectType,
-						property.Locations[0],
-						parameter.Name,
-						property.Name
-					)
-				);
-			}
+		if (
+			propertyType is { SpecialType: SpecialType.System_Object }
+			&& property.GetAttributes().Any(a => a.AttributeClass.IsTargetTypeAttribute())
+		)
+		{
+			return;
 		}
+
+		if (SymbolEqualityComparer.IncludeNullability.Equals(propertyType, parameterType))
+			return;
+
+		context.ReportDiagnostic(
+			Diagnostic.Create(
+				ValidateMethodParameterIsIncorrectType,
+				parameter.Locations[0],
+				parameter.Name,
+				property.Name
+			)
+		);
+
+		context.ReportDiagnostic(
+			Diagnostic.Create(
+				ValidateMethodParameterIsIncorrectType,
+				property.Locations[0],
+				parameter.Name,
+				property.Name
+			)
+		);
 	}
 
 	private static void CheckParameterIsRequired(SymbolAnalysisContext context, IParameterSymbol parameter, ISymbol property, bool isRequired)

src/Immediate.Validations.Generators/EquatableReadOnlyList.cs

@@ -6,8 +6,8 @@ namespace Immediate.Validations.Generators;
 [ExcludeFromCodeCoverage]
 public static class EquatableReadOnlyList
 {
-	public static EquatableReadOnlyList<T> ToEquatableReadOnlyList<T>(this IEnumerable<T> enumerable)
-		=> new((enumerable as IReadOnlyList<T>) ?? enumerable.ToArray());
+	public static EquatableReadOnlyList<T> ToEquatableReadOnlyList<T>(this IEnumerable<T>? enumerable)
+		=> new((enumerable as IReadOnlyList<T>) ?? enumerable?.ToArray());
 }
 
 /// <summary>