Implemented NoImplicitConversionAttribute (#56)

Allow the user to disable implicit construction of a variant from a
value by adding the `[NoImplicitConversion]` attribute to the
`VariantOf` parameter. This also silences the warning about no implicit
conversions form interfaces or base classes.

src/dotVariant.Generator.Test/GeneratorTools.cs

@@ -116,6 +116,7 @@ DiagnosticExpectation ToExpectation(Match m)
             new Dictionary<string, string>()
                 {
                     { "VariantAttribute.cs", LoadSample("VariantAttribute.cs") },
+                    { "NoImplicitConversionAttribute.cs", LoadSample("NoImplicitConversionAttribute.cs") },
                 }
                 .ToImmutableDictionary();
     }

src/dotVariant.Generator.Test/RenderInfo.Params.cs

@@ -155,6 +155,16 @@ public partial class Variant
                     }",
                     ri => Assert.That(ri.Params[0].EmitImplicitCast, Is.True)
                 ),
+                (
+                    "emit no implicit cast for explicitly attributed parameters",
+                    @"
+                    [dotVariant.Variant]
+                    public partial class Variant
+                    {
+                        static partial void VariantOf([dotVariant.NoImplicitConversion] int a);
+                    }",
+                    ri => Assert.That(ri.Params[0].EmitImplicitCast, Is.False)
+                ),
                 (
                     "emit no implicit cast for base types",
                     @"

src/dotVariant.Generator.Test/SourceGenerator.Test.cs

@@ -83,6 +83,7 @@ public static IEnumerable<TestCaseData> TranslationCases()
                     ("Variant-generic-unbounded", "Foo.Variant{T}"),
                     ("Variant-nullable-value-type", "Foo.Variant_nullable_value_type"),
                     ("Variant-public", "Foo.Variant_public"),
+                    ("Variant-no-implicit-conversion", "Foo.Variant_no_implicit_conversion"),
                     ("Variant-struct-nullable-disable", "Foo.Variant_struct_nullable_disable"),
                     ("Variant-struct-nullable-enable", "Foo.Variant_struct_nullable_enable"),
                 }

src/dotVariant.Generator.Test/diagnostics/NoImplicitConversionForBaseClasses.cs

@@ -9,3 +9,9 @@ partial class Variant1
 {
     static partial void VariantOf(int a, object b); // expected-warning:49 dotVariant.NoImplicitConversionForBaseClasses
 }
+
+[dotVariant.Variant]
+partial class Variant2
+{
+    static partial void VariantOf(int a, [dotVariant.NoImplicitConversion] object b);
+}

src/dotVariant.Generator.Test/diagnostics/NoImplicitConversionForInterfaces.cs

@@ -9,3 +9,9 @@ partial class Variant1
 {
     static partial void VariantOf(int a, System.Collections.IEnumerable b); // expected-warning:73 dotVariant.NoImplicitConversionForInterfaces
 }
+
+[dotVariant.Variant]
+partial class Variant2
+{
+    static partial void VariantOf(int a, [dotVariant.NoImplicitConversion] System.Collections.IEnumerable b);
+}

src/dotVariant.Generator.Test/dotVariant.Generator.Test.csproj

@@ -26,7 +26,7 @@
 
   <ItemGroup>
     <EmbeddedResource Include="diagnostics/**/*" />
-    <EmbeddedResource Include="samples/**/*" />
+    <EmbeddedResource Include="samples/**/*" WithCulture="false" />
     <!--
       Embed the support sources so we don't have a dependency on the runtime library
       (which might contain generated code and fail to build while generator tests are failing)

src/dotVariant.Generator.Test/samples/Variant-no-implicit-conversion.in.cs

@@ -0,0 +1,16 @@
+//
+// Copyright Miro Knejp 2021.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
+//
+
+#nullable disable
+
+namespace Foo
+{
+    [dotVariant.Variant]
+    partial class Variant_no_implicit_conversion
+    {
+        static partial void VariantOf([dotVariant.NoImplicitConversion] int i, string s);
+    }
+}

src/dotVariant.Generator/Diagnose.cs

@@ -220,7 +220,7 @@ public static IEnumerable<Diagnostic> NoImplicitConversionForBaseClasses(
             {
                 foreach (var p in options)
                 {
-                    if (Inspect.IsAncestorOf(p.Type, type))
+                    if (Inspect.IsAncestorOf(p.Type, type) && !Inspect.HasImplicitConversionDisabled(p))
                     {
                         yield return MakeWarning(
                             nameof(NoImplicitConversionForBaseClasses),
@@ -240,7 +240,7 @@ public static IEnumerable<Diagnostic> NoImplicitConversionForInterfaces(
             {
                 foreach (var p in options)
                 {
-                    if (p.Type.TypeKind == TypeKind.Interface)
+                    if (p.Type.TypeKind == TypeKind.Interface && !Inspect.HasImplicitConversionDisabled(p))
                     {
                         yield return MakeWarning(
                             nameof(NoImplicitConversionForInterfaces),

src/dotVariant.Generator/Inspect.cs

@@ -97,6 +97,12 @@ public static bool Implements(IParameterSymbol param, INamedTypeSymbol interface
         public static int NumReferenceFields(IParameterSymbol param)
             => NumReferenceFields(param.Type);
 
+        public static bool HasImplicitConversionDisabled(IParameterSymbol param)
+        {
+            const string attributeName = nameof(dotVariant) + "." + nameof(NoImplicitConversionAttribute);
+            return param.GetAttributes().Any(a => a.AttributeClass?.ToDisplayString() == attributeName);
+        }
+
         public static int NumReferenceFields(ITypeSymbol type)
             => type.IsReferenceType
                 ? 1

src/dotVariant.Generator/RenderInfo.cs

@@ -207,7 +207,7 @@ public static RenderInfo FromDescriptor(
                 .Select((p, i) => new ParamInfo(
                     CanBeNull: CanBeNull(p, desc.NullableContext),
                     DiagType: p.Type.WithNullableAnnotation(p.NullableAnnotation).ToDisplayString(DiagFormat),
-                    EmitImplicitCast: !(p.Type.TypeKind == TypeKind.Interface || IsAncestorOf(p.Type, desc.Type)),
+                    EmitImplicitCast: !(p.Type.TypeKind == TypeKind.Interface || IsAncestorOf(p.Type, desc.Type) || HasImplicitConversionDisabled(p)),
                     Identifier: p.ToDisplayString(IdentifierFormat),
                     Index: i + 1,
                     IsDisposable: Implements(p, disposable),

src/dotVariant.Runtime/NoImplicitConversionAttribute.cs

@@ -0,0 +1,16 @@
+//
+// Copyright Miro Knejp 2021.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
+//
+
+using System;
+
+namespace dotVariant
+{
+    [AttributeUsage(AttributeTargets.Parameter)]
+    public sealed class NoImplicitConversionAttribute : Attribute
+    {
+        public NoImplicitConversionAttribute() { }
+    }
+}