Record method call generic argument types as dependencies

ArchUnitNET/Loader/LoadTasks/AddMethodDependencies.cs

@@ -259,6 +259,16 @@ var calledMethodReference in calledMethodReferences.Except(visitedMethodReferenc
             {
                 visitedMethodReferences.Add(calledMethodReference);
 
+                var calledType = _typeFactory.GetOrCreateStubTypeInstanceFromTypeReference(
+                    calledMethodReference.DeclaringType
+                );
+                var calledMethodMember = _typeFactory.GetOrCreateMethodMemberFromMethodReference(
+                    calledType,
+                    calledMethodReference
+                );
+
+                bodyTypes.AddRange(calledMethodMember.MemberGenericArguments);
+
                 if (calledMethodReference.IsCompilerGenerated())
                 {
                     MethodDefinition calledMethodDefinition;
@@ -314,14 +324,6 @@ var dep in CreateMethodBodyDependenciesRecursive(
                 }
                 else
                 {
-                    var calledType = _typeFactory.GetOrCreateStubTypeInstanceFromTypeReference(
-                        calledMethodReference.DeclaringType
-                    );
-                    var calledMethodMember =
-                        _typeFactory.GetOrCreateMethodMemberFromMethodReference(
-                            calledType,
-                            calledMethodReference
-                        );
                     yield return calledMethodMember;
                 }
             }

ArchUnitNETTests/Dependencies/GenericMemberDependenciesTests.cs

@@ -1,13 +1,71 @@
-namespace ArchUnitNETTests.Dependencies
+using System;
+using System.Linq;
+using ArchUnitNET.Domain;
+using ArchUnitNET.Domain.Dependencies;
+using ArchUnitNET.Domain.Extensions;
+using Xunit;
+
+namespace ArchUnitNETTests.Dependencies
 {
-    public class GenericMemberDependenciesTests { }
+    public class GenericMemberDependenciesTests
+    {
+        [Fact]
+        public void GenericArgumentsFromMethodCallLocalFuncTest()
+        {
+            var architecture = StaticTestArchitectures.ArchUnitNETTestArchitecture;
+            var classWithGenericMethodCall = architecture.GetClassOfType(
+                typeof(ClassWithGenericMethodCall)
+            );
+            var genericArgumentClass = architecture.GetClassOfType(typeof(GenericArgumentClass));
+            var methodMember = (MethodMember)
+                classWithGenericMethodCall.Members.WhereNameIs("OuterFunc()").First();
+            Assert.Contains(
+                methodMember.Dependencies,
+                dependency =>
+                    dependency is BodyTypeMemberDependency bodyTypeMemberDependency
+                    && bodyTypeMemberDependency.Target.Equals(genericArgumentClass)
+            );
+        }
 
-    internal class GenericClass<T>
+        [Fact]
+        public void GenericArgumentsFromMethodCallTest()
+        {
+            var architecture = StaticTestArchitectures.ArchUnitNETTestArchitecture;
+            var classWithGenericMethodCall = architecture.GetClassOfType(
+                typeof(ClassWithGenericMethodCall)
+            );
+            var genericArgumentClass = architecture.GetClassOfType(
+                typeof(OtherGenericArgumentClass)
+            );
+            var methodMember = (MethodMember)
+                classWithGenericMethodCall.Members.WhereNameIs("OuterFunc()").First();
+            Assert.Contains(
+                methodMember.Dependencies,
+                dependency =>
+                    dependency is BodyTypeMemberDependency bodyTypeMemberDependency
+                    && bodyTypeMemberDependency.Target.Equals(genericArgumentClass)
+            );
+        }
+    }
+
+    internal class ClassWithGenericMethodCall
     {
-        public M GenericMethod<M>(T t)
-            where M : new()
+        public void OuterFunc()
+        {
+            LocalFunc<GenericArgumentClass>();
+            PrivateFunc<OtherGenericArgumentClass>();
+
+            void LocalFunc<T>()
+            {
+                throw new NotImplementedException($"Called with type {typeof(T)}");
+            }
+        }
+
+        private static void PrivateFunc<T>()
         {
-            return new M();
+            throw new NotImplementedException($"Called with type {typeof(T)}");
         }
     }
+
+    internal class OtherGenericArgumentClass { }
 }