Fix VB With block conversion with null-conditional operator

Modified IsSubPartOfConditionalAccess to recursively check if a member access is part of the WhenNotNull branch of a ConditionalAccessExpression, handling nested conditional accesses. This ensures that the expression part (LHS) of a conditional access is correctly identified as not being part of the binding chain, allowing it to be resolved to the With block variable.

Added regression test WithBlockWithNullConditionalAccessAsync.

Co-authored-by: GrahamTheCoder <2490482+GrahamTheCoder@users.noreply.github.com>

Author: google-labs-jules[bot]

CodeConverter/CSharp/NameExpressionNodeVisitor.cs

@@ -1,4 +1,4 @@
-using System.Data;
+using System.Data;
 using System.Globalization;
 using ICSharpCode.CodeConverter.CSharp.Replacements;
 using ICSharpCode.CodeConverter.Util.FromRoslyn;
@@ -688,14 +688,39 @@ private static QualifiedNameSyntax Qualify(string qualification, ExpressionSynta
 
     private static bool IsSubPartOfConditionalAccess(VBasic.Syntax.MemberAccessExpressionSyntax node)
     {
-        var firstPossiblyConditionalAncestor = node.Parent;
-        while (firstPossiblyConditionalAncestor != null &&
-               firstPossiblyConditionalAncestor.IsKind(VBasic.SyntaxKind.InvocationExpression,
-                   VBasic.SyntaxKind.SimpleMemberAccessExpression)) {
-            firstPossiblyConditionalAncestor = firstPossiblyConditionalAncestor.Parent;
+        SyntaxNode child = node;
+        SyntaxNode parent = node.Parent;
+
+        while (parent != null)
+        {
+            if (parent.IsKind(VBasic.SyntaxKind.InvocationExpression,
+                              VBasic.SyntaxKind.SimpleMemberAccessExpression,
+                              VBasic.SyntaxKind.ParenthesizedExpression))
+            {
+                child = parent;
+                parent = parent.Parent;
+                continue;
+            }
+
+            if (parent is VBSyntax.ConditionalAccessExpressionSyntax cae)
+            {
+                if (cae.WhenNotNull == child)
+                {
+                    return true;
+                }
+
+                if (cae.Expression == child)
+                {
+                     child = parent;
+                     parent = parent.Parent;
+                     continue;
+                }
+            }
+
+            break;
         }
 
-        return firstPossiblyConditionalAncestor?.IsKind(VBasic.SyntaxKind.ConditionalAccessExpression) == true;
+        return false;
     }
 
     private static CSharpSyntaxNode ReplaceRightmostIdentifierText(CSharpSyntaxNode expr, SyntaxToken idToken, string overrideIdentifier)

Tests/CSharp/StatementTests/MethodStatementTests.cs

@@ -1,4 +1,4 @@
-using System.Threading.Tasks;
+using System.Threading.Tasks;
 using ICSharpCode.CodeConverter.Tests.TestRunners;
 using Xunit;
 
@@ -1673,4 +1673,44 @@ public object Func()
     }
 }");
     }
-}
+
+    [Fact]
+    public async Task WithBlockWithNullConditionalAccessAsync()
+    {
+        await TestConversionVisualBasicToCSharpAsync(@"
+Public Class Class1
+    Public Property x As Class1
+    Public Property Name As String
+End Class
+
+Public Class TestClass
+    Private _Data As Class1
+    Private x As String
+
+    Public Sub TestMethod()
+        With _Data
+            x = .x?.Name
+        End With
+    End Sub
+End Class", @"
+public partial class Class1
+{
+    public Class1 x { get; set; }
+    public string Name { get; set; }
+}
+
+public partial class TestClass
+{
+    private Class1 _Data;
+    private string x;
+
+    public void TestMethod()
+    {
+        {
+            ref var withBlock = ref _Data;
+            x = withBlock.x?.Name;
+        }
+    }
+}");
+    }
+}