fix to validate arguments

Author: smdn

src/Smdn.Reflection.ReverseGenerating/Smdn.Reflection.ReverseGenerating/Generator.cs

@@ -12,13 +12,33 @@
 namespace Smdn.Reflection.ReverseGenerating;
 
 public static partial class Generator {
+  private static Type GenerateDeclarationValidateTypeArgument(Type? t, string paramName)
+  {
+    if (t is null)
+      throw new ArgumentNullException(paramName);
+    if (t.IsConstructedGenericType)
+      throw new ArgumentException($"can not generate declaration of constructed generic types (type: {t})");
+
+    return t;
+  }
+
+  private static Type GenerateDeclarationValidateGenericParameterArgument(Type? genericParameter, string paramName)
+  {
+    if (genericParameter is null)
+      throw new ArgumentNullException(paramName);
+    if (!genericParameter.IsGenericParameter)
+      throw new ArgumentException($"can not generate declaration of types which does not represent generic parameter ({genericParameter.FullName})");
+
+    return genericParameter;
+  }
+
   public static string GenerateTypeDeclaration(
     Type t,
     ISet<string>? referencingNamespaces,
     GeneratorOptions options
   ) =>
     GenerateTypeDeclaration(
-      t,
+      GenerateDeclarationValidateTypeArgument(t, nameof(t)),
       false,
       referencingNamespaces,
       options ?? throw new ArgumentNullException(nameof(options))
@@ -30,7 +50,7 @@ public static IEnumerable<string> GenerateTypeDeclarationWithExplicitBaseTypeAnd
     GeneratorOptions options
   ) =>
     GenerateTypeDeclaration(
-      t,
+      GenerateDeclarationValidateTypeArgument(t, nameof(t)),
       true,
       referencingNamespaces,
       options ?? throw new ArgumentNullException(nameof(options))
@@ -148,7 +168,7 @@ public static string GenerateGenericArgumentConstraintDeclaration(
     GeneratorOptions options
   )
     => GenerateGenericParameterConstraintDeclaration(
-      genericParameter: genericArgument,
+      genericParameter: GenerateDeclarationValidateGenericParameterArgument(genericArgument, nameof(genericArgument)),
       referencingNamespaces: referencingNamespaces,
       options: options
     );
@@ -159,6 +179,11 @@ public static string GenerateGenericParameterConstraintDeclaration(
     GeneratorOptions options
   )
   {
+    GenerateDeclarationValidateGenericParameterArgument(genericParameter, nameof(genericParameter));
+
+    if (options is null)
+      throw new ArgumentNullException(nameof(options));
+
     static bool HasUnmanagedConstraint(Type genericParameter)
       => genericParameter.CustomAttributes.Any(
         static attr => attr.AttributeType.FullName.Equals("System.Runtime.CompilerServices.IsUnmanagedAttribute", StringComparison.Ordinal)
@@ -244,6 +269,8 @@ public static IEnumerable<string> GenerateExplicitBaseTypeAndInterfaces(
     GeneratorOptions options
   )
   {
+    if (t is null)
+      throw new ArgumentNullException(nameof(t));
     if (options == null)
       throw new ArgumentNullException(nameof(options));
 
@@ -678,7 +705,10 @@ GeneratorOptions options
   {
     MethodInfo? explicitInterfaceMethod = null;
 
-    if (!asDelegateDeclaration) {
+    if (asDelegateDeclaration) {
+      GenerateDeclarationValidateTypeArgument(m.GetDeclaringTypeOrThrow(), nameof(m));
+    }
+    else {
       var isExplicitInterfaceMethod = m.TryFindExplicitInterfaceMethod(
         out explicitInterfaceMethod,
         findOnlyPublicInterfaces: options.IgnorePrivateOrAssembly
@@ -744,7 +774,9 @@ GeneratorOptions options
       ? null
       : asDelegateDeclaration
         ? m.GetDeclaringTypeOrThrow().GetGenericArguments()
-        : method.GetGenericArguments();
+        : method.IsGenericMethodDefinition
+          ? method.GetGenericArguments()
+          : null;
     var methodConstraints = genericParameters is null
       ? null
       : string.Join(

tests/Smdn.Reflection.ReverseGenerating/Smdn.Reflection.ReverseGenerating/Generator.cs

@@ -176,4 +176,76 @@ private static GeneratorOptions GetGeneratorOptions(GeneratorTestCaseAttribute t
 
     return options;
   }
+
+  [Test]
+  public void GenerateTypeDeclaration_ArgumentOptionsNull()
+    => Assert.Throws<ArgumentNullException>(() => Generator.GenerateTypeDeclaration(t: typeof(int), null, options: null!));
+
+  [Test]
+  public void GenerateTypeDeclaration_ArgumentTypeNull()
+    => Assert.Throws<ArgumentNullException>(() => Generator.GenerateTypeDeclaration(t: null!, null, options: new()));
+
+  [TestCase(typeof(List<int>))]
+  [TestCase(typeof(IEnumerable<int>))]
+  [TestCase(typeof(Action<int>))]
+  [TestCase(typeof(int?))]
+  [TestCase(typeof((int, int)))]
+  public void GenerateTypeDeclaration_ArgumentTypeIsConstructedGenericType(Type type)
+    => Assert.Throws<ArgumentException>(() => Generator.GenerateTypeDeclaration(t: type, null, options: new()));
+
+  [Test]
+  public void GenerateTypeDeclarationWithExplicitBaseTypeAndInterfaces_ArgumentOptionsNull()
+    => Assert.Throws<ArgumentNullException>(() => Generator.GenerateTypeDeclarationWithExplicitBaseTypeAndInterfaces(t: typeof(int), null, options: null!));
+
+  [Test]
+  public void GenerateTypeDeclarationWithExplicitBaseTypeAndInterfaces_ArgumentTypeNull()
+    => Assert.Throws<ArgumentNullException>(() => Generator.GenerateTypeDeclarationWithExplicitBaseTypeAndInterfaces(t: null!, null, options: new()));
+
+  [TestCase(typeof(List<int>))]
+  [TestCase(typeof(IEnumerable<int>))]
+  [TestCase(typeof(Action<int>))]
+  [TestCase(typeof(int?))]
+  [TestCase(typeof((int, int)))]
+  public void GenerateTypeDeclarationWithExplicitBaseTypeAndInterfaces_ArgumentTypeIsConstructedGenericType(Type type)
+    => Assert.Throws<ArgumentException>(() => Generator.GenerateTypeDeclarationWithExplicitBaseTypeAndInterfaces(t: type, null, options: new()));
+
+  [Test]
+  public void GenerateMemberDeclaration_ArgumentOptionsNull()
+    => Assert.Throws<ArgumentNullException>(() => Generator.GenerateMemberDeclaration(member: typeof(int).GetMembers().First(), null, options: null!));
+
+  [Test]
+  public void GenerateMemberDeclaration_ArgumentTypeNull()
+    => Assert.Throws<ArgumentNullException>(() => Generator.GenerateMemberDeclaration(member: null!, null, options: new()));
+
+  [Test]
+  public void GenerateGenericParameterConstraintDeclaration_ArgumentOptionsNull()
+  {
+    var genericParameter = typeof(List<>).GetGenericArguments()[0];
+
+    Assert.Throws<ArgumentNullException>(() => Generator.GenerateGenericParameterConstraintDeclaration(genericParameter: genericParameter, null, options: null!));
+  }
+
+  [Test]
+  public void GenerateGenericParameterConstraintDeclaration_ArgumentGenericParameterNull()
+    => Assert.Throws<ArgumentNullException>(() => Generator.GenerateGenericParameterConstraintDeclaration(genericParameter: null!, null, options: new()));
+
+  [TestCase(typeof(int))]
+  [TestCase(typeof(List<>))]
+  public void GenerateGenericParameterConstraintDeclaration_ArgumentGenericParameterIsType(Type type)
+    => Assert.Throws<ArgumentException>(() => Generator.GenerateGenericParameterConstraintDeclaration(genericParameter: type, null, options: new()));
+
+  [TestCase(typeof(List<int>))]
+  [TestCase(typeof(Action<int>))]
+  [TestCase(typeof(int?))]
+  [TestCase(typeof((int, int)))]
+  public void GenerateGenericParameterConstraintDeclaration_ArgumentGenericParameterIsGenericArgument(Type type)
+    => Assert.Throws<ArgumentException>(() => Generator.GenerateGenericParameterConstraintDeclaration(genericParameter: type.GetGenericArguments()[0], null, options: new()));
+
+  [Test]
+  public void GenerateExplicitBaseTypeAndInterfaces_ArgumentOptionsNull()
+    => Assert.Throws<ArgumentNullException>(() => Generator.GenerateExplicitBaseTypeAndInterfaces(t: typeof(int), null, options: null!));
+
+  [Test]
+  public void GenerateExplicitBaseTypeAndInterfaces_ArgumentTypeNull()
+    => Assert.Throws<ArgumentNullException>(() => Generator.GenerateExplicitBaseTypeAndInterfaces(t: null!, null, options: new()));
 }