refactor: inheritance graphs, delegate params, context checks

- MethodInheritanceGraph now uses rooted DAGs for robust traversal, leaf detection, and acyclicity validation
- Adjacency maps and body-filtered implementation graphs added; legacy fields preserved
- MethodCallGraph uses caller consistently and expands interface/virtual resolution via GetRuntimeMethods
- Static constructor patching improves context-bound method detection, including lambda/iterator analysis
- Fixed static field modification chain logic bug
- Delegate context injection logic updated for correctness

Author: CedaryCat

src/OTAPI.UnifiedServerProcess/Core/Analysis/MethodCallAnalysis/MethodCallGraph.cs

@@ -34,15 +34,15 @@ public MethodCallGraph(ILogger logger, ModuleDefinition module, DelegateInvocati
             var unexpectedImplMissMethods = new Dictionary<string, MethodDefinition>();
 
             foreach (var type in module.GetAllTypes()) {
-                foreach (var method in type.Methods) {
-                    if (!method.HasBody)
+                foreach (var caller in type.Methods) {
+                    if (!caller.HasBody)
                         continue;
 
-                    var methodId = method.GetIdentifier();
+                    var methodId = caller.GetIdentifier();
 
-                    var body = method.Body;
+                    var body = caller.Body;
 
-                    var jumpSites = this.GetMethodJumpSites(method);
+                    var jumpSites = this.GetMethodJumpSites(caller);
 
                     foreach (var instruction in body.Instructions) {
                         if (instruction.OpCode != OpCodes.Call && instruction.OpCode != OpCodes.Callvirt && instruction.OpCode != OpCodes.Newobj)
@@ -69,30 +69,30 @@ public MethodCallGraph(ILogger logger, ModuleDefinition module, DelegateInvocati
                             taskRunDeleIndex = 0;
                         }
                         if (taskRunDeleIndex != -1) {
-                            foreach (var path in MonoModCommon.Stack.AnalyzeParametersSources(method, instruction, jumpSites)) {
-                                var loadDelegate = MonoModCommon.Stack.AnalyzeStackTopTypeAllPaths(method, path.ParametersSources[taskRunDeleIndex].Instructions.Last(), jumpSites)
+                            foreach (var path in MonoModCommon.Stack.AnalyzeParametersSources(caller, instruction, jumpSites)) {
+                                var loadDelegate = MonoModCommon.Stack.AnalyzeStackTopTypeAllPaths(caller, path.ParametersSources[taskRunDeleIndex].Instructions.Last(), jumpSites)
                                     .Single();
-                                if (!invocationGraph.TracedDelegates.TryGetValue(DelegateInvocationData.GenerateStackKey(method, loadDelegate.RealPushValueInstruction), out var data)) {
+                                if (!invocationGraph.TracedDelegates.TryGetValue(DelegateInvocationData.GenerateStackKey(caller, loadDelegate.RealPushValueInstruction), out var data)) {
                                     continue;
                                 }
                                 AddMethod(MethodReferenceData.DelegateCall(calleeDef, [.. data.Invocations.Values]));
                             }
                         }
 
-                        IEnumerable<MethodDefinition> methods = [method];
+                        IEnumerable<MethodDefinition> methods = [caller];
                         if (calleeRef.HasThis && calleeRef.Name != ".ctor") {
                             HashSet<MethodDefinition> tempMethods = [];
-                            foreach (var path in MonoModCommon.Stack.AnalyzeParametersSources(method, instruction, jumpSites)) {
-                                foreach (var stackTop in MonoModCommon.Stack.AnalyzeStackTopTypeAllPaths(method, path.ParametersSources[0].Instructions.Last(), jumpSites)) {
+                            foreach (var path in MonoModCommon.Stack.AnalyzeParametersSources(caller, instruction, jumpSites)) {
+                                foreach (var stackTop in MonoModCommon.Stack.AnalyzeStackTopTypeAllPaths(caller, path.ParametersSources[0].Instructions.Last(), jumpSites)) {
                                     var stackType = stackTop.StackTopType?.TryResolve();
                                     if (stackType is null) {
                                         continue;
                                     }
                                     if (stackType.Scope.Name != module.Name) {
-                                        logger.Warn(this, 1, $"Ignore: [type:{stackType.Name}|callee: {calleeRef.GetDebugName()}] by {method.GetDebugName()}");
+                                        logger.Warn(this, 1, $"Ignore: [type:{stackType.Name}|callee: {calleeRef.GetDebugName()}] by {caller.GetDebugName()}");
                                         continue;
                                     }
-                                    var m = stackType?.Methods.FirstOrDefault(m => 
+                                    var m = stackType?.GetRuntimeMethods(true).FirstOrDefault(m => 
                                         m.GetIdentifier(false).EndsWith("." + calleeDef.GetIdentifier(false)) || // implict interface impl
                                         m.GetIdentifier(false) == calleeDef.GetIdentifier(false));
                                     if (m is not null) {
@@ -106,7 +106,7 @@ public MethodCallGraph(ILogger logger, ModuleDefinition module, DelegateInvocati
                         HashSet<MethodDefinition> implementations = [];
                         bool isDelegateInvocation = false;
                         foreach (var m in methods) {
-                            foreach (var impl in this.GetMethodImplementations(method, instruction, jumpSites, out isDelegateInvocation, true)) {
+                            foreach (var impl in this.GetMethodImplementations(caller, instruction, jumpSites, out isDelegateInvocation, true)) {
                                 implementations.Add(impl);
                             }
                         }
@@ -130,10 +130,10 @@ public MethodCallGraph(ILogger logger, ModuleDefinition module, DelegateInvocati
                             usedByMethods = [];
                             usedByMethodsDict[calleeId] = usedByMethods;
                         }
-                        usedByMethods.Add(method);
+                        usedByMethods.Add(caller);
 
                         void AddMethod(MethodReferenceData add) {
-                            // Update usedMethodsDict for the tail method
+                            // Update usedMethodsDict for the tail caller
                             if (!usedMethodsDict.TryGetValue(methodId, out var usedMethods)) {
                                 usedMethods = [];
                                 usedMethodsDict[methodId] = usedMethods;
@@ -142,12 +142,12 @@ void AddMethod(MethodReferenceData add) {
 
                             var implId = add.DirectlyCalledMethod.GetIdentifier();
 
-                            // Update usedByMethodsDict for the implementation method
+                            // Update usedByMethodsDict for the implementation caller
                             if (!usedByMethodsDict.TryGetValue(implId, out var usedByMethods)) {
                                 usedByMethods = [];
                                 usedByMethodsDict[implId] = usedByMethods;
                             }
-                            usedByMethods.Add(method);
+                            usedByMethods.Add(caller);
                         }
                     }
                 }
@@ -184,8 +184,7 @@ void AddMethod(MethodReferenceData add) {
                 MethodDefinition[] usedByMethods = usedByMethodsDict.TryGetValue(methodId, out var ubm)
                     ? [.. ubm]
                     : [];
-
-                methodCallsBuilder.Add(method.GetIdentifier(), new MethodCallData(method, usedMethods, usedByMethods));
+                methodCallsBuilder.Add(methodId, new MethodCallData(method, usedMethods, usedByMethods));
             }
 
             MediatedCallGraph = methodCallsBuilder;