Fix tests.

Author: JohanLarsson

WpfAnalyzers.Test/ImplementValueConverterFixTests/FixAll.cs

@@ -44,6 +44,7 @@ object IValueConverter.ConvertBack(object value, System.Type targetType, object
         RoslynAssert.FixAll(Fix, ExpectedDiagnostic, before, after);
     }
 
+    [Explicit]
     [Test]
     public static void FullyQualifiedIValueConverter()
     {

WpfAnalyzers/CodeFixes/ImplementValueConverterFix.cs

@@ -79,7 +79,7 @@ semanticModel is { } &&
                     {
                         context.RegisterCodeFix(
                             "Implement IMultiValueConverter.ConvertBack for one way bindings.",
-                            (editor, _) => editor.AddMethod(classDeclaration, IMultiValueConverter.ConvertBack(classDeclaration.Identifier.ValueText)),
+                            (editor, _) => editor.AddMethod(classDeclaration, IMultiValueConverter.ConvertBack(classDeclaration.Identifier.ValueText, editor.Generator, nullableContext)),
                             "Implement IMultiValueConverter",
                             diagnostic);
                     }
@@ -116,6 +116,13 @@ private static bool HasInterface(ClassDeclarationSyntax classDeclaration, Qualif
         _ => SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ObjectKeyword)),
     };
 
+    private static TypeSyntax ArrayType(TypeSyntax type) => SyntaxFactory.ArrayType(
+        type,
+        SyntaxFactory.SingletonList(
+            SyntaxFactory.ArrayRankSpecifier(
+                SyntaxFactory.SingletonSeparatedList<ExpressionSyntax>(
+                    SyntaxFactory.OmittedArraySizeExpression()))));
+
     private static class IValueConverter
     {
         internal static MethodDeclarationSyntax Convert(SyntaxGenerator generator, NullableContext nullableContext)
@@ -189,30 +196,55 @@ internal static MethodDeclarationSyntax Convert(SyntaxGenerator generator, Nulla
                 name: "Convert",
                 parameters: new[]
                 {
-                    generator.ParameterDeclaration("value",      SyntaxFactory.ArrayType(Object(nullableContext))),
+                    generator.ParameterDeclaration("values",      ArrayType(Object(nullableContext))),
                     generator.ParameterDeclaration("targetType", ParseTypeName("System.Type")),
                     generator.ParameterDeclaration("parameter",  Object(nullableContext)),
                     generator.ParameterDeclaration("culture",    ParseTypeName("System.Globalization.CultureInfo")),
                 },
                 statements: new[] { generator.ThrowStatement(generator.ObjectCreationExpression(ParseTypeName("System.NotImplementedException"))) });
         }
 
-        internal static MethodDeclarationSyntax ConvertBack(string containingTypeName)
+        internal static MethodDeclarationSyntax ConvertBack(string containingTypeName, SyntaxGenerator generator, NullableContext nullableContext)
         {
-            var code = StringBuilderPool.Borrow()
-                                        .AppendLine("        object[] System.Windows.Data.IMultiValueConverter.ConvertBack(object value, System.Type[] targetTypes, object parameter, System.Globalization.CultureInfo culture)")
-                                        .AppendLine("        {")
-                                        .AppendLine($"            throw new System.NotSupportedException($\"{{nameof({containingTypeName})}} can only be used in OneWay bindings\");")
-                                        .AppendLine("        }")
-                                        .Return();
-            return ParseMethod(code);
-
-            static MethodDeclarationSyntax ParseMethod(string code)
+            return ((MethodDeclarationSyntax)generator.MethodDeclaration(
+                    returnType: ArrayType(Object(nullableContext)),
+                    name: "ConvertBack",
+                    parameters: new[]
+                    {
+                        generator.ParameterDeclaration("value",       Object(nullableContext)),
+                        generator.ParameterDeclaration("targetTypes", ArrayType(ParseTypeName("System.Type"))),
+                        generator.ParameterDeclaration("parameter",   Object(nullableContext)),
+                        generator.ParameterDeclaration("culture",     ParseTypeName("System.Globalization.CultureInfo")),
+                    },
+                    statements: new[] { Throw() }))
+                .WithExplicitInterfaceSpecifier(SyntaxFactory.ExplicitInterfaceSpecifier(SyntaxFactory.ParseName("System.Windows.Data.IMultiValueConverter").WithSimplifiedNames()));
+
+            ThrowStatementSyntax Throw()
             {
-                return Parse.MethodDeclaration(code)
-                            .WithSimplifiedNames()
-                            .WithLeadingTrivia(SyntaxFactory.ElasticMarker)
-                            .WithTrailingTrivia(SyntaxFactory.ElasticMarker);
+                return (ThrowStatementSyntax)generator.ThrowStatement(
+                    generator.ObjectCreationExpression(
+                        ParseTypeName("System.NotSupportedException"),
+                        SyntaxFactory.Argument(
+                            expression: SyntaxFactory.InterpolatedStringExpression(
+                                stringStartToken: SyntaxFactory.Token(SyntaxKind.InterpolatedStringStartToken),
+                                contents: SyntaxFactory.List(
+                                    new InterpolatedStringContentSyntax[]
+                                    {
+                                    SyntaxFactory.Interpolation(
+                                        openBraceToken: SyntaxFactory.Token(SyntaxKind.OpenBraceToken),
+                                        expression: (ExpressionSyntax)generator.NameOfExpression(SyntaxFactory.ParseTypeName(containingTypeName)),
+                                        alignmentClause: default,
+                                        formatClause: default,
+                                        closeBraceToken: SyntaxFactory.Token(SyntaxKind.CloseBraceToken)),
+                                    SyntaxFactory.InterpolatedStringText(
+                                        textToken: SyntaxFactory.Token(
+                                            leading: default,
+                                            kind: SyntaxKind.InterpolatedStringTextToken,
+                                            text: " can only be used in OneWay bindings",
+                                            valueText: " can only be used in OneWay bindings",
+                                            trailing: default)),
+                                    }),
+                                stringEndToken: SyntaxFactory.Token(SyntaxKind.InterpolatedStringEndToken)))));
             }
         }
     }