More robust generic parsing (#3)

Author: ATrefzer

CSharpCodeAnalyst/board.txt

@@ -1,12 +1,15 @@
 IMPROVEMENTS
 ---------------------
 
+- SybolEqualityComparer does not work for this application well. Remove it where it is used.
+- Check if the map key -> Symbol is unique. If not use a list of symbols!
+  _elementIdToSymbolMap. Are all locations captured in this case?
+
+
 - Highlight of aggregated edges takes too long. If quick help not visible skip?
 - Performance in general
 
 - Attributes are caught at class or method level. Not for the parameters like [CallerMemberName]
-- Main method is required
-
 
 BUGS
 ---------------------

CodeParser/Parser/Parser.Phase1.cs

@@ -9,7 +9,8 @@ public partial class Parser
 {
     private readonly List<INamedTypeSymbol> _allNamedTypesInSolution = new();
 
-    private readonly Dictionary<IAssemblySymbol, List<GlobalStatementSyntax>> _globalStatementsByAssembly = new(SymbolEqualityComparer.Default);
+    private readonly Dictionary<IAssemblySymbol, List<GlobalStatementSyntax>> _globalStatementsByAssembly =
+        new(SymbolEqualityComparer.Default);
 
 
     private async Task BuildHierarchy(Solution solution)
@@ -30,6 +31,7 @@ private async Task BuildHierarchy(Solution solution)
 
             // Build also a list of all named types in the solution
             // We need this in phase 2 to resolve dependencies
+            // Constructed types are not contained in this list!
             var types = compilation.GetSymbolsWithName(_ => true, SymbolFilter.Type).OfType<INamedTypeSymbol>();
             _allNamedTypesInSolution.AddRange(types);
 
@@ -155,7 +157,7 @@ private void ProcessNodeForHierarchy(SyntaxNode node, SemanticModel semanticMode
                 var assemblySymbol = semanticModel.Compilation.Assembly;
                 _globalStatementsByAssembly[assemblySymbol].Add(globalStatementSyntax);
                 return; // We'll handle these collectively later
-                        
+
             // Add more cases as needed (e.g., for events, delegates, etc.)
         }
 

CodeParser/Parser/Parser.Phase2.Properties.cs

@@ -53,7 +53,8 @@ private void AnalyzePropertyBody(Solution solution, CodeElement propertyElement,
                 {
                     if (propertyDeclaration.ExpressionBody != null)
                     {
-                        AnalyzeMethodBody(propertyElement, propertyDeclaration.ExpressionBody.Expression, semanticModel);
+                        AnalyzeMethodBody(propertyElement, propertyDeclaration.ExpressionBody.Expression,
+                            semanticModel);
                     }
                     else if (propertyDeclaration.AccessorList != null)
                     {
@@ -73,19 +74,11 @@ private void AnalyzePropertyBody(Solution solution, CodeElement propertyElement,
             }
         }
     }
+
     private void AddPropertyDependency(CodeElement sourceElement, IPropertySymbol propertySymbol,
         DependencyType dependencyType, List<SourceLocation> locations)
     {
-        if (_symbolKeyToElementMap.TryGetValue(GetSymbolKey(propertySymbol), out var targetElement))
-        {
-            AddDependency(sourceElement, dependencyType, targetElement, locations);
-        }
-        else if (_symbolKeyToElementMap.TryGetValue(GetSymbolKey(propertySymbol.ContainingType),
-                     out var containingTypeElement))
-        {
-            // If we don't have the property itself in our map, add a dependency to its containing type
-            AddDependency(sourceElement, dependencyType, containingTypeElement, locations);
-        }
+        AddDependencyWithFallbackToContainingType(sourceElement, propertySymbol, dependencyType, locations);
     }
 
     private IPropertySymbol? GetImplementedInterfaceProperty(IPropertySymbol propertySymbol)

CodeParser/Parser/Parser.Phase2.cs

@@ -16,6 +16,7 @@ private void AnalyzeDependencies(Solution solution)
         var loop = 0;
         foreach (var element in _codeGraph.Nodes.Values)
         {
+            // TODO atr Analyze if we can have more than one symbol!
             var symbol = _elementIdToSymbolMap[element.Id];
 
             if (symbol is IEventSymbol eventSymbol)
@@ -75,13 +76,13 @@ private void AnalyzeGlobalStatementsForAssembly(Solution solution)
             }
 
             // Find the existing assembly element
-            var symbolKey = GetSymbolKey(assemblySymbol);
+            var symbolKey = assemblySymbol.Key();
             var assemblyElement = _symbolKeyToElementMap[symbolKey];
 
             // Create a dummy class for this assembly's global statements
             var dummyClassId = Guid.NewGuid().ToString();
             var dummyClassName = "GlobalStatements";
-            var dummyClassFullName = BuildSymbolName(assemblySymbol) + "." + dummyClassName;
+            var dummyClassFullName = assemblySymbol.BuildSymbolName() + "." + dummyClassName;
             var dummyClass = new CodeElement(dummyClassId, CodeElementType.Class, dummyClassName, dummyClassFullName,
                 assemblyElement);
             _codeGraph.Nodes[dummyClassId] = dummyClass;
@@ -108,6 +109,7 @@ private void AnalyzeGlobalStatementsForAssembly(Solution solution)
             }
         }
     }
+
     private void AnalyzeAttributeDependencies(CodeElement element, ISymbol symbol)
     {
         foreach (var attributeData in symbol.GetAttributes())
@@ -238,7 +240,7 @@ private void FindImplementations(CodeElement methodElement, IMethodSymbol method
             var implementingMethod = implementingType.FindImplementationForInterfaceMember(methodSymbol);
             if (implementingMethod != null)
             {
-                var implementingElement = _symbolKeyToElementMap.GetValueOrDefault(GetSymbolKey(implementingMethod));
+                var implementingElement = _symbolKeyToElementMap.GetValueOrDefault(implementingMethod.Key());
                 if (implementingElement != null)
                 {
                     // Note: Implementations for external methods are not in our map
@@ -283,20 +285,10 @@ private bool IsTypeDerivedFrom(INamedTypeSymbol type, INamedTypeSymbol baseType)
     private void AddMethodOverrideDependency(CodeElement sourceElement, IMethodSymbol methodSymbol,
         List<SourceLocation> locations)
     {
-        if (_symbolKeyToElementMap.TryGetValue(GetSymbolKey(methodSymbol), out var targetElement))
-        {
-            AddDependency(sourceElement, DependencyType.Overrides, targetElement, locations);
-        }
-        else if (_symbolKeyToElementMap.TryGetValue(GetSymbolKey(methodSymbol.ContainingType),
-                     out var containingTypeElement))
-        {
-            // Trace.WriteLine("Method override not captured. It is likely that the base method is generic or external code.");
-
-            // If we don't have the method itself in our map, add a dependency to its containing type
-            // Maybe we override a framework method. Happens also if the base method is a generic one.
-            // In this case the GetSymbolKey is different. One uses T, the overriding method uses the actual type.
-            AddDependency(sourceElement, DependencyType.Overrides, containingTypeElement, locations);
-        }
+        // If we don't have the method itself in our map, add a dependency to its containing type
+        // Maybe we override a framework method. Happens also if the base method is a generic one.
+        // In this case the GetSymbolKey is different. One uses T, the overriding method uses the actual type.
+        AddDependencyWithFallbackToContainingType(sourceElement, methodSymbol, DependencyType.Overrides, locations);
     }
 
     private void AnalyzeFieldDependencies(CodeElement fieldElement, IFieldSymbol fieldSymbol)
@@ -378,20 +370,13 @@ private void AnalyzeMethodBody(CodeElement sourceElement, SyntaxNode node, Seman
 
     private void AddEventUsageDependency(CodeElement sourceElement, IEventSymbol eventSymbol)
     {
-        if (_symbolKeyToElementMap.TryGetValue(GetSymbolKey(eventSymbol), out var eventElement))
-        {
-            AddDependency(sourceElement, DependencyType.Uses, eventElement, []);
-        }
-        else if (_symbolKeyToElementMap.TryGetValue(GetSymbolKey(eventSymbol.ContainingType),
-                     out var containingTypeElement))
-        {
-            // If we don't have the event itself in our map, add a dependency to its containing type
-            AddDependency(sourceElement, DependencyType.Uses, containingTypeElement, []);
-        }
+        // If we don't have the event itself in our map, add a dependency to its containing type
+        AddDependencyWithFallbackToContainingType(sourceElement, eventSymbol, DependencyType.Uses, []);
     }
 
     private void AddCallsDependency(CodeElement sourceElement, IMethodSymbol methodSymbol, SourceLocation location)
     {
+        //Debug.Assert(FindCodeElement(methodSymbol)!= null);
         //Trace.WriteLine($"Adding call dependency: {sourceElement.Name} -> {methodSymbol.Name}");
 
         if (methodSymbol.IsExtensionMethod)
@@ -400,16 +385,13 @@ private void AddCallsDependency(CodeElement sourceElement, IMethodSymbol methodS
             methodSymbol = methodSymbol.ReducedFrom ?? methodSymbol;
         }
 
-        if (_symbolKeyToElementMap.TryGetValue(GetSymbolKey(methodSymbol), out var targetElement))
+        if (methodSymbol.IsGenericMethod && FindCodeElement(methodSymbol) is null)
         {
-            AddDependency(sourceElement, DependencyType.Calls, targetElement, [location]);
+            methodSymbol = methodSymbol.OriginalDefinition;
         }
+
         // If the method is not in our map, we might want to add a dependency to its containing type
-        else if (_symbolKeyToElementMap.TryGetValue(GetSymbolKey(methodSymbol.ContainingType),
-                     out var containingTypeElement))
-        {
-            AddDependency(sourceElement, DependencyType.Calls, containingTypeElement, [location]);
-        }
+        AddDependencyWithFallbackToContainingType(sourceElement, methodSymbol, DependencyType.Calls, [location]);
     }
 
 
@@ -442,38 +424,8 @@ private void AddTypeDependency(CodeElement sourceElement, ITypeSymbol typeSymbol
                 break;
 
             case INamedTypeSymbol namedTypeSymbol:
-                var symbolKey = GetSymbolKey(namedTypeSymbol);
-                if (_symbolKeyToElementMap.TryGetValue(symbolKey, out var targetElement))
-                {
-                    // The type is internal (part of our codebase)
-                    AddDependency(sourceElement, dependencyType, targetElement, location != null ? [location] : []);
-
-                    if (namedTypeSymbol.IsGenericType)
-                    {
-                        // Add "Uses" dependencies to type arguments
-                        foreach (var typeArg in namedTypeSymbol.TypeArguments)
-                        {
-                            AddTypeDependency(sourceElement, typeArg, DependencyType.Uses, location);
-                        }
-                    }
-                }
-                else
-                {
-                    // The type is external
-
-                    // Optionally, you might want to track external dependencies
-                    // AddExternalDependency(sourceElement, namedTypeSymbol, dependencyType, location);
-                    if (namedTypeSymbol.IsGenericType)
-                    {
-                        // For example List<MyType>
-                        // Add "Uses" dependencies to type arguments, which might be internal
-                        foreach (var typeArg in namedTypeSymbol.TypeArguments)
-                        {
-                            AddTypeDependency(sourceElement, typeArg, DependencyType.Uses, location);
-                        }
-                    }
-                }
 
+                AddNamedTypeDependency(sourceElement, namedTypeSymbol, dependencyType, location);
                 break;
 
             case IPointerTypeSymbol pointerTypeSymbol:
@@ -491,8 +443,8 @@ private void AddTypeDependency(CodeElement sourceElement, ITypeSymbol typeSymbol
                 break;
             default:
                 // Handle other type symbols (e.g., type parameters)
-                symbolKey = GetSymbolKey(typeSymbol);
-                if (_symbolKeyToElementMap.TryGetValue(symbolKey, out targetElement))
+                var symbolKey = typeSymbol.Key();
+                if (_symbolKeyToElementMap.TryGetValue(symbolKey, out var targetElement))
                 {
                     AddDependency(sourceElement, dependencyType, targetElement, location != null ? [location] : []);
                 }
@@ -501,6 +453,44 @@ private void AddTypeDependency(CodeElement sourceElement, ITypeSymbol typeSymbol
         }
     }
 
+    private void AddNamedTypeDependency(CodeElement sourceElement, INamedTypeSymbol namedTypeSymbol,
+        DependencyType dependencyType,
+        SourceLocation? location)
+    {
+        var targetElement = FindCodeElement(namedTypeSymbol);
+        if (targetElement != null)
+        {
+            // The type is internal (part of our codebase)
+            AddDependency(sourceElement, dependencyType, targetElement, location != null ? [location] : []);
+        }
+        else
+        {
+            // The type is external or a constructed generic type
+            // Note the constructed type is not in our CodeElement map!
+            // It is not found in phase1 the way we parse it but the original definition is.
+            var originalDefinition = namedTypeSymbol.OriginalDefinition;
+            var originalSymbolKey = originalDefinition.Key();
+
+            if (_symbolKeyToElementMap.TryGetValue(originalSymbolKey, out var originalTargetElement))
+            {
+                // We found the original definition, add dependency to it
+                AddDependency(sourceElement, dependencyType, originalTargetElement, location != null ? [location] : []);
+            }
+            // The type is truly external, you might want to log this or handle it differently
+            // AddExternalDependency(sourceElement, namedTypeSymbol, dependencyType, location);
+        }
+
+        if (namedTypeSymbol.IsGenericType)
+        {
+            // Add "Uses" dependencies to type arguments
+            foreach (var typeArg in namedTypeSymbol.TypeArguments)
+            {
+                AddTypeDependency(sourceElement, typeArg, DependencyType.Uses, location);
+            }
+        }
+    }
+
+
     private void AnalyzeIdentifier(CodeElement sourceElement, IdentifierNameSyntax identifierSyntax,
         SemanticModel semanticModel)
     {
@@ -517,7 +507,7 @@ private void AnalyzeIdentifier(CodeElement sourceElement, IdentifierNameSyntax i
 
         if (symbolInfo.Symbol is IFieldSymbol fieldSymbol)
         {
-            AddFieldDependency(sourceElement, fieldSymbol, DependencyType.Uses);
+            AddDependencyWithFallbackToContainingType(sourceElement, fieldSymbol, DependencyType.Uses);
         }
     }
 
@@ -533,7 +523,7 @@ private void AnalyzeMemberAccess(CodeElement sourceElement, MemberAccessExpressi
         }
         else if (symbolInfo.Symbol is IFieldSymbol fieldSymbol)
         {
-            AddFieldDependency(sourceElement, fieldSymbol, DependencyType.Uses);
+            AddDependencyWithFallbackToContainingType(sourceElement, fieldSymbol, DependencyType.Uses);
         }
     }
 
@@ -543,27 +533,40 @@ private void AnalyzeMemberAccess(CodeElement sourceElement, MemberAccessExpressi
     private void AddPropertyCallDependency(CodeElement sourceElement, IPropertySymbol propertySymbol,
         List<SourceLocation> locations)
     {
-        if (_symbolKeyToElementMap.TryGetValue(GetSymbolKey(propertySymbol), out var targetElement))
+        AddDependencyWithFallbackToContainingType(sourceElement, propertySymbol, DependencyType.Calls, locations);
+    }
+
+    private void AddDependencyWithFallbackToContainingType(CodeElement sourceElement, ISymbol symbol,
+        DependencyType dependencyType, List<SourceLocation>? locations = null)
+    {
+        // If we don't have the property itself in our map, add a dependency to its containing type
+        if (locations == null)
+        {
+            locations = [];
+        }
+
+        var targetElement = FindCodeElement(symbol);
+        if (targetElement != null)
         {
-            AddDependency(sourceElement, DependencyType.Calls, targetElement, locations);
+            AddDependency(sourceElement, dependencyType, targetElement, locations);
+            return;
         }
-        else if (_symbolKeyToElementMap.TryGetValue(GetSymbolKey(propertySymbol.ContainingType),
-                     out var containingTypeElement))
+
+        var containingTypeElement = FindCodeElement(symbol.ContainingType);
+        if (containingTypeElement != null)
         {
-            AddDependency(sourceElement, DependencyType.Calls, containingTypeElement, locations);
+            AddDependency(sourceElement, dependencyType, containingTypeElement, locations);
         }
     }
 
-    private void AddFieldDependency(CodeElement sourceElement, IFieldSymbol fieldSymbol, DependencyType dependencyType)
+    private CodeElement? FindCodeElement(ISymbol? symbol)
     {
-        if (_symbolKeyToElementMap.TryGetValue(GetSymbolKey(fieldSymbol), out var targetElement))
+        if (symbol is null)
         {
-            AddDependency(sourceElement, dependencyType, targetElement, []);
-        }
-        else if (_symbolKeyToElementMap.TryGetValue(GetSymbolKey(fieldSymbol.ContainingType),
-                     out var containingTypeElement))
-        {
-            AddDependency(sourceElement, dependencyType, containingTypeElement, []);
+            return null;
         }
+
+        _symbolKeyToElementMap.TryGetValue(symbol.Key(), out var element);
+        return element;
     }
 }