Handle array element references

Author: GrahamTheCoder

CodeConverter/CSharp/ExpressionNodeVisitor.cs

@@ -894,8 +894,8 @@ private async Task<CSharpSyntaxNode> ConvertInvocation(VBSyntax.InvocationExpres
 
             async Task<(ExpressionSyntax, bool isElementAccess)> ConvertInvocationSubExpression()
             {
-                var isElementAccess = IsPropertyElementAccess(operation) ||
-                                      IsArrayElementAccess(operation) ||
+                var isElementAccess = operation.IsPropertyElementAccess() ||
+                                      operation.IsArrayElementAccess() ||
                                       ProbablyNotAMethodCall(node, expressionSymbol, expressionReturnType);
 
                 var expr = await node.Expression.AcceptAsync(TriviaConvertingExpressionVisitor);
@@ -1411,19 +1411,38 @@ private RefConversion NeedsVariableForArgument(VBasic.Syntax.ArgumentSyntax node
         {
             if (refKind == RefKind.None) return RefConversion.Inline;
             if (!(node is VBSyntax.SimpleArgumentSyntax sas)) return RefConversion.PreAssigment;
-            bool isIdentifier = sas.Expression is VBasic.Syntax.IdentifierNameSyntax;
-            bool isMemberAccess = sas.Expression is VBasic.Syntax.MemberAccessExpressionSyntax;
+            var expression = sas.Expression.SkipParens();
 
-            var symbolInfo = GetSymbolInfoInDocument<ISymbol>(sas.Expression);
-            bool isProperty = symbolInfo != null && symbolInfo.IsKind(SymbolKind.Property);
-            bool isUsing = symbolInfo?.DeclaringSyntaxReferences.FirstOrDefault()?.GetSyntax()?.Parent?.Parent?.IsKind(VBasic.SyntaxKind.UsingStatement) == true;
+            return GetRefConversion(expression);
 
-            var typeInfo = _semanticModel.GetTypeInfo(sas.Expression);
-            bool isTypeMismatch = typeInfo.Type == null || !typeInfo.Type.Equals(typeInfo.ConvertedType);
+            RefConversion GetRefConversion(VBSyntax.ExpressionSyntax expression)
+            {
+                var symbolInfo = GetSymbolInfoInDocument<ISymbol>(expression);
+                if (symbolInfo.IsKind(SymbolKind.Property)) return RefConversion.PreAndPostAssignment;
+
+                var typeInfo = _semanticModel.GetTypeInfo(expression);
+                bool isTypeMismatch = typeInfo.Type == null || !typeInfo.Type.Equals(typeInfo.ConvertedType);
+
+                if (isTypeMismatch || DeclaredInUsing(symbolInfo)) return RefConversion.PreAssigment;
+
+                if (expression is VBasic.Syntax.IdentifierNameSyntax || expression is VBSyntax.MemberAccessExpressionSyntax ||
+                    IsRefArrayAcces(expression)) {
+                    return RefConversion.Inline;
+                }
+
+                return RefConversion.PreAssigment;
+            }
+
+            bool IsRefArrayAcces(VBSyntax.ExpressionSyntax expression)
+            {
+                if (!(expression is VBSyntax.InvocationExpressionSyntax ies)) return false;
+                return _semanticModel.GetOperation(ies).IsArrayElementAccess() && GetRefConversion(ies.Expression) == RefConversion.Inline;
+            }
+        }
 
-            if (isProperty) return RefConversion.PreAndPostAssignment;
-            if ((!isIdentifier && !isMemberAccess) || isTypeMismatch || isUsing) return RefConversion.PreAssigment;
-            return RefConversion.Inline;
+        private static bool DeclaredInUsing(ISymbol symbolInfo)
+        {
+            return symbolInfo?.DeclaringSyntaxReferences.FirstOrDefault()?.GetSyntax()?.Parent?.Parent?.IsKind(VBasic.SyntaxKind.UsingStatement) == true;
         }
 
         /// <summary>
@@ -1481,16 +1500,6 @@ private static CSharpSyntaxNode ReplaceRightmostIdentifierText(CSharpSyntaxNode
             return expr.ReplaceToken(idToken, SyntaxFactory.Identifier(overrideIdentifier).WithTriviaFrom(idToken).WithAdditionalAnnotations(idToken.GetAnnotations()));
         }
 
-        private static bool IsPropertyElementAccess(IOperation operation)
-        {
-            return operation is IPropertyReferenceOperation pro && pro.Arguments.Any() && VBasic.VisualBasicExtensions.IsDefault(pro.Property);
-        }
-
-        private static bool IsArrayElementAccess(IOperation operation)
-        {
-            return operation != null && operation.Kind == OperationKind.ArrayElementReference;
-        }
-
         /// <summary>
         /// Chances of having an unknown delegate stored as a field/local seem lower than having an unknown non-delegate type with an indexer stored.
         /// So for a standalone identifier err on the side of assuming it's an indexer.

CodeConverter/CSharp/OperationExtensions.cs

@@ -1,6 +1,10 @@
-using ICSharpCode.CodeConverter.Util.FromRoslyn;
+using System.Linq;
+using ICSharpCode.CodeConverter.Util.FromRoslyn;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Operations;
+using VBasic = Microsoft.CodeAnalysis.VisualBasic;
+using VBSyntax = Microsoft.CodeAnalysis.VisualBasic.Syntax;
+
 
 namespace ICSharpCode.CodeConverter.CSharp
 {
@@ -32,5 +36,15 @@ public static IOperation SkipParens(this IOperation operation, bool skipImplicit
                 }
             }
         }
+
+        public static bool IsPropertyElementAccess(this IOperation operation)
+        {
+            return operation is IPropertyReferenceOperation pro && pro.Arguments.Any() && VBasic.VisualBasicExtensions.IsDefault(pro.Property);
+        }
+
+        public static bool IsArrayElementAccess(this IOperation operation)
+        {
+            return operation != null && operation.Kind == OperationKind.ArrayElementReference;
+        }
     }
 }

Tests/CSharp/ExpressionTests/ByRefTests.cs

@@ -420,6 +420,47 @@ public void UsesRef(bool someBool, int someInt)
 
         Console.WriteLine(someInt);
     }
+}");
+        }
+
+        [Fact]
+        public async Task Issue567()
+        {
+            await TestConversionVisualBasicToCSharpAsync(@"Public Class Issue567
+    Dim arr(,) As String
+    Dim lst As List(Of String) = New List(Of String)({1.ToString(), 2.ToString(), 3.ToString()})
+
+    Sub DoSomething(ByRef str As String)
+        str = ""test""
+    End Sub
+
+    Sub Main()
+        DoSomething(arr(2, 2))
+        DoSomething(lst(1))
+        Debug.Assert(arr(2, 2) = ""test"")
+    End Sub
+
+End Class", @"using System.Collections.Generic;
+using System.Diagnostics;
+
+public partial class Issue567
+{
+    private string[,] arr;
+    private List<string> lst = new List<string>(new[] { 1.ToString(), 2.ToString(), 3.ToString() });
+
+    public void DoSomething(ref string str)
+    {
+        str = ""test"";
+    }
+
+    public void Main()
+    {
+        DoSomething(ref arr[2, 2]);
+        string argstr = lst[1];
+        DoSomething(ref argstr);
+        lst[1] = argstr;
+        Debug.Assert((arr[2, 2] ?? """") == ""test"");
+    }
 }");
         }
     }