Use Array.Resize - fixes #501

Author: GrahamTheCoder

CHANGELOG.md

@@ -14,6 +14,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 * Add AsEnumerable where needed in linq "in" clause - [#544](https://github.com/icsharpcode/CodeConverter/issues/544)
 * Remove redundant empty string coalesce in string comparison - [#500](https://github.com/icsharpcode/CodeConverter/issues/500)
 * Convert VB comparison operators - [#396](https://github.com/icsharpcode/CodeConverter/issues/396)
+* Convert Redim Preserve of 1D array to Array.Resize - [#501](https://github.com/icsharpcode/CodeConverter/issues/501)
 
 ### C# -> VB
 

CodeConverter/CSharp/MethodBodyExecutableStatementVisitor.cs

@@ -228,7 +228,10 @@ private async Task<SyntaxList<StatementSyntax>> ConvertRedimClauseAsync(VBSyntax
 
             var csTargetArrayExpression = (ExpressionSyntax) await node.Expression.AcceptAsync(_expressionVisitor);
             var convertedBounds = (await CommonConversions.ConvertArrayBoundsAsync(node.ArrayBounds)).Sizes.ToList();
-
+            if (preserve && convertedBounds.Count == 1) {
+                var arrayResize = SyntaxFactory.InvocationExpression(ValidSyntaxFactory.MemberAccess(nameof(Array), nameof(Array.Resize)), new[] { csTargetArrayExpression, convertedBounds.Single() }.CreateCsArgList());
+                return SingleStatement(arrayResize);
+            }
             var newArrayAssignment = CreateNewArrayAssignment(node.Expression, csTargetArrayExpression, convertedBounds, node.SpanStart);
             if (!preserve) return SingleStatement(newArrayAssignment);
 

CodeConverter/Util/ExpressionSyntaxExtensions.cs

@@ -13,19 +13,24 @@ internal static class ExpressionSyntaxExtensions
     {
         public static ArgumentListSyntax CreateArgList(params ExpressionSyntax[] args)
         {
-            return SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(args.Select(SyntaxFactory.Argument)));
+            return CreateCsArgList(args);
         }
 
         public static VBSyntax.ArgumentListSyntax CreateArgList<T>(params T[] args) where T : VBSyntax.ExpressionSyntax
         {
-            return CreateArgList((IEnumerable<T>) args);
+            return CreateVbArgList((IEnumerable<T>) args);
         }
 
-        public static VBSyntax.ArgumentListSyntax CreateArgList<T>(this IEnumerable<T> argExpressions) where T : VBSyntax.ExpressionSyntax
+        public static VBSyntax.ArgumentListSyntax CreateVbArgList<T>(this IEnumerable<T> argExpressions) where T : VBSyntax.ExpressionSyntax
         {
             return VBasic.SyntaxFactory.ArgumentList(VBasic.SyntaxFactory.SeparatedList(argExpressions.Select(e => (VBSyntax.ArgumentSyntax) VBasic.SyntaxFactory.SimpleArgument(e))));
         }
 
+        public static ArgumentListSyntax CreateCsArgList<T>(this IEnumerable<T> argExpressions) where T : ExpressionSyntax
+        {
+            return SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(argExpressions.Select(SyntaxFactory.Argument)));
+        }
+
         /// <summary>
         /// This is a conversion heavily based on Microsoft.CodeAnalysis.VisualBasic.Syntax.InternalSyntax.SyntaxExtensions.ExtractAnonymousTypeMemberName from 1bbbfc28a8e4493b4057e171310343a4c7ba826c
         /// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0

CodeConverter/VB/NodesVisitor.cs

@@ -634,7 +634,7 @@ public override VisualBasicSyntaxNode VisitEventDeclaration(CSS.EventDeclaration
                     var invocationExpression =
                         SyntaxFactory.InvocationExpression(
                             SyntaxFactory.ParseExpression(eventFieldIdentifier.Identifier.ValueText + "?"), //I think this syntax tree is the wrong shape, but using the right shape causes the simplifier to fail
-                            raiseEventParameters.Select(x => SyntaxFactory.IdentifierName(x.Identifier.Identifier)).CreateArgList()
+                            raiseEventParameters.Select(x => SyntaxFactory.IdentifierName(x.Identifier.Identifier)).CreateVbArgList()
                         );
                     riseEventAccessor = riseEventAccessor.WithStatements(SyntaxFactory.SingletonList((StatementSyntax)SyntaxFactory.ExpressionStatement(invocationExpression)));
                 }
@@ -1005,7 +1005,7 @@ public override VisualBasicSyntaxNode VisitPostfixUnaryExpression(CSS.PostfixUna
                                     ExpressionSyntaxExtensions.CreateArgList((ExpressionSyntax)node.Operand.Accept(TriviaConvertingVisitor))
                                 ),
                             SyntaxFactory.BinaryExpression(op, (ExpressionSyntax)node.Operand.Accept(TriviaConvertingVisitor), SyntaxFactory.Token(VBUtil.GetExpressionOperatorTokenKind(op)), _commonConversions.Literal(1))
-                    }.CreateArgList()
+                    }.CreateVbArgList()
                 );
             }
         }
@@ -1334,7 +1334,7 @@ public override VisualBasicSyntaxNode VisitArrayCreationExpression(CSS.ArrayCrea
                 SyntaxFactory.Token(SyntaxKind.NewKeyword),
                 SyntaxFactory.List<AttributeListSyntax>(),
                 (TypeSyntax)node.Type.ElementType.Accept(TriviaConvertingVisitor),
-                upperBoundArguments.Any() ? upperBoundArguments.CreateArgList() : null,
+                upperBoundArguments.Any() ? upperBoundArguments.CreateVbArgList() : null,
                 upperBoundArguments.Any() ? SyntaxFactory.List(rankSpecifiers.Skip(1)) : SyntaxFactory.List(rankSpecifiers),
                 (CollectionInitializerSyntax)node.Initializer?.Accept(TriviaConvertingVisitor) ?? SyntaxFactory.CollectionInitializer()
             );

Tests/CSharp/MissingSemanticModelInfo/StatementTests.cs

@@ -38,5 +38,20 @@ public void Test()
 1 target compilation errors:
 CS0246: The type or namespace name 'Asadf' could not be found (are you missing a using directive or an assembly reference?)", missingSemanticInfo: true);
         }
+
+        [Fact]
+        public async Task RedimOfUnknownVariableAsync()
+        {
+            await TestConversionVisualBasicToCSharpAsync(@"ReDim Preserve UnknownArray(unknownIntIdentifer)", @"{
+    Array.Resize(UnknownArray, unknownIntIdentifer + 1);
+}
+
+2 source compilation errors:
+BC30451: 'UnknownArray' is not declared. It may be inaccessible due to its protection level.
+BC30451: 'unknownIntIdentifer' is not declared. It may be inaccessible due to its protection level.
+2 target compilation errors:
+CS0103: The name 'UnknownArray' does not exist in the current context
+CS0103: The name 'unknownIntIdentifer' does not exist in the current context", missingSemanticInfo: true);
+        }
     }
 }

Tests/CSharp/StatementTests/StatementTests.cs

@@ -483,14 +483,8 @@ public static int[] TestMethod(int[] numArray, int[] numArray2)
         numArray = new int[4];
         numArray = null;
         numArray2[1] = 1;
-        var oldNumArray = numArray;
-        numArray = new int[6];
-        if (oldNumArray is object)
-            Array.Copy(oldNumArray, numArray, Math.Min(6, oldNumArray.Length));
-        var oldNumArray2 = numArray2;
-        numArray2 = new int[6];
-        if (oldNumArray2 is object)
-            Array.Copy(oldNumArray2, numArray2, Math.Min(6, oldNumArray2.Length));
+        Array.Resize(numArray, 6);
+        Array.Resize(numArray2, 6);
         var y = new int[7, 6];
         y[2, 3] = 1;
         var oldY = y;
@@ -500,7 +494,9 @@ public static int[] TestMethod(int[] numArray, int[] numArray2)
                 Array.Copy(oldY, i * oldY.GetLength(1), y, i * y.GetLength(1), Math.Min(oldY.GetLength(1), y.GetLength(1)));
         return numArray2;
     }
-}");
+}
+1 target compilation errors:
+CS1620: Argument 1 must be passed with the 'ref' keyword");
         }
 
         [Fact]