Merge pull request #862 from Yozer/fix-conversions-calls

use explicit cast when integral numeric types are casted to enum
# Conflicts:
#	CodeConverter/CSharp/ExpressionNodeVisitor.cs
#	CodeConverter/Util/FromRoslyn/ITypeSymbolExtensions.cs
#	Tests/CSharp/TypeCastTests.cs

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#
 
 * Xml Namespace Imports now converted [#836](https://github.com/icsharpcode/CodeConverter/issues/836)
+* Use explicit cast when integral numeric types are casted to enum [#861](https://github.com/icsharpcode/CodeConverter/issues/861)
 * Correct inconsistent casing of event handlers [#854](https://github.com/icsharpcode/CodeConverter/issues/854)
 
 ### C# -> VB

CodeConverter/CSharp/ExpressionNodeVisitor.cs

@@ -283,7 +283,8 @@ public override async Task<CSharpSyntaxNode> VisitCTypeExpression(VBasic.Syntax.
     {
         var nodeForType = node;
         var convertMethodForKeyword = GetConvertMethodForKeywordOrNull(nodeForType);
-        if (_semanticModel.GetTypeInfo(nodeForType).Type is INamedTypeSymbol typeSymbol && typeSymbol.IsEnumType()) {
+        if (_semanticModel.GetTypeInfo(nodeForType).Type is INamedTypeSymbol typeSymbol && typeSymbol.IsEnumType() &&
+            _semanticModel.GetTypeInfo(node.Expression).Type is {} expressionType && !expressionType.IsIntegralType() && !expressionType.IsEnumType()) {
             convertMethodForKeyword = GetConvertMethodForKeywordOrNull(typeSymbol.EnumUnderlyingType);
         } else if (convertMethodForKeyword != null) {
             nodeForType = null;
@@ -690,7 +691,7 @@ public override async Task<CSharpSyntaxNode> VisitNamedFieldInitializer(VBasic.S
         var csExpressionSyntax = await node.Expression.AcceptAsync<ExpressionSyntax>(TriviaConvertingExpressionVisitor);
         csExpressionSyntax =
             CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(node.Expression, csExpressionSyntax);
-        if (node?.Parent?.Parent is VBasic.Syntax.AnonymousObjectCreationExpressionSyntax) {
+        if (node.Parent?.Parent is VBasic.Syntax.AnonymousObjectCreationExpressionSyntax) {
             return SyntaxFactory.AnonymousObjectMemberDeclarator(
                 SyntaxFactory.NameEquals(SyntaxFactory.IdentifierName(ConvertIdentifier(node.Name.Identifier))),
                 csExpressionSyntax);
@@ -1769,7 +1770,7 @@ private ArgumentListSyntax CreateArgList(ISymbol invocationSymbol)
     private async Task<CSharpSyntaxNode> SubstituteVisualBasicMethodOrNullAsync(VBSyntax.InvocationExpressionSyntax node, ISymbol invocationSymbol, ISymbol symbol)
     {
         ExpressionSyntax cSharpSyntaxNode = null;
-        if (symbol?.ContainingNamespace.MetadataName == nameof(Microsoft.VisualBasic) && symbol?.Name == "ChrW" || symbol?.Name == "Chr") {
+        if (symbol?.ContainingNamespace.MetadataName == nameof(Microsoft.VisualBasic) && symbol.Name == "ChrW" || symbol?.Name == "Chr") {
             var vbArg = node.ArgumentList.Arguments.Single().GetExpression();
             var constValue = _semanticModel.GetConstantValue(vbArg);
             if (IsCultureInvariant(symbol, constValue)) {

CodeConverter/Util/FromRoslyn/ITypeSymbolExtensions.cs

@@ -254,6 +254,8 @@ public static bool IsUnexpressibleTypeParameterConstraint(this ITypeSymbol typeS
         return false;
     }
 
+    public static bool IsIntegralType(this ITypeSymbol? type) => type.IsNumericType() && !type.IsFractionalNumericType();
+
     public static bool IsFractionalNumericType(this ITypeSymbol? type)
     {
         if (type != null) {

Tests/CSharp/TypeCastTests.cs

@@ -256,6 +256,61 @@ private void Test()
 }");
     }
 
+    [Fact]
+    public async Task CastingIntegralTypeToEnumShouldUseExplicitCastAsync()
+    {
+        await TestConversionVisualBasicToCSharpAsync(
+            @"
+Enum TestEnum
+    None = 0
+End Enum
+Enum TestEnum2
+    None = 1
+End Enum
+Class Class1
+    Private Sub Test()
+        Dim res = CType(5S, TestEnum)
+        res = CType(5D, TestEnum)
+        res = CType(5L, TestEnum)
+        res = CType(5.4F, TestEnum)
+        res = CType(5.7R, TestEnum)
+        res = CType(5UL, TestEnum)
+        res = CType(5, TestEnum)
+        
+        Dim otherEnum = TestEnum2.None
+        res = CType(otherEnum, TestEnum)
+    End Sub
+End Class",
+            @"using Microsoft.VisualBasic.CompilerServices; // Install-Package Microsoft.VisualBasic
+
+internal enum TestEnum
+{
+    None = 0
+}
+
+internal enum TestEnum2
+{
+    None = 1
+}
+
+internal partial class Class1
+{
+    private void Test()
+    {
+        TestEnum res = (TestEnum)5;
+        res = (TestEnum)Conversions.ToInteger(5m);
+        res = (TestEnum)5L;
+        res = (TestEnum)Conversions.ToInteger(5.4f);
+        res = (TestEnum)Conversions.ToInteger(5.7d);
+        res = (TestEnum)5UL;
+        res = (TestEnum)5;
+        var otherEnum = TestEnum2.None;
+        res = (TestEnum)otherEnum;
+    }
+}
+");
+    }
+
     [Fact]
     public async Task TryCastObjectToGenericListAsync()
     {