Add support for inheritance of validations (#19)

Author: viceroypenguin

src/Immediate.Validations.Generators/ITypeSymbolExtensions.cs

@@ -103,4 +103,31 @@ typeSymbol is
 				},
 			},
 		};
+
+	public static bool IsIValidationTarget(this INamedTypeSymbol? typeSymbol) =>
+		typeSymbol is
+		{
+			MetadataName: "IValidationTarget`1",
+			ContainingNamespace:
+			{
+				Name: "Shared",
+				ContainingNamespace:
+				{
+					Name: "Validations",
+					ContainingNamespace:
+					{
+						Name: "Immediate",
+						ContainingNamespace.IsGlobalNamespace: true,
+					},
+				},
+			},
+		};
+
+	public static bool IsValidationTarget([NotNullWhen(returnValue: true)] this INamedTypeSymbol? typeSymbol) =>
+		typeSymbol is not null
+		&& typeSymbol.Interfaces
+			.Any(i =>
+				i.IsIValidationTarget()
+				&& SymbolEqualityComparer.Default.Equals(typeSymbol, i.TypeArguments[0])
+			);
 }

src/Immediate.Validations.Generators/ImmediateValidationsGenerator.Transform.cs

@@ -25,6 +25,7 @@ CancellationToken token
 		var symbol = (INamedTypeSymbol)context.TargetSymbol;
 		var @namespace = symbol.ContainingNamespace.ToString().NullIf("<global namespace>");
 		var outerClasses = GetOuterClasses(symbol);
+		var baseValidatorTypes = GetBaseValidatorTypes(symbol);
 		var properties = GetProperties(context.SemanticModel.Compilation, symbol, token);
 
 		return new()
@@ -33,6 +34,7 @@ CancellationToken token
 			OuterClasses = outerClasses,
 			Class = GetClass(symbol),
 			IsReferenceType = symbol.IsReferenceType,
+			BaseValidatorTypes = baseValidatorTypes,
 			Properties = properties,
 		};
 	}
@@ -53,19 +55,41 @@ private static Class GetClass(INamedTypeSymbol symbol) =>
 
 	private static EquatableReadOnlyList<Class> GetOuterClasses(INamedTypeSymbol symbol)
 	{
-		var outerClasses = new List<Class>();
+		List<Class>? outerClasses = null;
 		var outerSymbol = symbol.ContainingType;
 		while (outerSymbol is not null)
 		{
-			outerClasses.Add(GetClass(outerSymbol));
+			(outerClasses ??= []).Add(GetClass(outerSymbol));
 			outerSymbol = outerSymbol.ContainingType;
 		}
 
+		if (outerClasses is null)
+			return default;
+
 		outerClasses.Reverse();
 
 		return outerClasses.ToEquatableReadOnlyList();
 	}
 
+	private static EquatableReadOnlyList<string> GetBaseValidatorTypes(INamedTypeSymbol symbol)
+	{
+		List<string>? baseValidatorTypes = null;
+
+		if (symbol.BaseType.IsValidationTarget())
+			(baseValidatorTypes = []).Add(symbol.BaseType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat));
+
+		foreach (var i in symbol.Interfaces)
+		{
+			if (i.IsValidationTarget())
+				(baseValidatorTypes ??= []).Add(i.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat));
+		}
+
+		if (baseValidatorTypes is null)
+			return default;
+
+		return baseValidatorTypes.ToEquatableReadOnlyList();
+	}
+
 	private static EquatableReadOnlyList<ValidationTargetProperty> GetProperties(
 		Compilation compilation,
 		INamedTypeSymbol symbol,

src/Immediate.Validations.Generators/Models.cs

@@ -6,6 +6,7 @@ public sealed record ValidationTarget
 	public required EquatableReadOnlyList<Class> OuterClasses { get; init; }
 	public required Class Class { get; init; }
 	public required bool IsReferenceType { get; init; }
+	public required EquatableReadOnlyList<string> BaseValidatorTypes { get; init; }
 	public required EquatableReadOnlyList<ValidationTargetProperty> Properties { get; init; }
 }
 

src/Immediate.Validations.Generators/Templates/Validations.sbntxt

@@ -15,7 +15,10 @@ partial {{ c.type }} {{ c.name }}
 
 partial {{ class.type }} {{ class.name }}
 {
-	public static List<ValidationError> Validate({{ class.name; if is_reference_type; "?"; end }} target)
+	static List<ValidationError> IValidationTarget<{{ class.name }}>.Validate({{ class.name; if is_reference_type; "?"; end }} target) =>
+		Validate(target);
+
+	public static {{ if class.type == "interface"; "new"; end }} List<ValidationError> Validate({{ class.name; if is_reference_type; "?"; end }} target)
 	{
 		{{~ if is_reference_type ~}}
 		if (target is not { } t)
@@ -35,6 +38,10 @@ partial {{ class.type }} {{ class.name }}
 
 		var errors = new List<ValidationError>();
 
+		{{~ for bc in base_validator_types ~}}
+		errors.AddRange({{ bc }}.Validate(t));
+		{{~ end ~}}
+
 		{{~ for p in properties ~}}
 		__Validate{{ p.property_name }}(errors, t, t.{{ p.property_name }});
 		{{~ end ~}}

src/Immediate.Validations.Shared/IValidationTarget.cs

@@ -29,5 +29,5 @@ public interface IValidationTarget<T>
 		"CA1002:Do not expose generic lists",
 		Justification = "List<> is returned for performance; this method is generally only used internally."
 	)]
-	static abstract List<ValidationError> Validate(T target);
+	static abstract List<ValidationError> Validate(T? target);
 }

src/Immediate.Validations.Shared/ValidateAttribute.cs

@@ -7,5 +7,5 @@ namespace Immediate.Validations.Shared;
 /// <summary>
 ///		Applied to a class to indicate that validation methods should be generated.
 /// </summary>
-[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct)]
+[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface)]
 public sealed class ValidateAttribute : Attribute;

tests/Immediate.Validations.FunctionalTests/IntegrationTests/InheritanceTests.cs

@@ -0,0 +1,87 @@
+using Immediate.Validations.Shared;
+using Xunit;
+
+namespace Immediate.Validations.FunctionalTests.IntegrationTests;
+
+public sealed partial class InheritanceTests
+{
+	[Validate]
+	public partial interface IBaseInterface : IValidationTarget<IBaseInterface>
+	{
+		[NotEmptyOrWhiteSpace]
+		string Description { get; }
+	}
+
+	[Validate]
+	public partial record BaseClass : IValidationTarget<BaseClass>
+	{
+		[MinLength(4)]
+		public required string Id { get; init; }
+	}
+
+	[Validate]
+	public partial record Class : BaseClass, IBaseInterface, IValidationTarget<Class>
+	{
+		public required string Description { get; init; }
+	}
+
+	[Fact]
+	public void ValidClassHasNoErrors()
+	{
+		var @class = new Class
+		{
+			Id = "1234",
+			Description = "Hello World!",
+		};
+
+		var errors = Class.Validate(@class);
+
+		Assert.Empty(errors);
+	}
+
+	[Fact]
+	public void ShortIdHasErrors()
+	{
+		var @class = new Class
+		{
+			Id = "123",
+			Description = "Hello World!",
+		};
+
+		var errors = Class.Validate(@class);
+
+		Assert.Equal(
+			[
+				new()
+				{
+					PropertyName = "Id",
+					ErrorMessage = "String is of length '3', which is shorter than the minimum allowed length of '4'.",
+				}
+			],
+			errors
+		);
+	}
+
+	[Fact]
+	public void EmptyDescriptionHasErrors()
+	{
+		var @class = new Class
+		{
+			Id = "1234",
+			Description = "",
+		};
+
+		var errors = Class.Validate(@class);
+
+		Assert.Equal(
+			[
+				new()
+				{
+					PropertyName = "Description",
+					ErrorMessage = "Property must not be `null` or whitespace.",
+				}
+			],
+			errors
+		);
+	}
+}

tests/Immediate.Validations.Tests/GeneratorTests/ClassLocationTests.ImplementBaseValidationInterface#IV...BaseInterface.g.verified.cs

@@ -0,0 +1,38 @@
+//HintName: IV...BaseInterface.g.cs
+using System.Collections.Generic;
+using Immediate.Validations.Shared;
+
+#nullable enable
+#pragma warning disable CS1591
+
+
+partial interface BaseInterface
+{
+	static List<ValidationError> IValidationTarget<BaseInterface>.Validate(BaseInterface? target) =>
+		Validate(target);
+
+	public static new List<ValidationError> Validate(BaseInterface? target)
+	{
+		if (target is not { } t)
+		{
+			return 
+			[
+				new()
+				{
+					PropertyName = ".self",
+					ErrorMessage = "`target` must not be `null`.",
+				},
+			];
+		}
+		
+		var errors = new List<ValidationError>();
+
+
+
+		return errors;
+	}
+
+
+
+}
+

tests/Immediate.Validations.Tests/GeneratorTests/ClassLocationTests.ImplementBaseValidationInterface#IV...ValidateClass.g.verified.cs

@@ -0,0 +1,39 @@
+//HintName: IV...ValidateClass.g.cs
+using System.Collections.Generic;
+using Immediate.Validations.Shared;
+
+#nullable enable
+#pragma warning disable CS1591
+
+
+partial class ValidateClass
+{
+	static List<ValidationError> IValidationTarget<ValidateClass>.Validate(ValidateClass? target) =>
+		Validate(target);
+
+	public static  List<ValidationError> Validate(ValidateClass? target)
+	{
+		if (target is not { } t)
+		{
+			return 
+			[
+				new()
+				{
+					PropertyName = ".self",
+					ErrorMessage = "`target` must not be `null`.",
+				},
+			];
+		}
+		
+		var errors = new List<ValidationError>();
+
+		errors.AddRange(global::BaseInterface.Validate(t));
+
+
+		return errors;
+	}
+
+
+
+}
+

tests/Immediate.Validations.Tests/GeneratorTests/ClassLocationTests.InheritBaseValidationTarget#IV...BaseClass.g.verified.cs

@@ -0,0 +1,38 @@
+//HintName: IV...BaseClass.g.cs
+using System.Collections.Generic;
+using Immediate.Validations.Shared;
+
+#nullable enable
+#pragma warning disable CS1591
+
+
+partial class BaseClass
+{
+	static List<ValidationError> IValidationTarget<BaseClass>.Validate(BaseClass? target) =>
+		Validate(target);
+
+	public static  List<ValidationError> Validate(BaseClass? target)
+	{
+		if (target is not { } t)
+		{
+			return 
+			[
+				new()
+				{
+					PropertyName = ".self",
+					ErrorMessage = "`target` must not be `null`.",
+				},
+			];
+		}
+		
+		var errors = new List<ValidationError>();
+
+
+
+		return errors;
+	}
+
+
+
+}
+