Merge pull request #400 from ManuelWalz/fix/use-intended-member-generic-arguments

Fix assignment of MemberGenericArguments

Author: alexanderlinne

ArchUnitNET/Domain/Dependencies/MethodCallDependency.cs

@@ -1,5 +1,4 @@
 using System.Collections.Generic;
-using ArchUnitNET.Loader;
 
 namespace ArchUnitNET.Domain.Dependencies
 {
@@ -9,7 +8,7 @@ public MethodCallDependency(IMember originMember, MethodMemberInstance calledMet
             : base(originMember, calledMethodInstance)
         {
             TargetMember = calledMethodInstance.Member;
-            TargetMemberGenericArguments = calledMethodInstance.GenericArguments;
+            TargetMemberGenericArguments = calledMethodInstance.MemberGenericArguments;
         }
 
         public IMember TargetMember { get; }

ArchUnitNETTests/Domain/Dependencies/Members/MethodCallDependencyTests.cs

@@ -33,6 +33,44 @@ public MethodCallDependencyTests()
                 .FirstOrDefault();
         }
 
+        [Fact]
+        public void UsesMemberGenericArguments()
+        {
+            var architecture = StaticTestArchitectures.ArchUnitNETTestArchitecture;
+            var originClass = architecture.GetClassOfType(
+                typeof(ClassWithMethodWithGenericMethodArguments)
+            );
+            var originMember = originClass
+                .GetMembersWithName(
+                    nameof(ClassWithMethodWithGenericMethodArguments.Method).BuildMethodMemberName()
+                )
+                .Single();
+            var targetClass = architecture.GetClassOfType(typeof(ClassWithGenericMethodArguments));
+            var targetMember = targetClass
+                .GetMethodMembersWithName(
+                    nameof(ClassWithGenericMethodArguments.Method).BuildMethodMemberName()
+                )
+                .Single();
+            var memberGenericArgument = new GenericArgument(
+                new TypeInstance<IType>(
+                    architecture.GetClassOfType(typeof(ClassForGenericArgument))
+                )
+            );
+            var methodCallDependency = new MethodCallDependency(
+                targetMember,
+                new MethodMemberInstance(
+                    targetMember,
+                    Enumerable.Empty<GenericArgument>(),
+                    [memberGenericArgument]
+                )
+            );
+
+            Assert.Contains(
+                memberGenericArgument,
+                methodCallDependency.TargetMemberGenericArguments
+            );
+        }
+
         [Theory]
         [ClassData(typeof(MethodDependencyTestBuild.ConstructorTestData))]
         public void ConstructorsAddedToClass(Class classWithConstructors)
@@ -68,6 +106,42 @@ MethodCallDependency expectedDependency
             Assert.True(originMember.HasMemberDependency(expectedDependency));
             Assert.Contains(expectedDependency, originMember.GetMethodCallDependencies());
         }
+
+        [Theory]
+        [ClassData(
+            typeof(MethodDependencyTestBuild.MethodCallGenericConstructorArgumentsDependencyTestData)
+        )]
+        public void MethodCallGenericConstructorArgumentDependenciesAreFound(
+            IMember originMember,
+            MethodCallDependency expectedDependency
+        )
+        {
+            Assert.Contains(
+                originMember.GetMethodCallDependencies(),
+                methodCallDependency =>
+                    methodCallDependency.TargetGenericArguments.SequenceEqual(
+                        expectedDependency.TargetGenericArguments
+                    )
+            );
+        }
+
+        [Theory]
+        [ClassData(
+            typeof(MethodDependencyTestBuild.MethodCallGenericMethodArgumentsDependencyTestData)
+        )]
+        public void MethodCallGenericMethodArgumentDependenciesAreFound(
+            IMember originMember,
+            MethodCallDependency expectedDependency
+        )
+        {
+            Assert.Contains(
+                originMember.GetMethodCallDependencies(),
+                methodCallDependency =>
+                    methodCallDependency.TargetMemberGenericArguments.SequenceEqual(
+                        expectedDependency.TargetMemberGenericArguments
+                    )
+            );
+        }
     }
 
     public class ClassWithMethodA
@@ -99,6 +173,34 @@ public static async void MethodAAsync()
         }
     }
 
+    public class ClassWithMethodWithGenericConstructorArguments
+    {
+        public static void Method()
+        {
+            var classForGenericArguments =
+                new ClassWithGenericConstructorArguments<ClassForGenericArgument>();
+        }
+    }
+
+    // ReSharper disable once UnusedTypeParameter
+    public class ClassWithGenericConstructorArguments<T>;
+
+    public class ClassWithMethodWithGenericMethodArguments
+    {
+        public static void Method()
+        {
+            ClassWithGenericMethodArguments.Method<ClassForGenericArgument>();
+        }
+    }
+
+    public class ClassWithGenericMethodArguments
+    {
+        // ReSharper disable once UnusedTypeParameter
+        public static void Method<T>() { }
+    }
+
+    public class ClassForGenericArgument;
+
     public class ClassWithConstructors
     {
         private FieldType _fieldTest;

ArchUnitNETTests/Domain/Dependencies/Members/MethodDependencyTestBuild.cs

@@ -4,8 +4,8 @@
 using ArchUnitNET.Domain;
 using ArchUnitNET.Domain.Dependencies;
 using ArchUnitNET.Domain.Extensions;
-using ArchUnitNET.Loader;
 using ArchUnitNETTests.Fluent.Extensions;
+using JetBrains.Annotations;
 using Type = System.Type;
 
 namespace ArchUnitNETTests.Domain.Dependencies.Members
@@ -19,7 +19,9 @@ private static object[] BuildMethodCallDependencyTestData(
             Type originType,
             string nameOfOriginMember,
             Type targetType,
-            string nameOfTargetMember
+            string nameOfTargetMember,
+            [CanBeNull] IEnumerable<Type> declaringGenericArgumentsTypes = null,
+            [CanBeNull] IEnumerable<Type> memberGenericArgumentsTypes = null
         )
         {
             var originClass = Architecture.GetClassOfType(originType);
@@ -30,13 +32,22 @@ string nameOfTargetMember
                 originMember,
                 new MethodMemberInstance(
                     targetMember,
-                    Enumerable.Empty<GenericArgument>(),
-                    Enumerable.Empty<GenericArgument>()
+                    CreateGenericArguments(declaringGenericArgumentsTypes ?? []),
+                    CreateGenericArguments(memberGenericArgumentsTypes ?? [])
                 )
             );
             return new object[] { originMember, expectedDependency };
         }
 
+        private static IEnumerable<GenericArgument> CreateGenericArguments(
+            IEnumerable<Type> classTypes
+        )
+        {
+            return classTypes
+                .Select(x => Architecture.GetClassOfType(x))
+                .Select(x => new GenericArgument(new TypeInstance<Class>(x)));
+        }
+
         private static object[] BuildMethodSignatureDependencyTestData(
             Type originType,
             string nameOfOriginMember,
@@ -171,6 +182,58 @@ IEnumerator IEnumerable.GetEnumerator()
             }
         }
 
+        public class MethodCallGenericConstructorArgumentsDependencyTestData : IEnumerable<object[]>
+        {
+            private readonly List<object[]> _methodCallDependencyData = new List<object[]>
+            {
+                BuildMethodCallDependencyTestData(
+                    typeof(ClassWithMethodWithGenericConstructorArguments),
+                    nameof(ClassWithMethodWithGenericConstructorArguments.Method)
+                        .BuildMethodMemberName(),
+                    typeof(ClassWithGenericConstructorArguments<>),
+                    StaticConstants.ConstructorNameBase.BuildMethodMemberName(),
+                    [typeof(ClassForGenericArgument)],
+                    []
+                ),
+            };
+
+            public IEnumerator<object[]> GetEnumerator()
+            {
+                return _methodCallDependencyData.GetEnumerator();
+            }
+
+            IEnumerator IEnumerable.GetEnumerator()
+            {
+                return GetEnumerator();
+            }
+        }
+
+        public class MethodCallGenericMethodArgumentsDependencyTestData : IEnumerable<object[]>
+        {
+            private readonly List<object[]> _methodCallDependencyData = new List<object[]>
+            {
+                BuildMethodCallDependencyTestData(
+                    typeof(ClassWithMethodWithGenericMethodArguments),
+                    nameof(ClassWithMethodWithGenericMethodArguments.Method)
+                        .BuildMethodMemberName(),
+                    typeof(ClassWithGenericMethodArguments),
+                    nameof(ClassWithGenericMethodArguments.Method).BuildMethodMemberName(),
+                    [],
+                    [typeof(ClassForGenericArgument)]
+                ),
+            };
+
+            public IEnumerator<object[]> GetEnumerator()
+            {
+                return _methodCallDependencyData.GetEnumerator();
+            }
+
+            IEnumerator IEnumerable.GetEnumerator()
+            {
+                return GetEnumerator();
+            }
+        }
+
         public class ConstructorTestData : IEnumerable<object[]>
         {
             private readonly List<object[]> _methodCallDependencyData = new List<object[]>