Address CodeRabbit review: tighten analyzer edge-case handling

MatExprChainAnalyzer (OCVS005): unwrap ParenthesizedExpressionSyntax when
  walking up to the parent binary expression so (a + b) + c is also detected.

RowColInLoopBodyAnalyzer (OCVS003): restrict IsInsideLoopBody to only return
  true when the node is inside the loop's Statement (body), not in the for-loop
  initializer, condition, or iterator expressions. Uses FullSpan.Contains.

RowColNotDisposedAnalyzer (OCVS004): narrow the member-access chain exemption
  from the blanket MemberAccessExpressionSyntax check to only At<T> calls
  (which OCVS001 already covers). mat.Row(i).Clone() now correctly reports
  OCVS004 since the Row() submatrix still leaks.

Tests added for each edge case (27 total, all passing).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: shimat

src/OpenCvSharp.Analyzers/MatExprChainAnalyzer.cs

@@ -65,7 +65,11 @@ private static void AnalyzeBinaryExpression(SyntaxNodeAnalysisContext context)
 
         // Flag only when this MatExpr is consumed immediately by another binary expression
         // without being assigned to a variable — that's the intermediate-temporary case.
+        // Unwrap any parentheses: (a + b) + c has a ParenthesizedExpressionSyntax between the
+        // inner binary and the outer one, but the semantics are identical.
         var parent = binary.Parent;
+        while (parent is ParenthesizedExpressionSyntax)
+            parent = parent.Parent;
         if (parent is BinaryExpressionSyntax or AssignmentExpressionSyntax { Left: not IdentifierNameSyntax })
         {
             var operatorToken = binary.OperatorToken.ToString();

src/OpenCvSharp.Analyzers/RowColInLoopBodyAnalyzer.cs

@@ -73,12 +73,18 @@ or LambdaExpressionSyntax
                          or AnonymousMethodExpressionSyntax)
                 return false;
 
-            // Loop constructs
-            if (current is ForStatementSyntax
-                         or WhileStatementSyntax
-                         or DoStatementSyntax
-                         or ForEachStatementSyntax)
-                return true;
+            // Loop constructs: only flag when node is inside the loop body (Statement),
+            // not in the initializer, condition, or iterator of a for/foreach.
+            StatementSyntax? loopBody = current switch
+            {
+                ForStatementSyntax f       => f.Statement,
+                WhileStatementSyntax w     => w.Statement,
+                DoStatementSyntax d        => d.Statement,
+                ForEachStatementSyntax fe  => fe.Statement,
+                _                          => null,
+            };
+            if (loopBody is not null)
+                return loopBody.FullSpan.Contains(node.FullSpan);
         }
         return false;
     }

src/OpenCvSharp.Analyzers/RowColNotDisposedAnalyzer.cs

@@ -84,10 +84,12 @@ private static bool IsDisposed(InvocationExpressionSyntax invocation)
         if (parent is UsingStatementSyntax)
             return true;
 
-        // mat.Row(i).SomeMethod() — member access chain; OCVS001 handles the At<T> case,
-        // and a chained call generally means the caller is using the result.
-        // Skip to avoid double-warning.
-        if (parent is MemberAccessExpressionSyntax)
+        // mat.Row(i).At<T>(col) — OCVS001 already flags this exact pattern; skip here
+        // to avoid a double warning. Only At<T> is exempted; other chains like .Clone()
+        // still leak the submatrix and should be reported.
+        if (parent is MemberAccessExpressionSyntax chainedMa
+            && chainedMa.Parent is InvocationExpressionSyntax
+            && chainedMa.Name.Identifier.Text == "At")
             return true;
 
         // Passed as argument — caller is responsible

test/OpenCvSharp.Analyzers.Tests/MatExprChainAnalyzerTests.cs

@@ -63,6 +63,20 @@ void M(OpenCvSharp.Mat a, OpenCvSharp.Mat b)
         }
         """);
 
+    [Fact]
+    public Task ParenthesizedChain_ReportsWarning() => Verify(
+        """
+        class Test
+        {
+            void M(OpenCvSharp.Mat a, OpenCvSharp.Mat b, OpenCvSharp.Mat c)
+            {
+                OpenCvSharp.Mat result = ({|#0:a + b|}) + c;
+            }
+        }
+        """,
+        DiagnosticResult.CompilerWarning(MatExprChainAnalyzer.DiagnosticId)
+            .WithLocation(0).WithArguments("+"));
+
     [Fact]
     public Task UsingMatExprVariable_NoWarning() => Verify(
         """

test/OpenCvSharp.Analyzers.Tests/RowColInLoopBodyAnalyzerTests.cs

@@ -78,6 +78,30 @@ void M(OpenCvSharp.Mat mat)
         }
         """);
 
+    [Fact]
+    public Task RowInForLoopCondition_NoWarning() => Verify(
+        """
+        class Test
+        {
+            void M(OpenCvSharp.Mat mat)
+            {
+                for (int i = 0; i < mat.Row(0).Rows; i++) { }
+            }
+        }
+        """);
+
+    [Fact]
+    public Task RowInForLoopInitializer_NoWarning() => Verify(
+        """
+        class Test
+        {
+            void M(OpenCvSharp.Mat mat)
+            {
+                for (var r = mat.Row(0); ; ) { }
+            }
+        }
+        """);
+
     [Fact]
     public Task RowInNestedLambda_NoWarning() => Verify(
         """

test/OpenCvSharp.Analyzers.Tests/RowColNotDisposedAnalyzerTests.cs

@@ -17,6 +17,8 @@ public class Mat : System.IDisposable
                 public Mat Col(int x) => this;
                 public Mat RowRange(int start, int end) => this;
                 public Mat ColRange(int start, int end) => this;
+                public T At<T>(int i0) where T : struct => default;
+                public Mat Clone() => new Mat();
                 public void Dispose() { }
             }
         }
@@ -83,6 +85,32 @@ void M(OpenCvSharp.Mat mat)
         }
         """);
 
+    [Fact]
+    public Task ChainedAtCall_NoWarning() => Verify(
+        """
+        class Test
+        {
+            void M(OpenCvSharp.Mat mat)
+            {
+                int v = mat.Row(0).At<int>(3);
+            }
+        }
+        """);
+
+    [Fact]
+    public Task ChainedCloneCall_ReportsWarning() => Verify(
+        """
+        class Test
+        {
+            void M(OpenCvSharp.Mat mat)
+            {
+                var copy = {|#0:mat.Row(0)|}.Clone();
+            }
+        }
+        """,
+        DiagnosticResult.CompilerWarning(RowColNotDisposedAnalyzer.DiagnosticId)
+            .WithLocation(0).WithArguments("Row"));
+
     [Fact]
     public Task ColRangeWithoutUsing_ReportsWarning() => Verify(
         """