Format Predefined return types in Conversion OpDecl

Fix #4240 Make conversion operator declaration and Operator Decl
to honor SpacingAfterMethodDeclarationName option

For Eg:

public static implicit operator string (Program p) { return null; }
public static Program operator ! (Program p) { return null; }

should be formatted to

public static implicit operator string(Program p) { return null; }
public static Program operator !(Program p) { return null; }

if the spacing option says no spaces

src/Workspaces/CSharp/Portable/Formatting/FormattingHelpers.cs

@@ -61,6 +61,16 @@ public static bool IsValidBracePair(this ValueTuple<SyntaxToken, SyntaxToken> br
             return true;
         }
 
+        public static bool IsOpenParenInParameterListOfAConversionOperator(this SyntaxToken token)
+        {
+            return token.IsOpenParenInParameterList() && token.Parent.IsParentKind(SyntaxKind.ConversionOperatorDeclaration);
+        }
+
+        public static bool IsOpenParenInParameterListOfAOperationDeclaration(this SyntaxToken token)
+        {
+            return token.IsOpenParenInParameterList() && token.Parent.IsParentKind(SyntaxKind.OperatorDeclaration);
+        }
+
         public static bool IsOpenParenInParameterList(this SyntaxToken token)
         {
             return token.Kind() == SyntaxKind.OpenParenToken && token.Parent.Kind() == SyntaxKind.ParameterList;

src/Workspaces/CSharp/Portable/Formatting/Rules/SpacingFormattingRule.cs

@@ -32,6 +32,18 @@ public override AdjustSpacesOperation GetAdjustSpacesOperation(SyntaxToken previ
                 return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpacingAfterMethodDeclarationName);
             }
 
+            // Case: public static implicit operator string(Program p) { return null; }
+            if (previousToken.IsKeyword() && currentToken.IsOpenParenInParameterListOfAConversionOperator())
+            {
+                return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpacingAfterMethodDeclarationName);
+            }
+
+            // Case: public static Program operator !(Program p) { return null; }
+            if (previousToken.Parent.IsKind(SyntaxKind.OperatorDeclaration) && currentToken.IsOpenParenInParameterListOfAOperationDeclaration())
+            {
+                return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpacingAfterMethodDeclarationName);
+            }
+
             if (previousToken.IsOpenParenInParameterList() && currentToken.IsCloseParenInParameterList())
             {
                 return AdjustSpacesOperationZeroOrOne(optionSet, CSharpFormattingOptions.SpaceBetweenEmptyMethodDeclarationParentheses);

src/Workspaces/CSharp/Portable/Formatting/Rules/TokenBasedFormattingRule.cs

@@ -200,7 +200,6 @@ public override AdjustSpacesOperation GetAdjustSpacesOperation(SyntaxToken previ
                     previousToken.Kind() == SyntaxKind.BaseKeyword ||
                     previousToken.Kind() == SyntaxKind.ThisKeyword ||
                     previousToken.Kind() == SyntaxKind.NewKeyword ||
-                    previousToken.Parent.Kind() == SyntaxKind.OperatorDeclaration ||
                     previousToken.IsGenericGreaterThanToken() ||
                     currentToken.IsParenInArgumentList())
                 {

src/Workspaces/CSharpTest/Formatting/FormattingTests.cs

@@ -6231,6 +6231,46 @@ void Main()
             AssertFormat(expected, code);
         }
 
+        [WorkItem(4240, "https://github.com/dotnet/roslyn/issues/4240")]
+        [Fact, Trait(Traits.Feature, Traits.Features.Formatting)]
+        public void VerifySpacingAfterMethodDeclarationName_Default()
+        {
+            var code = @"class Program
+{
+    public static Program operator +   (Program p1, Program p2) { return null; }
+    public static implicit operator string (Program p) { return null; }
+    public static void M  () { }
+}";
+            var expected = @"class Program
+{
+    public static Program operator +(Program p1, Program p2) { return null; }
+    public static implicit operator string(Program p) { return null; }
+    public static void M() { }
+}";
+            AssertFormat(expected, code);
+        }
+
+        [WorkItem(4240, "https://github.com/dotnet/roslyn/issues/4240")]
+        [Fact, Trait(Traits.Feature, Traits.Features.Formatting)]
+        public void VerifySpacingAfterMethodDeclarationName_NonDefault()
+        {
+            var changingOptions = new Dictionary<OptionKey, object>();
+            changingOptions.Add(CSharpFormattingOptions.SpacingAfterMethodDeclarationName, true);
+            var code = @"class Program
+{
+    public static Program operator +   (Program p1, Program p2) { return null; }
+    public static implicit operator string (Program p) { return null; }
+    public static void M  () { }
+}";
+            var expected = @"class Program
+{
+    public static Program operator + (Program p1, Program p2) { return null; }
+    public static implicit operator string (Program p) { return null; }
+    public static void M () { }
+}";
+            AssertFormat(expected, code, changedOptionSet: changingOptions);
+        }
+
         [WorkItem(939, "https://github.com/dotnet/roslyn/issues/939")]
         [Fact, Trait(Traits.Feature, Traits.Features.Formatting)]
         public void DontFormatInsideArrayInitializers()