Use a dummy syntax tree to test whether types are implicitly convertible

Author: silkfire

src/BenchmarkDotNet.Analyzers/AnalyzerHelper.cs

@@ -1,9 +1,9 @@
 namespace BenchmarkDotNet.Analyzers
 {
     using Microsoft.CodeAnalysis;
+    using Microsoft.CodeAnalysis.CSharp;
     using Microsoft.CodeAnalysis.CSharp.Syntax;
 
-    using System;
     using System.Collections.Immutable;
 
     internal static class AnalyzerHelper
@@ -92,89 +92,19 @@ public static string NormalizeTypeName(INamedTypeSymbol namedTypeSymbol)
             return typeName;
         }
 
-        public static bool ValueFitsInType(object value, ITypeSymbol targetType)
+        public static bool IsConstantAssignableToType(Compilation compilation, ITypeSymbol targetType, string valueExpression)
         {
+            var code = $$"""
+                         file class Internal {
+                             {{targetType}} x = {{valueExpression}};
+                         }
+                         """;
 
+            var syntaxTree = CSharpSyntaxTree.ParseText(code);
 
-            try
-            {
-                switch (targetType.SpecialType)
-                {
-                    case SpecialType.System_Byte:
-                        var byteVal = Convert.ToInt64(value);
-
-                        return byteVal is >= byte.MinValue and <= byte.MaxValue;
-
-                    case SpecialType.System_SByte:
-                        var sbyteVal = Convert.ToInt64(value);
-
-                        return sbyteVal is >= sbyte.MinValue and <= sbyte.MaxValue;
-
-                    case SpecialType.System_Int16:
-                        var int16Val = Convert.ToInt64(value);
-
-                        return int16Val is >= short.MinValue and <= short.MaxValue;
-
-                    case SpecialType.System_UInt16:
-                        var uint16Val = Convert.ToInt64(value);
-
-                        return uint16Val is >= ushort.MinValue and <= ushort.MaxValue;
-
-                    case SpecialType.System_Int32:
-                        var int32Val = Convert.ToInt64(value);
-
-                        return int32Val is >= int.MinValue and <= int.MaxValue;
-
-                    case SpecialType.System_UInt32:
-                        var uint32Val = Convert.ToInt64(value);
-
-                        return uint32Val is >= uint.MinValue and <= uint.MaxValue;
-
-                    case SpecialType.System_Int64:
-                        {
-                            _ = Convert.ToInt64(value);
-                        }
-
-                        return true;
+            var diagnostics = compilation.AddSyntaxTrees(syntaxTree).GetSemanticModel(syntaxTree).GetMethodBodyDiagnostics();
 
-                    case SpecialType.System_UInt64:
-                        var val = Convert.ToInt64(value);
-
-                        return val >= 0;
-
-                    case SpecialType.System_Single:
-                        if (value is double)
-                        {
-                            return false;
-                        }
-
-                        var floatVal = Convert.ToSingle(value);
-
-                        return !float.IsInfinity(floatVal);
-
-                    case SpecialType.System_Double:
-                        var doubleVal = Convert.ToDouble(value);
-
-                        return !double.IsInfinity(doubleVal);
-
-                    case SpecialType.System_Decimal:
-                        if (value is double or float)
-                        {
-                            return false;
-                        }
-
-                        _ = Convert.ToDecimal(value);
-
-                        return true;
-
-                    default:
-                        return false;
-                }
-            }
-            catch (Exception)
-            {
-                return false;
-            }
+            return diagnostics.Length == 0;
         }
     }
 }

src/BenchmarkDotNet.Analyzers/Attributes/ArgumentsAttributeAnalyzer.cs

@@ -277,24 +277,13 @@ void ReportIfNotImplicitlyConvertibleValueTypeDiagnostic(Func<int, ExpressionSyn
                         continue;
                     }
 
-                    var actualValueTypeSymbol = context.SemanticModel.GetTypeInfo(valueExpressionSyntaxFunc(i)).Type;
+                    var valueExpressionString = valueExpressionSyntax.ToString();
+
+                    var actualValueTypeSymbol = context.SemanticModel.GetTypeInfo(valueExpressionSyntax).Type;
                     if (actualValueTypeSymbol != null && actualValueTypeSymbol.TypeKind != TypeKind.Error)
                     {
-                        var conversionSummary = context.Compilation.ClassifyConversion(actualValueTypeSymbol, methodParameterTypeSymbol);
-                        if (!conversionSummary.IsImplicit)
+                        if (!AnalyzerHelper.IsConstantAssignableToType(context.Compilation, methodParameterTypeSymbol, valueExpressionString))
                         {
-                            if (conversionSummary is { IsExplicit: true, IsEnumeration: false })
-                            {
-                                var constantValue = context.SemanticModel.GetConstantValue(valueExpressionSyntax is CastExpressionSyntax castExpressionSyntax ? castExpressionSyntax.Expression : valueExpressionSyntax);
-                                if (constantValue is { HasValue: true, Value: not null })
-                                {
-                                    if (AnalyzerHelper.ValueFitsInType(constantValue.Value, methodParameterTypeSymbol))
-                                    {
-                                        return;
-                                    }
-                                }
-                            }
-
                             ReportValueTypeMustBeImplicitlyConvertibleDiagnostic(valueExpressionSyntax.GetLocation(),
                                                                                  valueExpressionSyntax.ToString(),
                                                                                  methodParameterTypeSymbol.ToString(),

src/BenchmarkDotNet.Analyzers/Attributes/ParamsAttributeAnalyzer.cs

@@ -248,34 +248,23 @@ private static void AnalyzeFieldOrPropertyTypeSyntax(SyntaxNodeAnalysisContext c
 
             void ReportIfNotImplicitlyConvertibleValueTypeDiagnostic(ExpressionSyntax valueExpressionSyntax)
             {
+                var valueExpressionString = valueExpressionSyntax.ToString();
+
                 var actualValueTypeSymbol = context.SemanticModel.GetTypeInfo(valueExpressionSyntax).Type;
                 if (actualValueTypeSymbol != null && actualValueTypeSymbol.TypeKind != TypeKind.Error)
                 {
-                    var conversionSummary = context.Compilation.ClassifyConversion(actualValueTypeSymbol, expectedValueTypeSymbol);
-                    if (!conversionSummary.IsImplicit)
+                    if (!AnalyzerHelper.IsConstantAssignableToType(context.Compilation, expectedValueTypeSymbol, valueExpressionString))
                     {
-                        if (conversionSummary is { IsExplicit: true, IsEnumeration: false })
-                        {
-                            var constantValue = context.SemanticModel.GetConstantValue(valueExpressionSyntax is CastExpressionSyntax castExpressionSyntax ? castExpressionSyntax.Expression : valueExpressionSyntax);
-                            if (constantValue is { HasValue: true, Value: not null })
-                            {
-                                if (AnalyzerHelper.ValueFitsInType(constantValue.Value, expectedValueTypeSymbol))
-                                {
-                                    return;
-                                }
-                            }
-                        }
-
                         ReportValueTypeMustBeImplicitlyConvertibleDiagnostic(valueExpressionSyntax.GetLocation(),
-                                                                             valueExpressionSyntax.ToString(),
+                                                                             valueExpressionString,
                                                                              fieldOrPropertyTypeSyntax.ToString(),
                                                                              actualValueTypeSymbol.ToString());
                     }
                 }
                 else
                 {
                     ReportValueTypeMustBeImplicitlyConvertibleDiagnostic(valueExpressionSyntax.GetLocation(),
-                                                                         valueExpressionSyntax.ToString(),
+                                                                         valueExpressionString,
                                                                          fieldOrPropertyTypeSyntax.ToString());
                 }