Better heuristics for MA0003 (#2)

.NET MAUI is getting some warnings like:

    src\Core\src\Platform\iOS\MauiSearchBar.cs(73,31):
    error MA0003: Subscribing to events with instance method 'OnEditingChanged' could cause memory leaks in an NSObject subclass. Remove the subscription or convert the method to a static method.

But this is a pattern that is OK:

    picker.ValueChanged += _proxy.OnValueChanged;
    //...
    class UIDatePickerProxy
    {
        public void OnValueChanged(object? sender, EventArgs e) { }
    }

Added some logic to allow this pattern.

I continued to emit MA0003 if `UIDatePickerProxy` is an
`NSObject`-subclass.

MemoryAnalyzers/MemoryAnalyzers.Test/MemoryAnalyzersUnitTests.cs

@@ -506,5 +506,71 @@ public MauiDatePicker()
 			var expected = VerifyCS.Diagnostic("MA0003").WithLocation(0).WithArguments("OnValueChanged");
 			await VerifyCS.VerifyAnalyzerAsync(test, expected);
 		}
+
+		/// <summary>
+		/// This pattern is used commonly in .NET MAUI, and should be OK
+		/// </summary>
+		[TestMethod]
+		public async Task SubscriptionForProxyClass_OK()
+		{
+			var test = """
+				[Register(Name = "UITextField", IsWrapper = true)]
+				class UITextField
+				{
+					[UnconditionalSuppressMessage("Memory", "MA0001")]
+					public event EventHandler EditingDidBegin;
+				}
+
+				class MyView : UIView
+				{
+					readonly UITextFieldProxy _proxy = new();
+
+					public MyView()
+					{
+						new UITextField().EditingDidBegin += _proxy.OnEditingDidBegin;
+					}
+
+					class UITextFieldProxy
+					{
+						public void OnEditingDidBegin(object sender, EventArgs e) { }
+					}
+				}
+			""";
+
+			await VerifyCS.VerifyAnalyzerAsync(test);
+		}
+
+		[TestMethod]
+		public async Task SubscriptionForProxyClass_NotOK()
+		{
+			var test = """
+				[Register(Name = "UITextField", IsWrapper = true)]
+				class UITextField
+				{
+					[UnconditionalSuppressMessage("Memory", "MA0001")]
+					public event EventHandler EditingDidBegin;
+				}
+
+				class MyView : UIView
+				{
+					[UnconditionalSuppressMessage("Memory", "MA0002")]
+					readonly UITextFieldProxy _proxy = new();
+
+					public MyView()
+					{
+						new UITextField().EditingDidBegin += _proxy.{|#0:OnEditingDidBegin|};;
+					}
+
+					// This should warn, because it is NSObject
+					class UITextFieldProxy : NSObject
+					{
+						public void OnEditingDidBegin(object sender, EventArgs e) { }
+					}
+				}
+			""";
+
+			var expected = VerifyCS.Diagnostic("MA0003").WithLocation(0).WithArguments("OnEditingDidBegin");
+			await VerifyCS.VerifyAnalyzerAsync(test, expected);
+		}
 	}
 }

MemoryAnalyzers/MemoryAnalyzers/MemoryAnalyzer.cs

@@ -178,14 +178,23 @@ static void AnalyzeSubscription(SyntaxNodeAnalysisContext context)
 			var rightInfo = context.SemanticModel.GetSymbolInfo(assignment.Right);
 			if (rightInfo.Symbol is not IMethodSymbol methodSymbol || methodSymbol.IsStatic)
 				return; // static methods are fine
+			if (!IsNSObjectSubclass(methodSymbol.ContainingType))
+				return; // If the method is on a non-NSObject subclass, it's fine
 
 			// Subscribing to events you declare are fine
 			if (assignment.Left is IdentifierNameSyntax)
 				return;
-			if (assignment.Left is MemberAccessExpressionSyntax m && m.Expression is ThisExpressionSyntax)
+			if (assignment.Left is MemberAccessExpressionSyntax left && left.Expression is ThisExpressionSyntax)
 				return;
 
-			context.ReportDiagnostic(Diagnostic.Create(MA0003Rule, assignment.Right.GetLocation(), methodSymbol.Name));
+			// We have to calculate the proper location for something like `+= _proxy.OnValueChanged`
+			Location? location;
+			if (assignment.Right is MemberAccessExpressionSyntax right)
+				location = right.Name.GetLocation();
+			else
+				location = assignment.Right.GetLocation();
+
+			context.ReportDiagnostic(Diagnostic.Create(MA0003Rule, location, methodSymbol.Name));
 		}
 
 		static bool HasUnconditionalSuppressMessage(ISymbol symbol, string expectedCode)