Fix VB to C# assignment operators of parameterized properties

Fixes #1157 where shorthand assignment operators like "+=" or "-=" were not properly resolved for parameterized properties during conversion from VB.NET to C#.
- Updated MethodBodyExecutableStatementVisitor to correctly expand compound assignment operators to their corresponding setter invocations.
- Handles type conversions and `Math.Pow` logic for exponentiation explicitly when mapping back to the compound setter parameters.
- Add unit test AssignmentOperatorsParameterizedPropertiesAsync to verify expected behavior.

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

Author: google-labs-jules[bot]

CodeConverter/CSharp/MethodBodyExecutableStatementVisitor.cs

@@ -211,9 +211,22 @@ public override async Task<SyntaxList<StatementSyntax>> VisitAssignmentStatement
         var lhs = await node.Left.AcceptAsync<ExpressionSyntax>(_expressionVisitor);
         var lOperation = _semanticModel.GetOperation(node.Left);
 
-        //Already dealt with by call to the same method in ConvertInvocationExpression
         var (parameterizedPropertyAccessMethod, _) = await CommonConversions.GetParameterizedPropertyAccessMethodAsync(lOperation);
-        if (parameterizedPropertyAccessMethod != null) return SingleStatement(lhs);
+
+        // If it's a simple assignment, we can return early as it's already handled by ConvertInvocationExpression
+        if (parameterizedPropertyAccessMethod != null && node.IsKind(VBasic.SyntaxKind.SimpleAssignmentStatement)) {
+            return SingleStatement(lhs);
+        }
+
+        // For compound assignments, we want to expand it to the setter, but parameterizedPropertyAccessMethod above
+        // returned 'get_Item' or 'set_Item' depending on operation context.
+        // We know for sure the left-hand side is a getter invocation for compound assignments (e.g. this.get_Item(0) += 2),
+        // but we need the setter name to build the final expression.
+        string setMethodName = null;
+        if (lOperation is IPropertyReferenceOperation pro && pro.Arguments.Any() && !Microsoft.CodeAnalysis.VisualBasic.VisualBasicExtensions.IsDefault(pro.Property)) {
+            setMethodName = pro.Property.SetMethod?.Name;
+        }
+
         var rhs = await node.Right.AcceptAsync<ExpressionSyntax>(_expressionVisitor);
 
         if (node.Left is VBSyntax.IdentifierNameSyntax id &&
@@ -241,18 +254,62 @@ _methodNode is VBSyntax.MethodBlockSyntax mb &&
 
             var nonCompoundRhs = SyntaxFactory.BinaryExpression(nonCompound, lhs, typeConvertedRhs);
             var typeConvertedNonCompoundRhs = CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(node.Right, nonCompoundRhs, forceSourceType: rhsTypeInfo.ConvertedType, forceTargetType: lhsTypeInfo.Type);
-            if (nonCompoundRhs != typeConvertedNonCompoundRhs) {
+            if (nonCompoundRhs != typeConvertedNonCompoundRhs || setMethodName != null) {
                 kind = SyntaxKind.SimpleAssignmentExpression;
                 typeConvertedRhs = typeConvertedNonCompoundRhs;
             }
+        } else if (setMethodName != null && node.IsKind(VBasic.SyntaxKind.ExponentiateAssignmentStatement)) {
+            // ExponentiateAssignmentStatement evaluates to Math.Pow invocation which might need casting back to lhsType
+            var typeConvertedNonCompoundRhs = CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(node.Right, typeConvertedRhs, forceSourceType: _semanticModel.Compilation.GetTypeByMetadataName("System.Double"), forceTargetType: lhsTypeInfo.Type);
+            kind = SyntaxKind.SimpleAssignmentExpression;
+            typeConvertedRhs = typeConvertedNonCompoundRhs;
         }
 
         rhs = typeConvertedRhs;
-            
-        var assignment = SyntaxFactory.AssignmentExpression(kind, lhs, rhs);
 
-        var postAssignment = GetPostAssignmentStatements(node);
-        return postAssignment.Insert(0, SyntaxFactory.ExpressionStatement(assignment));
+        if (setMethodName != null) {
+            if (lhs is InvocationExpressionSyntax ies) {
+                ExpressionSyntax exprToReplace = ies.Expression;
+                if (exprToReplace is MemberAccessExpressionSyntax maes && maes.Name is IdentifierNameSyntax idn) {
+                    var newName = SyntaxFactory.IdentifierName(setMethodName).WithTriviaFrom(idn);
+                    exprToReplace = maes.WithName(newName);
+
+                    var skipParens = node.Left.SkipIntoParens();
+                    if (maes.Expression is ThisExpressionSyntax) {
+                        if (skipParens is VBSyntax.InvocationExpressionSyntax inv && inv.Expression is VBSyntax.IdentifierNameSyntax) {
+                            exprToReplace = newName.WithLeadingTrivia(maes.GetLeadingTrivia()).WithTrailingTrivia(maes.GetTrailingTrivia());
+                        } else if (skipParens is VBSyntax.IdentifierNameSyntax) {
+                            exprToReplace = newName.WithLeadingTrivia(maes.GetLeadingTrivia()).WithTrailingTrivia(maes.GetTrailingTrivia());
+                        } else if (skipParens is VBSyntax.MemberAccessExpressionSyntax vbMaes && vbMaes.Expression is VBSyntax.MyClassExpressionSyntax == false && vbMaes.Expression is VBSyntax.MeExpressionSyntax == false) {
+                            // keep it
+                        } else {
+                            exprToReplace = newName.WithLeadingTrivia(maes.GetLeadingTrivia()).WithTrailingTrivia(maes.GetTrailingTrivia());
+                        }
+                    }
+                } else if (exprToReplace is IdentifierNameSyntax idn2) {
+                    var newName = SyntaxFactory.IdentifierName(setMethodName).WithTriviaFrom(idn2);
+                    exprToReplace = newName;
+                }
+                var newArg = SyntaxFactory.Argument(rhs);
+                var newArgs = ies.ArgumentList.Arguments.Add(newArg);
+                var newArgList = ies.ArgumentList.WithArguments(newArgs);
+                var newLhs = ies.WithExpression(exprToReplace).WithArgumentList(newArgList);
+                var invokeAssignment = SyntaxFactory.ExpressionStatement(newLhs);
+                var postAssign = GetPostAssignmentStatements(node);
+                return postAssign.Insert(0, invokeAssignment);
+            }
+            return SingleStatement(lhs);
+        }
+
+        if (kind == SyntaxKind.SimpleAssignmentExpression) {
+            var assignment = SyntaxFactory.AssignmentExpression(kind, lhs, rhs);
+            var postAssignment = GetPostAssignmentStatements(node);
+            return postAssignment.Insert(0, SyntaxFactory.ExpressionStatement(assignment));
+        }
+
+        var compoundAssignment = SyntaxFactory.AssignmentExpression(kind, lhs, rhs);
+        var compoundPostAssignment = GetPostAssignmentStatements(node);
+        return compoundPostAssignment.Insert(0, SyntaxFactory.ExpressionStatement(compoundAssignment));
     }
 
     private async Task<SyntaxList<StatementSyntax>> ConvertMidAssignmentAsync(VBSyntax.AssignmentStatementSyntax node, VBSyntax.MidExpressionSyntax mes)

Tests/CSharp/StatementTests/MethodStatementTests.cs

@@ -1713,4 +1713,83 @@ public void TestMethod()
     }
 }");
     }
+
+
+    [Fact]
+    public async Task AssignmentOperatorsParameterizedPropertiesAsync()
+    {
+        await TestConversionVisualBasicToCSharpAsync(@"Public Class TestClass
+    Private _items As Integer() = New Integer() {1}
+    Public Property Item(index As Integer) As Integer
+        Get
+            Return _items(index)
+        End Get
+        Set(value As Integer)
+            _items(index) = value
+        End Set
+    End Property
+
+    Private _strItems As String() = New String() {""Hello""}
+    Public Property StrItem(index As Integer) As String
+        Get
+            Return _strItems(index)
+        End Get
+        Set(value As String)
+            _strItems(index) = value
+        End Set
+    End Property
+
+    Public Sub AllAssignmentOperators()
+        Item(0) += 2
+        Item(0) *= 2
+        Item(0) ^= 2
+        Item(0) /= 2
+        Item(0) -= 2
+        Item(0) \= 2
+        Item(0) <<= 2
+        Item(0) >>= 2
+        StrItem(0) &= "" World""
+    End Sub
+End Class", @"using System;
+
+public partial class TestClass
+{
+    private int[] _items = new int[] { 1 };
+    public int get_Item(int index)
+
+    {
+        return _items[index];
+    }
+    public void set_Item(int index, int value)
+    {
+        _items[index] = value;
+    }
+
+
+    private string[] _strItems = new string[] { ""Hello"" };
+    public string get_StrItem(int index)
+
+    {
+        return _strItems[index];
+    }
+    public void set_StrItem(int index, string value)
+    {
+        _strItems[index] = value;
+    }
+
+
+    public void AllAssignmentOperators()
+    {
+        set_Item(0, get_Item(0) + 2);
+        set_Item(0, get_Item(0) * 2);
+        set_Item(0, (int)Math.Round(Math.Pow(get_Item(0), 2d)));
+        set_Item(0, (int)Math.Round(get_Item(0) / 2d));
+        set_Item(0, get_Item(0) - 2);
+        set_Item(0, get_Item(0) / 2);
+        set_Item(0, get_Item(0) << 2);
+        set_Item(0, get_Item(0) >> 2);
+        set_StrItem(0, get_StrItem(0) + "" World"");
+    }
+}");
+    }
 }