Improve numeric casts - fixes #580

Author: GrahamTheCoder

CHANGELOG.md

@@ -11,6 +11,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 ### VB -> C#
 * Handle Option Compare Text case insensitive comparisons in switch statements [#579](https://github.com/icsharpcode/CodeConverter/issues/579)
 * Fix compilation error when switching with enum cases [#549](https://github.com/icsharpcode/CodeConverter/issues/549)
+* Improve numeric casts [#580](https://github.com/icsharpcode/CodeConverter/issues/580)
 
 ### C# -> VB
 

…uiltInVisualBasicOperatorSubsitutions.cs …iltInVisualBasicOperatorSubstitutions.csCodeConverter/CSharp/BuiltInVisualBasicOperatorSubsitutions.cs renamed to CodeConverter/CSharp/BuiltInVisualBasicOperatorSubstitutions.cs CodeConverter/CSharp/BuiltInVisualBasicOperatorSubsitutions.cs renamed to CodeConverter/CSharp/BuiltInVisualBasicOperatorSubstitutions.cs

@@ -22,24 +22,26 @@ namespace ICSharpCode.CodeConverter.CSharp
 {
     internal static class VbOperatorConversion
     {
-        public static IOperatorConverter Create(CommentConvertingVisitorWrapper expressionVisitor, SemanticModel semanticModel, VisualBasicEqualityComparison visualBasicEqualityComparison)
+        public static IOperatorConverter Create(CommentConvertingVisitorWrapper expressionVisitor, SemanticModel semanticModel, VisualBasicEqualityComparison visualBasicEqualityComparison, TypeConversionAnalyzer typeConversionAnalyzer)
         {
-            return new BuiltInVisualBasicOperatorSubsitutions(expressionVisitor, semanticModel, visualBasicEqualityComparison);
+            return new BuiltInVisualBasicOperatorSubstitutions(expressionVisitor, semanticModel, visualBasicEqualityComparison, typeConversionAnalyzer);
         }
 
-        private class BuiltInVisualBasicOperatorSubsitutions : IOperatorConverter
+        private class BuiltInVisualBasicOperatorSubstitutions : IOperatorConverter
         {
             private const string _compilerServices = nameof(Microsoft) + "." + nameof(Microsoft.VisualBasic) + "." + nameof(Microsoft.VisualBasic.CompilerServices);
             private const string _operators = nameof(Operators);
             private readonly SemanticModel _semanticModel;
             private readonly VisualBasicEqualityComparison _visualBasicEqualityComparison;
             private readonly CommentConvertingVisitorWrapper _triviaConvertingVisitor;
+            private readonly TypeConversionAnalyzer _typeConversionAnalyzer;
 
-            public BuiltInVisualBasicOperatorSubsitutions(CommentConvertingVisitorWrapper triviaConvertingVisitor, SemanticModel semanticModel, VisualBasicEqualityComparison visualBasicEqualityComparison)
+            public BuiltInVisualBasicOperatorSubstitutions(CommentConvertingVisitorWrapper triviaConvertingVisitor, SemanticModel semanticModel, VisualBasicEqualityComparison visualBasicEqualityComparison, TypeConversionAnalyzer typeConversionAnalyzer)
             {
                 _semanticModel = semanticModel;
                 _visualBasicEqualityComparison = visualBasicEqualityComparison;
                 _triviaConvertingVisitor = triviaConvertingVisitor;
+                _typeConversionAnalyzer = typeConversionAnalyzer;
             }
 
             public async Task<ExpressionSyntax> ConvertNothingComparisonOrNullAsync(VBSyntax.ExpressionSyntax exprNode, bool negateExpression = false)
@@ -93,11 +95,18 @@ private async Task<ExpressionSyntax> ConvertToLikeOperatorAsync(VBSyntax.BinaryE
 
             private async Task<ExpressionSyntax> ConvertToPowOperatorAsync(VBSyntax.BinaryExpressionSyntax node)
             {
-                 var (lhs, rhs) = await AcceptSidesAsync(node);
+                var (lhs, rhs) = await AcceptSidesAsync(node);
+                lhs = ConvertTo(node.Left, lhs, SpecialType.System_Double);
+                rhs = ConvertTo(node.Right, rhs, SpecialType.System_Double);
                 return new KnownMethod(nameof(System), nameof(Math), nameof(Math.Pow))
                     .Invoke(_visualBasicEqualityComparison.ExtraUsingDirectives, lhs, rhs);
             }
 
+            private ExpressionSyntax ConvertTo(VBSyntax.ExpressionSyntax node, ExpressionSyntax lhs, SpecialType targetType)
+            {
+                return _typeConversionAnalyzer.AddExplicitConversion(node, lhs, forceTargetType: _semanticModel.Compilation.GetSpecialType(targetType));
+            }
+
             /// <remarks>No need to implement these since this is only called for things that are already decimal and hence will resolve operator in C#</remarks>
             private async Task<ExpressionSyntax> ConvertToDecimalBinaryOperatorAsync(VBSyntax.BinaryExpressionSyntax node, KnownMethod member) =>
                 default;

CodeConverter/CSharp/ExpressionNodeVisitor.cs

@@ -56,7 +56,7 @@ public ExpressionNodeVisitor(SemanticModel semanticModel,
             _csCompilation = csCompilation;
             _typeContext = typeContext;
             _extraUsingDirectives = extraUsingDirectives;
-            _operatorConverter = VbOperatorConversion.Create(TriviaConvertingExpressionVisitor, semanticModel, visualBasicEqualityComparison);
+            _operatorConverter = VbOperatorConversion.Create(TriviaConvertingExpressionVisitor, semanticModel, visualBasicEqualityComparison, commonConversions.TypeConversionAnalyzer);
             // If this isn't needed, the assembly with Conversions may not be referenced, so this must be done lazily
             _convertMethodsLookupByReturnType =
                 new Lazy<IDictionary<ITypeSymbol, string>>(() => CreateConvertMethodsLookupByReturnType(semanticModel));
@@ -237,12 +237,13 @@ public override async Task<CSharpSyntaxNode> VisitPredefinedCastExpression(VBasi
                         SyntaxFactory.Argument(expressionSyntax))));
             }
 
-            return CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(node.Expression, expressionSyntax, true, false, forceTargetType: _semanticModel.GetTypeInfo(node).Type);
+            var withConversion = CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(node.Expression, expressionSyntax, false, false, forceTargetType: _semanticModel.GetTypeInfo(node).Type);
+            return node.ParenthesizeIfPrecedenceCouldChange(withConversion); // Use context of outer node, rather than just its exprssion, as the above method call would do if allowed to add parenthesis
         }
 
         public override async Task<CSharpSyntaxNode> VisitTryCastExpression(VBasic.Syntax.TryCastExpressionSyntax node)
         {
-            return VbSyntaxNodeExtensions.ParenthesizeIfPrecedenceCouldChange(node, SyntaxFactory.BinaryExpression(
+            return node.ParenthesizeIfPrecedenceCouldChange(SyntaxFactory.BinaryExpression(
                 SyntaxKind.AsExpression,
                 (ExpressionSyntax) await node.Expression.AcceptAsync(TriviaConvertingExpressionVisitor),
                 (TypeSyntax) await node.Type.AcceptAsync(TriviaConvertingExpressionVisitor)

CodeConverter/CSharp/VbSyntaxNodeExtensions.cs

@@ -1,32 +1,26 @@
-using ICSharpCode.CodeConverter.Util;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.VisualBasic;
-using ArgumentSyntax = Microsoft.CodeAnalysis.VisualBasic.Syntax.ArgumentSyntax;
-using BinaryExpressionSyntax = Microsoft.CodeAnalysis.VisualBasic.Syntax.BinaryExpressionSyntax;
-using LambdaExpressionSyntax = Microsoft.CodeAnalysis.VisualBasic.Syntax.LambdaExpressionSyntax;
-using ParenthesizedExpressionSyntax = Microsoft.CodeAnalysis.VisualBasic.Syntax.ParenthesizedExpressionSyntax;
-using ReturnStatementSyntax = Microsoft.CodeAnalysis.VisualBasic.Syntax.ReturnStatementSyntax;
+using CSSyntax = Microsoft.CodeAnalysis.CSharp.Syntax;
+using VBSyntax = Microsoft.CodeAnalysis.VisualBasic.Syntax;
+using VBasic = Microsoft.CodeAnalysis.VisualBasic;
 using SyntaxFactory = Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
 
 namespace ICSharpCode.CodeConverter.CSharp
 {
     internal static class VbSyntaxNodeExtensions
     {
-        public static ExpressionSyntax ParenthesizeIfPrecedenceCouldChange(this VisualBasicSyntaxNode node, ExpressionSyntax expression)
+        public static CSSyntax.ExpressionSyntax ParenthesizeIfPrecedenceCouldChange(this VBasic.VisualBasicSyntaxNode node, CSSyntax.ExpressionSyntax expression)
         {
             return PrecedenceCouldChange(node) ? SyntaxFactory.ParenthesizedExpression(expression) : expression;
         }
 
-        public static bool PrecedenceCouldChange(this VisualBasicSyntaxNode node)
+        public static bool PrecedenceCouldChange(this VBasic.VisualBasicSyntaxNode node)
         {
-            bool parentIsBinaryExpression = node is BinaryExpressionSyntax;
-            bool parentIsReturn = node.Parent is ReturnStatementSyntax;
-            bool parentIsLambda = node.Parent is LambdaExpressionSyntax;
-            bool parentIsNonArgumentExpression = node.Parent is Microsoft.CodeAnalysis.VisualBasic.Syntax.ExpressionSyntax && !(node.Parent is ArgumentSyntax);
-            bool parentIsParenthesis = node.Parent is ParenthesizedExpressionSyntax;
+            bool parentIsBinaryExpression = node is VBSyntax.BinaryExpressionSyntax;
+            bool parentIsLambda = node.Parent is VBSyntax.LambdaExpressionSyntax;
+            bool parentIsNonArgumentExpression = node.Parent is VBSyntax.ExpressionSyntax && !(node.Parent is VBSyntax.ArgumentSyntax);
+            bool parentIsParenthesis = node.Parent is VBSyntax.ParenthesizedExpressionSyntax;
+            bool parentIsMemberAccessExpression = node.Parent is VBSyntax.MemberAccessExpressionSyntax;
 
-            return parentIsNonArgumentExpression && !parentIsBinaryExpression && !parentIsReturn && !parentIsLambda && !parentIsParenthesis;
+            return parentIsMemberAccessExpression || parentIsNonArgumentExpression && !parentIsBinaryExpression && !parentIsLambda && !parentIsParenthesis;
         }
     }
 }

Tests/CSharp/ExpressionTests/ExpressionTests.cs

@@ -102,6 +102,39 @@ public void Bar(int x)
 }");
         }
 
+        [Fact]
+        public async Task Issue580_EnumCastsAsync()
+        {
+            await TestConversionVisualBasicToCSharpAsync(@"
+Public Class EnumToString
+    Enum Tes As Short
+        None = 0
+        TEST2 = 2
+    End Enum
+    Private Sub TEest2(aEnum As Tes)
+        Dim sxtr_Tmp As String = ""Use"" & CShort(aEnum).ToString
+        Dim si_Txt As Short = CShort(2 ^ Tes.TEST2)
+    End Sub
+End Class",
+@"using System;
+using Microsoft.VisualBasic.CompilerServices; // Install-Package Microsoft.VisualBasic
+
+public partial class EnumToString
+{
+    public enum Tes : short
+    {
+        None = 0,
+        TEST2 = 2
+    }
+
+    private void TEest2(Tes aEnum)
+    {
+        string sxtr_Tmp = ""Use"" + ((short)aEnum).ToString();
+        short si_Txt = Conversions.ToShort(Math.Pow(2, (double)Tes.TEST2));
+    }
+}");
+        }
+
         [Fact]
         public async Task IntToEnumArgAsync()
         {