Remove explicit cast where possible - fixes #388

Author: GrahamTheCoder

CodeConverter/CSharp/ExpressionNodeVisitor.cs

@@ -237,15 +237,7 @@ public override async Task<CSharpSyntaxNode> VisitPredefinedCastExpression(VBasi
                         SyntaxFactory.Argument(expressionSyntax))));
             }
 
-            var convertMethodForKeywordOrNull = GetConvertMethodForKeywordOrNull(node);
-
-            return convertMethodForKeywordOrNull != null ? (ExpressionSyntax)
-                SyntaxFactory.InvocationExpression(convertMethodForKeywordOrNull,
-                    SyntaxFactory.ArgumentList(
-                        SyntaxFactory.SingletonSeparatedList(
-                            SyntaxFactory.Argument(expressionSyntax)))
-                ) // Hopefully will be a compile error if it's wrong
-                : ValidSyntaxFactory.CastExpression(SyntaxFactory.PredefinedType(node.Keyword.ConvertToken()), expressionSyntax);
+            return CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(node.Expression, expressionSyntax, true, false, forceTargetType: _semanticModel.GetTypeInfo(node).Type);
         }
 
         public override async Task<CSharpSyntaxNode> VisitTryCastExpression(VBasic.Syntax.TryCastExpressionSyntax node)

CodeConverter/CSharp/TypeConversionAnalyzer.cs

@@ -196,7 +196,7 @@ private bool TryAnalyzeCsConversion(Microsoft.CodeAnalysis.VisualBasic.Syntax.Ex
                 // e.g. sbyte * ulong uses the decimal * operator in VB. In C# it's ambiguous - see ExpressionTests.vb "TestMul".
                 typeConversionKind = TypeConversionKind.NonDestructiveCast;
                 return true;
-            } else if (csConversion.IsExplicit && csConversion.IsEnumeration) {
+            } else if (csConversion.IsExplicit && csConversion.IsEnumeration || csConversion.IsBoxing) {
                 typeConversionKind = TypeConversionKind.NonDestructiveCast;
                 return true;
             } else if (isArithmetic) {

CodeConverter/Shared/ProjectConversion.cs

@@ -95,7 +95,7 @@ public static async IAsyncEnumerable<ConversionResult> ConvertProject(Project pr
             await foreach (var result in results) yield return result;
         }
 
-        /// <remarks>Perf: Keep lazy so that we don't keep all files in memory at once</remarks>
+        /// <remarks>Perf: Keep lazy so that we don't keep an extra copy of all files in memory at once</remarks>
         private static async IAsyncEnumerable<ConversionResult> WithProjectFile(IProjectContentsConverter projectContentsConverter, ILanguageConversion languageConversion, ImmutableHashSet<string> originalSourcePaths, IAsyncEnumerable<ConversionResult> convertProjectContents, (string Find, string Replace, bool FirstOnly)[] replacements)
         {
             var project = projectContentsConverter.Project;

Tests/CSharp/ExpressionTests/ExpressionTests.cs

@@ -1023,7 +1023,7 @@ private void TestMethod()
         object test(object a) => a * 2;
         object test2(object a, object b)
         {
-            if (Conversions.ToBoolean(b > 0))
+            if (Conversions.ToBoolean(b > (object)0))
                 return a / b;
             return 0;
         };
@@ -1032,8 +1032,8 @@ object test2(object a, object b)
     }
 }
 4 target compilation errors:
-CS0019: Operator '*' cannot be applied to operands of type 'object' and 'int'
-CS0019: Operator '>' cannot be applied to operands of type 'object' and 'int'
+CS0019: Operator '*' cannot be applied to operands of type 'object' and 'object'
+CS0019: Operator '>' cannot be applied to operands of type 'object' and 'object'
 CS0019: Operator '/' cannot be applied to operands of type 'object' and 'object'
 CS0019: Operator '%' cannot be applied to operands of type 'object' and 'object'");
         }

Tests/CSharp/StatementTests/LoopStatementTests.cs

@@ -512,7 +512,6 @@ Private Sub TestMethod()
         Next
     End Sub
 End Class", @"using System;
-using Microsoft.VisualBasic.CompilerServices;
 
 internal partial class TestClass
 {
@@ -521,7 +520,7 @@ private void TestMethod()
         string stringValue = ""42"";
         for (int i = 1, loopTo = 10 - stringValue.Length; i <= loopTo; i++)
         {
-            stringValue = stringValue + "" "" + Conversions.ToString(i);
+            stringValue = stringValue + "" "" + i.ToString();
             Console.WriteLine(stringValue);
         }
     }

Tests/CSharp/TypeCastTests.cs

@@ -326,6 +326,19 @@ private string[] QuoteSplit(string text)
 }");
         }
 
+        [Fact]
+        public async Task TestSingleCharacterStringLiteralBecomesChar_WhenExplictCastAsync()
+        {
+            await TestConversionVisualBasicToCSharpAsync(
+                @"Class ExplicitCastClass
+    Dim wordArray As String() = 1.ToString().Split(CChar("",""))
+End Class", @"
+internal partial class ExplicitCastClass
+{
+    private string[] wordArray = 1.ToString().Split(',');
+}");
+        }
+
         [Fact]
         public async Task TestCastHasBracketsWhenElementAccessAsync()
         {
@@ -342,6 +355,52 @@ private int Casting(object sender)
     {
         return Conversions.ToInteger(((object[])sender)[0]);
     }
+}");
+        }
+
+        [Fact]
+        public async Task MultipleNestedCastsAsync()
+        {
+            await TestConversionVisualBasicToCSharpAsync(
+                @"Public Class MultipleCasts
+    Public Shared Function ToGenericParameter(Of T)(Value As Object) As T
+        If Value Is Nothing Then
+            Return Nothing
+        End If
+        Dim reflectedType As Global.System.Type = GetType(T)
+        If Global.System.Type.Equals(reflectedType, GetType(Global.System.Int16)) Then
+            Return DirectCast(CObj(CShort(Value)), T)
+        ElseIf Global.System.Type.Equals(reflectedType, GetType(Global.System.UInt64)) Then
+            Return DirectCast(CObj(CULng(Value)), T)
+        Else
+            Return DirectCast(Value, T)
+        End If
+    End Function
+End Class", @"using Microsoft.VisualBasic.CompilerServices;
+
+public partial class MultipleCasts
+{
+    public static T ToGenericParameter<T>(object Value)
+    {
+        if (Value is null)
+        {
+            return default;
+        }
+
+        var reflectedType = typeof(T);
+        if (Equals(reflectedType, typeof(short)))
+        {
+            return (T)(object)Conversions.ToShort(Value);
+        }
+        else if (Equals(reflectedType, typeof(ulong)))
+        {
+            return (T)(object)Conversions.ToULong(Value);
+        }
+        else
+        {
+            return (T)Value;
+        }
+    }
 }");
         }
     }