Registration in lambda (#37)

Find event registrations in lambdas

Author: ATrefzer

CSharpCodeAnalyst/Analyzers/EventRegistration/Analyzer.cs

@@ -57,7 +57,7 @@ public bool IsDirty()
 
     public event EventHandler? DataChanged;
 
-    private static List<Result> FindImbalances(CodeGraph originalGraph)
+    public static List<Result> FindImbalances(CodeGraph originalGraph)
     {
         var relationships = originalGraph.GetAllRelationships().Where(r => r.Type == RelationshipType.Handles).ToHashSet();
 

CSharpCodeAnalyst/Analyzers/EventRegistration/Result.cs

@@ -2,7 +2,7 @@
 
 namespace CSharpCodeAnalyst.Analyzers.EventRegistration;
 
-internal class Result
+public class Result
 {
     public Result(CodeElement handler, CodeElement evt, List<SourceLocation> locations)
     {

CSharpCodeAnalyst/Areas/TreeArea/TreeViewModel.cs

@@ -89,15 +89,15 @@ public string SearchText
 
     private void OnSelectedItemChanged(TreeItemViewModel item)
     {
-        if (item?.CodeElement != null)
+        if (item.CodeElement != null)
         {
             _lastSelectedCodeElement = item.CodeElement.Id;
         }
     }
 
     private bool RefactoringCanMoveCodeElement(TreeItemViewModel tvm)
     {
-        var id = tvm?.CodeElement?.Id;
+        var id = tvm.CodeElement?.Id;
         return id != null && _refactoringService.CanMoveCodeElements([id]);
     }
 
@@ -114,16 +114,14 @@ private void RefactoringMoveCodeElement(TreeItemViewModel? tvm)
 
     private bool RefactoringCanSetMovementTarget(TreeItemViewModel tvm)
     {
-        return _refactoringService.CanSetMovementTarget(tvm?.CodeElement?.Id);
+        return _refactoringService.CanSetMovementTarget(tvm.CodeElement?.Id);
     }
 
     private void RefactoringSetMovementTarget(TreeItemViewModel tvm)
     {
-        _refactoringService.SetMovementTarget(tvm?.CodeElement?.Id);
+        _refactoringService.SetMovementTarget(tvm.CodeElement?.Id);
     }
 
-
-
     private static void OnCopyToClipboard(TreeItemViewModel vm)
     {
         var text = vm.CodeElement?.FullName;

CodeParser/Parser/ISyntaxNodeHandler.cs

@@ -12,24 +12,32 @@ public interface ISyntaxNodeHandler
     void AnalyzeInvocation(CodeElement sourceElement, InvocationExpressionSyntax invocationSyntax,
         SemanticModel semanticModel);
 
-    void AnalyzeAssignment(CodeElement sourceElement, AssignmentExpressionSyntax assignmentExpression,
+    /// <summary>
+    ///     Analyzes assignment expressions for event registration/unregistration.
+    ///     Property/field access on left and right sides is handled by the walker's normal traversal.
+    /// </summary>
+    void AnalyzeEventRegistrationAssignment(CodeElement sourceElement, AssignmentExpressionSyntax assignmentExpression,
         SemanticModel semanticModel);
 
     /// <summary>
     ///     Analyzes standalone identifier references (fields, properties, etc.).
     ///     Ownership: Handles ONLY standalone identifiers. Identifiers that are part of
     ///     MemberAccessExpressions are NOT visited here - they're handled by AnalyzeMemberAccess.
+    ///     The propertyAccessType parameter controls whether property access creates "Calls" or "Uses" relationships.
+    ///     Default is "Calls" for method bodies; lambda bodies should pass "Uses" because we don't know when/if the lambda executes.
     /// </summary>
     void AnalyzeIdentifier(CodeElement sourceElement, IdentifierNameSyntax identifierSyntax,
-        SemanticModel semanticModel);
+        SemanticModel semanticModel, RelationshipType propertyAccessType = RelationshipType.Calls);
 
     /// <summary>
     ///     Analyzes member access expressions (obj.Property, obj.Field, obj.Event).
     ///     Ownership: Handles the member being accessed (the .Name part on the right side).
     ///     The Expression (left side) is handled by the walker, which will visit it independently.
+    ///     The propertyAccessType parameter controls whether property access creates "Calls" or "Uses" relationships.
+    ///     Default is "Calls" for method bodies; lambda bodies should pass "Uses" because we don't know when/if the lambda executes.
     /// </summary>
     void AnalyzeMemberAccess(CodeElement sourceElement, MemberAccessExpressionSyntax memberAccessSyntax,
-        SemanticModel semanticModel);
+        SemanticModel semanticModel, RelationshipType propertyAccessType = RelationshipType.Calls);
 
     void AnalyzeArgument(CodeElement sourceElement, ArgumentSyntax argumentSyntax, SemanticModel semanticModel);
 

CodeParser/Parser/LambdaBodyWalker.cs

@@ -85,37 +85,34 @@ public override void VisitInvocationExpression(InvocationExpressionSyntax node)
         base.VisitInvocationExpression(node);
     }
 
-    // ReSharper disable once RedundantOverriddenMember
     public override void VisitAssignmentExpression(AssignmentExpressionSyntax node)
     {
-        // We need to walk further to capture following expressions:
-        // Traversal.Dfs(newParent, n => n.FullName = n.GetFullPath());
+        // Track event registration/unregistration (handled by AnalyzeAssignment)
+        // Property/field access on both sides is handled by the walker's normal traversal,
+        // which correctly uses "Uses" relationships for lambdas (see VisitIdentifierName and VisitMemberAccessExpression)
+        Analyzer.AnalyzeEventRegistrationAssignment(SourceElement, node, SemanticModel);
         base.VisitAssignmentExpression(node);
     }
 
-    public override void VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
+    /// <summary>
+    ///     Visit standalone identifiers (properties, fields, etc.).
+    ///     Uses "Uses" relationship for lambda bodies (we don't know when/if lambda executes).
+    ///     Examples: x => MyProperty (standalone), not obj.MyProperty (that's MemberAccess)
+    /// </summary>
+    public override void VisitIdentifierName(IdentifierNameSyntax node)
     {
-        // Track member references (properties, fields, events) with "Uses" relationship
-        var symbolInfo = SemanticModel.GetSymbolInfo(node);
-        var symbol = symbolInfo.Symbol;
-        var location = node.GetSyntaxLocation();
+        Analyzer.AnalyzeIdentifier(SourceElement, node, SemanticModel, RelationshipType.Uses);
+        base.VisitIdentifierName(node);
+    }
 
-        if (symbol is IPropertySymbol propertySymbol)
-        {
-            Analyzer.AddSymbolRelationshipPublic(
-                SourceElement, propertySymbol, RelationshipType.Uses, [location], RelationshipAttribute.None);
-        }
-        else if (symbol is IFieldSymbol fieldSymbol)
-        {
-            Analyzer.AddSymbolRelationshipPublic(
-                SourceElement, fieldSymbol, RelationshipType.Uses, [location], RelationshipAttribute.None);
-        }
-        else if (symbol is IEventSymbol eventSymbol)
-        {
-            Analyzer.AddSymbolRelationshipPublic(
-                SourceElement, eventSymbol, RelationshipType.Uses, [location], RelationshipAttribute.None);
-        }
+    public override void VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
+    {
+        // Delegate to AnalyzeMemberAccess with "Uses" relationship type for lambdas
+        // Same rationale as VisitAssignmentExpression - we don't know when/if the lambda executes
+        Analyzer.AnalyzeMemberAccess(SourceElement, node, SemanticModel, RelationshipType.Uses);
 
+        // Now safe to call base traversal since VisitIdentifierName is overridden in this class
+        // and will use RelationshipType.Uses (not the default Calls)
         base.VisitMemberAccessExpression(node);
     }
 

CodeParser/Parser/MethodBodyWalker.cs

@@ -16,6 +16,17 @@ public MethodBodyWalker(ISyntaxNodeHandler analyzer, CodeElement sourceElement,
     {
     }
 
+    /// <summary>
+    ///     Visit standalone identifiers (properties, fields, etc.).
+    ///     Uses "Calls" relationship for method bodies.
+    ///     Examples: MyProperty (standalone), not obj.MyProperty (that's MemberAccess)
+    /// </summary>
+    public override void VisitIdentifierName(IdentifierNameSyntax node)
+    {
+        Analyzer.AnalyzeIdentifier(SourceElement, node, SemanticModel, RelationshipType.Calls);
+        base.VisitIdentifierName(node);
+    }
+
     public override void VisitInvocationExpression(InvocationExpressionSyntax node)
     {
         Analyzer.AnalyzeInvocation(SourceElement, node, SemanticModel);
@@ -25,7 +36,7 @@ public override void VisitInvocationExpression(InvocationExpressionSyntax node)
 
     public override void VisitAssignmentExpression(AssignmentExpressionSyntax node)
     {
-        Analyzer.AnalyzeAssignment(SourceElement, node, SemanticModel);
+        Analyzer.AnalyzeEventRegistrationAssignment(SourceElement, node, SemanticModel);
         base.VisitAssignmentExpression(node);
     }
 

CodeParser/Parser/RelationshipAnalyzer.cs

@@ -102,14 +102,11 @@ public void AnalyzeInvocation(CodeElement sourceElement, InvocationExpressionSyn
         }
     }
 
-    public void AnalyzeAssignment(CodeElement sourceElement, AssignmentExpressionSyntax assignmentExpression,
+    public void AnalyzeEventRegistrationAssignment(CodeElement sourceElement, AssignmentExpressionSyntax assignmentExpression,
         SemanticModel semanticModel)
     {
-        // Analyze the left side of the assignment (target)
-        AnalyzeExpressionForPropertyAccess(sourceElement, assignmentExpression.Left, semanticModel);
-
-        // Analyze the right side of the assignment (value)
-        AnalyzeExpressionForPropertyAccess(sourceElement, assignmentExpression.Right, semanticModel);
+        // Note: Property/field access on left and right sides is handled by the walker's normal traversal
+        // (VisitIdentifierName and VisitMemberAccessExpression). We only need to handle event registration/unregistration here.
 
         var isRegistration = assignmentExpression.IsKind(SyntaxKind.AddAssignmentExpression);
         var isUnregistration = assignmentExpression.IsKind(SyntaxKind.SubtractAssignmentExpression);
@@ -179,7 +176,7 @@ public void AnalyzeTypeSyntax(CodeElement sourceElement, SemanticModel semanticM
     ///     <inheritdoc cref="ISyntaxNodeHandler.AnalyzeIdentifier" />
     /// </summary>
     public void AnalyzeIdentifier(CodeElement sourceElement, IdentifierNameSyntax identifierSyntax,
-        SemanticModel semanticModel)
+        SemanticModel semanticModel, RelationshipType propertyAccessType = RelationshipType.Calls)
     {
         var symbolInfo = semanticModel.GetSymbolInfo(identifierSyntax);
         var symbol = symbolInfo.Symbol;
@@ -190,14 +187,14 @@ public void AnalyzeIdentifier(CodeElement sourceElement, IdentifierNameSyntax id
         if (symbol is IPropertySymbol propertySymbol)
         {
             var location = identifierSyntax.GetSyntaxLocation();
-            AddPropertyCallRelationship(sourceElement, propertySymbol, [location], RelationshipAttribute.None);
+            AddRelationshipWithFallbackToContainingType(sourceElement, propertySymbol, propertyAccessType, [location], RelationshipAttribute.None);
         }
         else if (symbol is IFieldSymbol fieldSymbol)
         {
             var location = identifierSyntax.GetSyntaxLocation();
             AddRelationshipWithFallbackToContainingType(sourceElement, fieldSymbol, RelationshipType.Uses, [location], RelationshipAttribute.None);
         }
-        else if (symbol is IEventSymbol eventSymbol) 
+        else if (symbol is IEventSymbol eventSymbol)
         {
             var location = identifierSyntax.GetSyntaxLocation();
             AddEventUsageRelationship(sourceElement, eventSymbol, location);
@@ -208,7 +205,7 @@ public void AnalyzeIdentifier(CodeElement sourceElement, IdentifierNameSyntax id
     ///     <inheritdoc cref="ISyntaxNodeHandler.AnalyzeMemberAccess" />
     /// </summary>
     public void AnalyzeMemberAccess(CodeElement sourceElement, MemberAccessExpressionSyntax memberAccessSyntax,
-        SemanticModel semanticModel)
+        SemanticModel semanticModel, RelationshipType propertyAccessType = RelationshipType.Calls)
     {
         // Analyze the member being accessed (the right side of the dot)
         var symbolInfo = semanticModel.GetSymbolInfo(memberAccessSyntax);
@@ -217,7 +214,7 @@ public void AnalyzeMemberAccess(CodeElement sourceElement, MemberAccessExpressio
         if (symbol is IPropertySymbol propertySymbol)
         {
             var location = memberAccessSyntax.GetSyntaxLocation();
-            AddPropertyCallRelationship(sourceElement, propertySymbol, [location], RelationshipAttribute.None);
+            AddRelationshipWithFallbackToContainingType(sourceElement, propertySymbol, propertyAccessType, [location], RelationshipAttribute.None);
         }
         else if (symbol is IFieldSymbol fieldSymbol)
         {
@@ -814,21 +811,6 @@ private void AddEventHandlerRelationship(IMethodSymbol handlerMethod, IEventSymb
         //    $"Unable to add 'Handles' relationship: Handler {handlerMethod.Name} or Event {eventSymbol.Name} not found in codebase.");
     }
 
-    private void AnalyzeExpressionForPropertyAccess(CodeElement sourceElement, ExpressionSyntax expression,
-        SemanticModel semanticModel)
-    {
-        switch (expression)
-        {
-            case IdentifierNameSyntax identifierSyntax:
-                AnalyzeIdentifier(sourceElement, identifierSyntax, semanticModel);
-                break;
-            case MemberAccessExpressionSyntax memberAccessSyntax:
-                AnalyzeMemberAccess(sourceElement, memberAccessSyntax, semanticModel);
-                break;
-            // Add more cases if needed for other types of expressions
-        }
-    }
-
     private void AddCallsRelationship(CodeElement sourceElement, IMethodSymbol methodSymbol, SourceLocation location, RelationshipAttribute attributes)
     {
         //Debug.Assert(FindCodeElement(methodSymbol)!= null);
@@ -1006,15 +988,6 @@ private void AddNamedTypeRelationship(CodeElement sourceElement, INamedTypeSymbo
         return _externalCodeElementCache.TryGetOrCreateExternalCodeElement(symbol);
     }
 
-    /// <summary>
-    ///     Calling a property is treated like calling a method.
-    /// </summary>
-    private void AddPropertyCallRelationship(CodeElement sourceElement, IPropertySymbol propertySymbol,
-        List<SourceLocation> locations, RelationshipAttribute attributes)
-    {
-        AddRelationshipWithFallbackToContainingType(sourceElement, propertySymbol, RelationshipType.Calls, locations, attributes);
-    }
-
     /// <summary>
     ///     Adds a relationship to a symbol, with configurable fallback behavior for external symbols.
     ///     Tries in order: direct symbol → normalized symbol → containing type → external element

CodeParser/Parser/SyntaxWalkerBase.cs

@@ -32,16 +32,10 @@ public override void VisitArgument(ArgumentSyntax node)
         base.VisitArgument(node);
     }
 
-    /// <summary>
-    /// The walker ensures we only visit standalone identifiers
-    /// like MyProperty, not: obj.MyProperty
-    /// </summary>
-    public override void VisitIdentifierName(IdentifierNameSyntax node)
-    {
-        Analyzer.AnalyzeIdentifier(SourceElement, node, SemanticModel);
-        base.VisitIdentifierName(node);
-    }
-    
+    // Note: VisitIdentifierName is NOT overridden here because concrete walkers need to specify
+    // their relationship type (Calls for MethodBodyWalker, Uses for LambdaBodyWalker).
+    // Each walker overrides VisitIdentifierName with the appropriate RelationshipType parameter.
+
     public override void VisitLocalDeclarationStatement(LocalDeclarationStatementSyntax node)
     {
         Analyzer.AnalyzeLocalDeclaration(SourceElement, node, SemanticModel);

TestSuite/Core.BasicLanguageFeatures/Lambdas.cs

@@ -19,7 +19,6 @@ private void Start()
         var y = () =>
         {
             BaseClass? baseClass;
-            
         };
 
 

….SpecificBugs/AssignmentDuplicateTest.cs …signmentDuplicate/AssignmentDuplicate.csTestSuite/Regression.SpecificBugs/AssignmentDuplicateTest.cs renamed to TestSuite/Regression.SpecificBugs/AssignmentDuplicate/AssignmentDuplicate.cs TestSuite/Regression.SpecificBugs/AssignmentDuplicateTest.cs renamed to TestSuite/Regression.SpecificBugs/AssignmentDuplicate/AssignmentDuplicate.cs

@@ -1,6 +1,6 @@
-namespace Regression.SpecificBugs;
+namespace Regression.SpecificBugs.AssignmentDuplicate;
 
-public class AssignmentDuplicateTest
+public class AssignmentDuplicate
 {
     public string TestField;
     public string TestProperty { get; set; }