Improvements

- Recognize access to properties
- Follow incoming calls recursive
- Add parents for marked elements

Author: ATrefzer

CSharpCodeAnalyst/App.xaml.cs

@@ -58,10 +58,6 @@ protected override void OnStartup(StartupEventArgs e)
         // Context-sensitive help triggered in the graph, handled in the main view model
         messaging.Subscribe<QuickInfoUpdate>(viewModel.HandleUpdateQuickInfo);
 
-        // Adding parent container triggered in graph, handled in the tree view model
-        // Sends back a AddNodeToGraphRequest.
-        messaging.Subscribe<AddParentContainerRequest>(treeViewModel.HandleAddParentContainerRequest);
-
         messaging.Subscribe<CycleCalculationComplete>(cycleViewModel.HandleCycleCalculationComplete);
 
         messaging.Subscribe<DeleteFromModelRequest>(viewModel.HandleDeleteFromModel);

CSharpCodeAnalyst/Common/AddParentContainerRequest.cs

@@ -4,11 +4,15 @@ namespace CSharpCodeAnalyst.Exploration;
 
 public class CodeGraphExplorer : ICodeGraphExplorer
 {
+    private List<Dependency> _allDependencies = [];
     private CodeGraph? _codeGraph;
 
     public void LoadCodeGraph(CodeGraph graph)
     {
         _codeGraph = graph;
+
+        // Clear all cached data
+        _allDependencies = [];
     }
 
     public List<CodeElement> GetElements(List<string> ids)
@@ -33,6 +37,28 @@ public List<CodeElement> GetElements(List<string> ids)
         return elements;
     }
 
+    public SearchResult FindParents(List<string> ids)
+    {
+        if (_codeGraph is null)
+        {
+            return new SearchResult([], []);
+        }
+
+        var parents = new HashSet<CodeElement>();
+        foreach (var id in ids)
+        {
+            if (_codeGraph.Nodes.TryGetValue(id, out var element))
+            {
+                if (element.Parent is not null)
+                {
+                    parents.Add(element.Parent);
+                }
+            }
+        }
+
+        return new SearchResult(parents, []);
+    }
+
     /// <summary>
     ///     Returns all dependencies that link the given nodes (ids).
     /// </summary>
@@ -62,13 +88,14 @@ public Invocation FindIncomingCalls(string id)
 
         var method = _codeGraph.Nodes[id];
 
-        var callDependencies = GetCallDependencies();
-        var calls = callDependencies.Where(call => call.TargetId == method.Id).ToArray();
+        var allCalls = GetDependencies(d => d.Type == DependencyType.Calls);
+        var calls = allCalls.Where(call => call.TargetId == method.Id).ToArray();
         var methods = calls.Select(d => _codeGraph.Nodes[d.SourceId]);
 
         return new Invocation(methods, calls);
     }
 
+
     public Invocation FindIncomingCallsRecursive(string id)
     {
         ArgumentNullException.ThrowIfNull(id);
@@ -83,10 +110,10 @@ public Invocation FindIncomingCallsRecursive(string id)
         var processingQueue = new Queue<CodeElement>();
         processingQueue.Enqueue(method);
 
-        var allCalls = new HashSet<Dependency>();
-        var allMethods = new HashSet<CodeElement>();
+        var foundCalls = new HashSet<Dependency>();
+        var foundMethods = new HashSet<CodeElement>();
 
-        var callDependencies = GetCallDependencies();
+        var allCalls = GetDependencies(d => d.Type == DependencyType.Calls);
 
         var processed = new HashSet<string>();
         while (processingQueue.Any())
@@ -97,19 +124,74 @@ public Invocation FindIncomingCallsRecursive(string id)
                 continue;
             }
 
-            var calls = callDependencies.Where(call => call.TargetId == element.Id).ToArray();
-            allCalls.UnionWith(calls);
+            var calls = allCalls.Where(call => call.TargetId == element.Id).ToArray();
+            foundCalls.UnionWith(calls);
 
             var methods = calls.Select(d => _codeGraph.Nodes[d.SourceId]).ToArray();
-            allMethods.UnionWith(methods);
+            foundMethods.UnionWith(methods);
 
             foreach (var methodToExplore in methods)
             {
                 processingQueue.Enqueue(_codeGraph.Nodes[methodToExplore.Id]);
             }
         }
 
-        return new Invocation(allMethods, allCalls);
+        return new Invocation(foundMethods, foundCalls);
+    }
+
+
+    public SearchResult FollowIncomingCallsRecursive(string id)
+    {
+        ArgumentNullException.ThrowIfNull(id);
+
+        if (_codeGraph is null)
+        {
+            return new SearchResult([], []);
+        }
+
+        var allImplementsAndOverrides =
+            GetDependencies(d => d.Type is DependencyType.Implements or DependencyType.Overrides);
+        var allCalls = GetDependencies(d => d.Type == DependencyType.Calls);
+
+        var method = _codeGraph.Nodes[id];
+
+        var processingQueue = new Queue<CodeElement>();
+        processingQueue.Enqueue(method);
+
+        var foundDependencies = new HashSet<Dependency>();
+        var foundElements = new HashSet<CodeElement>();
+
+
+        var processed = new HashSet<string>();
+        while (processingQueue.Any())
+        {
+            var element = processingQueue.Dequeue();
+            if (!processed.Add(element.Id))
+            {
+                continue;
+            }
+
+            // Calls
+            var calls = allCalls.Where(call => call.TargetId == element.Id).ToArray();
+            foundDependencies.UnionWith(calls);
+            var callSources = calls.Select(d => _codeGraph.Nodes[d.SourceId]).ToHashSet();
+            foundElements.UnionWith(callSources);
+
+            // Abstractions. Sometimes the abstractions is called.
+            var abstractions = allImplementsAndOverrides.Where(d => d.SourceId == element.Id).ToArray();
+            foundDependencies.UnionWith(abstractions);
+            var abstractionTargets = abstractions.Select(d => _codeGraph.Nodes[d.TargetId]).ToHashSet();
+            foundElements.UnionWith(abstractionTargets);
+
+            // Follow new leads
+            var methodsToExplore = abstractionTargets.Union(callSources);
+            foreach (var methodToExplore in methodsToExplore)
+            {
+                processingQueue.Enqueue(_codeGraph.Nodes[methodToExplore.Id]);
+            }
+        }
+
+        return new SearchResult(foundElements, foundDependencies);
     }
 
     /// <summary>
@@ -264,18 +346,24 @@ public SearchResult FindIncomingDependencies(string id)
         return new SearchResult(elements, dependencies);
     }
 
-    private List<Dependency> GetCallDependencies()
+    private List<Dependency> GetCachedDependencies()
     {
         if (_codeGraph is null)
         {
             return [];
         }
 
-        var callDependencies = _codeGraph.Nodes.Values
-            .SelectMany(node => node.Dependencies)
-            .Where(d => d.Type == DependencyType.Calls)
-            .ToList();
-        return callDependencies;
+        if (_allDependencies.Count == 0)
+        {
+            _allDependencies = _codeGraph.GetAllDependencies().ToList();
+        }
+
+        return _allDependencies;
+    }
+
+    private List<Dependency> GetDependencies(Func<Dependency, bool> filter)
+    {
+        return GetCachedDependencies().Where(filter).ToList();
     }
 
     private HashSet<Dependency> FindInheritsAndImplementsRelationships()

CSharpCodeAnalyst/Exploration/CodeGraphExplorer.cs

@@ -6,7 +6,17 @@ public interface ICodeGraphExplorer
 {
     Invocation FindIncomingCalls(string id);
     Invocation FindOutgoingCalls(string id);
+
+    /// <summary>
+    /// Follows all incoming calls recursively.
+    /// </summary>
     Invocation FindIncomingCallsRecursive(string id);
+
+    /// <summary>
+    /// Traces back callers of the given method. Includes also abstractions and their callers
+    /// </summary>
+    SearchResult FollowIncomingCallsRecursive(string id);
+
     SearchResult FindFullInheritanceTree(string id);
 
     /// <summary>
@@ -28,4 +38,5 @@ public interface ICodeGraphExplorer
     SearchResult FindIncomingDependencies(string id);
     void LoadCodeGraph(CodeGraph graph);
     List<CodeElement> GetElements(List<string> ids);
+    SearchResult FindParents(List<string> ids);
 }

CSharpCodeAnalyst/Exploration/ICodeGraphExplorer.cs

@@ -296,7 +296,7 @@ private void RefreshGraph()
     {
         if (_msaglViewer != null)
         {
-            var graph = _msaglBuilder.CreateGraphFromCodeStructure(_clonedCodeGraph, _presentationState,
+            var graph = _msaglBuilder.CreateGraph(_clonedCodeGraph, _presentationState,
                 _showFlatGraph);
 
             _renderOption.Apply(graph);