diff --git a/src/NetEscapades.EnumGenerators.Generators/Diagnostics/UsageAnalyzers/GetNamesCodeFixProvider.cs b/src/NetEscapades.EnumGenerators.Generators/Diagnostics/UsageAnalyzers/GetNamesCodeFixProvider.cs
index 3b28b2e..414ea3d 100644
--- a/src/NetEscapades.EnumGenerators.Generators/Diagnostics/UsageAnalyzers/GetNamesCodeFixProvider.cs
+++ b/src/NetEscapades.EnumGenerators.Generators/Diagnostics/UsageAnalyzers/GetNamesCodeFixProvider.cs
@@ -3,6 +3,7 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.Simplification;
diff --git a/tests/NetEscapades.EnumGenerators.Tests/GetNamesAnalyzerTests.cs b/tests/NetEscapades.EnumGenerators.Tests/GetNamesAnalyzerTests.cs
index 4fa4195..aa3322d 100644
--- a/tests/NetEscapades.EnumGenerators.Tests/GetNamesAnalyzerTests.cs
+++ b/tests/NetEscapades.EnumGenerators.Tests/GetNamesAnalyzerTests.cs
@@ -428,6 +428,68 @@ public void TestMethod()
         await VerifyAnalyzerAsync(test, EnableState.Disabled);
     }
 
+    [Fact]
+    public async Task GetNamesAsMethodArgumentShouldPreserveWhitespace()
+    {
+        var test = GetTestCode(
+            /* lang=c# */
+            """
+            public class TestClass
+            {
+                public void TestMethod()
+                {
+                    SomeMethod({|NEEG008:Enum.GetNames(typeof(MyEnum))|});
+                }
+                
+                private void SomeMethod(string[] names) { }
+            }
+            """);
+
+        var fix = GetTestCode(
+            /* lang=c# */
+            """
+            public class TestClass
+            {
+                public void TestMethod()
+                {
+                    SomeMethod(MyEnumExtensions.GetNames());
+                }
+                
+                private void SomeMethod(string[] names) { }
+            }
+            """);
+        await VerifyCodeFixAsync(test, fix);
+    }
+
+    [Fact]
+    public async Task GetNamesWithExtraWhitespaceShouldPreserveWhitespace()
+    {
+        var test = GetTestCode(
+            /* lang=c# */
+            """
+            public class TestClass
+            {
+                public void TestMethod()
+                {
+                            {|NEEG008:Enum.GetNames(typeof(MyEnum))|};
+                }
+            }
+            """);
+
+        var fix = GetTestCode(
+            /* lang=c# */
+            """
+            public class TestClass
+            {
+                public void TestMethod()
+                {
+                            MyEnumExtensions.GetNames();
+                }
+            }
+            """);
+        await VerifyCodeFixAsync(test, fix);
+    }
+
     private static string GetTestCodeWithExternalEnum(string testCode) =>
         $$"""
           using System;
diff --git a/tests/NetEscapades.EnumGenerators.Tests/GetValuesAnalyzerTests.cs b/tests/NetEscapades.EnumGenerators.Tests/GetValuesAnalyzerTests.cs
index 6510dc1..ece75d3 100644
--- a/tests/NetEscapades.EnumGenerators.Tests/GetValuesAnalyzerTests.cs
+++ b/tests/NetEscapades.EnumGenerators.Tests/GetValuesAnalyzerTests.cs
@@ -534,4 +534,66 @@ public static class MyEnumExtensions
              {{TestHelpers.LoadEmbeddedAttribute()}}
              {{TestHelpers.LoadEmbeddedMetadataSource()}}
              """;
+
+    [Fact]
+    public async Task GetValuesAsMethodArgumentShouldPreserveWhitespace()
+    {
+        var test = GetTestCode(
+            /* lang=c# */
+            """
+            public class TestClass
+            {
+                public void TestMethod()
+                {
+                    SomeMethod({|NEEG009:Enum.GetValues(typeof(MyEnum))|});
+                }
+                
+                private void SomeMethod(MyEnum[] values) { }
+            }
+            """);
+
+        var fix = GetTestCode(
+            /* lang=c# */
+            """
+            public class TestClass
+            {
+                public void TestMethod()
+                {
+                    SomeMethod(MyEnumExtensions.GetValues());
+                }
+                
+                private void SomeMethod(MyEnum[] values) { }
+            }
+            """);
+        await Verifier.VerifyCodeFixAsync(test, fix);
+    }
+
+    [Fact]
+    public async Task GetValuesWithExtraWhitespaceShouldPreserveWhitespace()
+    {
+        var test = GetTestCode(
+            /* lang=c# */
+            """
+            public class TestClass
+            {
+                public void TestMethod()
+                {
+                            var values = {|NEEG009:Enum.GetValues(typeof(MyEnum))|};
+                }
+            }
+            """);
+
+        var fix = GetTestCode(
+            /* lang=c# */
+            """
+            public class TestClass
+            {
+                public void TestMethod()
+                {
+                            var values = MyEnumExtensions.GetValues();
+                }
+            }
+            """);
+        await Verifier.VerifyCodeFixAsync(test, fix);
+    }
 }
diff --git a/tests/NetEscapades.EnumGenerators.Tests/GetValuesAsUnderlyingTypeAnalyzerTests.cs b/tests/NetEscapades.EnumGenerators.Tests/GetValuesAsUnderlyingTypeAnalyzerTests.cs
index b531ce5..ad5205d 100644
--- a/tests/NetEscapades.EnumGenerators.Tests/GetValuesAsUnderlyingTypeAnalyzerTests.cs
+++ b/tests/NetEscapades.EnumGenerators.Tests/GetValuesAsUnderlyingTypeAnalyzerTests.cs
@@ -486,4 +486,78 @@ public static class MyEnumExtensions
         {{TestHelpers.LoadEmbeddedAttribute()}}
         {{TestHelpers.LoadEmbeddedMetadataSource()}}
         """;
+
+    private static Task VerifyCodeFixWithNet6AssembliesAsync(string source, string fixedSource)
+    {
+        var test = new Test
+        {
+            TestCode = source,
+            FixedCode = fixedSource,
+            ReferenceAssemblies = ReferenceAssemblies.Net.Net60,
+        };
+
+        return test.RunAsync(CancellationToken.None);
+    }
+
+    [Fact]
+    public async Task GetValuesAsUnderlyingTypeAsMethodArgumentShouldPreserveWhitespace()
+    {
+        var test = GetTestCode(
+            /* lang=c# */
+            """
+            public class TestClass
+            {
+                public void TestMethod()
+                {
+                    SomeMethod({|NEEG010:Enum.GetValuesAsUnderlyingType(typeof(MyEnum))|});
+                }
+                
+                private void SomeMethod(int[] values) { }
+            }
+            """);
+
+        var fix = GetTestCode(
+            /* lang=c# */
+            """
+            public class TestClass
+            {
+                public void TestMethod()
+                {
+                    SomeMethod(MyEnumExtensions.GetValuesAsUnderlyingType());
+                }
+                
+                private void SomeMethod(int[] values) { }
+            }
+            """);
+        await VerifyCodeFixWithNet6AssembliesAsync(test, fix);
+    }
+
+    [Fact]
+    public async Task GetValuesAsUnderlyingTypeWithExtraWhitespaceShouldPreserveWhitespace()
+    {
+        var test = GetTestCode(
+            /* lang=c# */
+            """
+            public class TestClass
+            {
+                public void TestMethod()
+                {
+                            var values = {|NEEG010:Enum.GetValuesAsUnderlyingType<MyEnum>()|};
+                }
+            }
+            """);
+
+        var fix = GetTestCode(
+            /* lang=c# */
+            """
+            public class TestClass
+            {
+                public void TestMethod()
+                {
+                            var values = MyEnumExtensions.GetValuesAsUnderlyingType();
+                }
+            }
+            """);
+        await VerifyCodeFixWithNet6AssembliesAsync(test, fix);
+    }
 }
diff --git a/tests/NetEscapades.EnumGenerators.Tests/ParseAnalyzerTests.cs b/tests/NetEscapades.EnumGenerators.Tests/ParseAnalyzerTests.cs
index a5d8908..6e8099b 100644
--- a/tests/NetEscapades.EnumGenerators.Tests/ParseAnalyzerTests.cs
+++ b/tests/NetEscapades.EnumGenerators.Tests/ParseAnalyzerTests.cs
@@ -704,4 +704,66 @@ public static class MyEnumExtensions
         {{TestHelpers.LoadEmbeddedAttribute()}}
         {{TestHelpers.LoadEmbeddedMetadataSource()}}
         """;
+
+    [Fact]
+    public async Task ParseAsMethodArgumentShouldPreserveWhitespace()
+    {
+        var test = GetTestCode(
+            /* lang=c# */
+            """
+            public class TestClass
+            {
+                public void TestMethod()
+                {
+                    SomeMethod({|NEEG007:Enum.Parse(typeof(MyEnum), "First")|});
+                }
+                
+                private void SomeMethod(MyEnum value) { }
+            }
+            """);
+
+        var fix = GetTestCode(
+            /* lang=c# */
+            """
+            public class TestClass
+            {
+                public void TestMethod()
+                {
+                    SomeMethod(MyEnumExtensions.Parse("First"));
+                }
+                
+                private void SomeMethod(MyEnum value) { }
+            }
+            """);
+        await Verifier.VerifyCodeFixAsync(test, fix);
+    }
+
+    [Fact]
+    public async Task ParseWithExtraWhitespaceShouldPreserveWhitespace()
+    {
+        var test = GetTestCode(
+            /* lang=c# */
+            """
+            public class TestClass
+            {
+                public void TestMethod()
+                {
+                            var value = {|NEEG007:Enum.Parse(typeof(MyEnum), "First")|};
+                }
+            }
+            """);
+
+        var fix = GetTestCode(
+            /* lang=c# */
+            """
+            public class TestClass
+            {
+                public void TestMethod()
+                {
+                            var value = MyEnumExtensions.Parse("First");
+                }
+            }
+            """);
+        await Verifier.VerifyCodeFixAsync(test, fix);
+    }
 }
diff --git a/tests/NetEscapades.EnumGenerators.Tests/ToStringAnalyzerTests.cs b/tests/NetEscapades.EnumGenerators.Tests/ToStringAnalyzerTests.cs
index 7226111..d639e65 100644
--- a/tests/NetEscapades.EnumGenerators.Tests/ToStringAnalyzerTests.cs
+++ b/tests/NetEscapades.EnumGenerators.Tests/ToStringAnalyzerTests.cs
@@ -807,6 +807,140 @@ public void TestMethod()
         
         await VerifyAnalyzerAsync(test, EnableState.Disabled);
     }
+
+    [Fact]
+    public async Task ToStringInConsoleWriteLineShouldPreserveWhitespace()
+    {
+        var test = GetTestCode(
+            /* lang=c# */
+            """
+            public class TestClass
+            {
+                public void TestMethod()
+                {
+                    var value = TestEnum.First;
+                    System.Console.WriteLine(value.{|NEEG004:ToString|}());
+                }
+            }
+            """);
+
+        var fix = GetTestCode(
+            /* lang=c# */
+            """
+            public class TestClass
+            {
+                public void TestMethod()
+                {
+                    var value = TestEnum.First;
+                    System.Console.WriteLine(value.ToStringFast());
+                }
+            }
+            """);
+        await Verifier.VerifyCodeFixAsync(test, fix);
+    }
+
+    [Fact]
+    public async Task ToStringAsMethodArgumentShouldPreserveWhitespace()
+    {
+        var test = GetTestCode(
+            /* lang=c# */
+            """
+            public class TestClass
+            {
+                public void TestMethod()
+                {
+                    var value = TestEnum.First;
+                    SomeMethod(value.{|NEEG004:ToString|}());
+                }
+                
+                private void SomeMethod(string s) { }
+            }
+            """);
+
+        var fix = GetTestCode(
+            /* lang=c# */
+            """
+            public class TestClass
+            {
+                public void TestMethod()
+                {
+                    var value = TestEnum.First;
+                    SomeMethod(value.ToStringFast());
+                }
+                
+                private void SomeMethod(string s) { }
+            }
+            """);
+        await Verifier.VerifyCodeFixAsync(test, fix);
+    }
+
+    [Fact]
+    public async Task ToStringWithMultipleArgumentsShouldPreserveWhitespace()
+    {
+        var test = GetTestCode(
+            /* lang=c# */
+            """
+            public class TestClass
+            {
+                public void TestMethod()
+                {
+                    var value1 = TestEnum.First;
+                    var value2 = TestEnum.Second;
+                    SomeMethod(value1.{|NEEG004:ToString|}(), value2.{|NEEG004:ToString|}());
+                }
+                
+                private void SomeMethod(string s1, string s2) { }
+            }
+            """);
+
+        var fix = GetTestCode(
+            /* lang=c# */
+            """
+            public class TestClass
+            {
+                public void TestMethod()
+                {
+                    var value1 = TestEnum.First;
+                    var value2 = TestEnum.Second;
+                    SomeMethod(value1.ToStringFast(), value2.ToStringFast());
+                }
+                
+                private void SomeMethod(string s1, string s2) { }
+            }
+            """);
+        await Verifier.VerifyCodeFixAsync(test, fix);
+    }
+
+    [Fact]
+    public async Task ToStringWithExtraWhitespaceShouldPreserveWhitespace()
+    {
+        var test = GetTestCode(
+            /* lang=c# */
+            """
+            public class TestClass
+            {
+                public void TestMethod()
+                {
+                    var value = TestEnum.First;
+                            System.Console.WriteLine(value.{|NEEG004:ToString|}());
+                }
+            }
+            """);
+
+        var fix = GetTestCode(
+            /* lang=c# */
+            """
+            public class TestClass
+            {
+                public void TestMethod()
+                {
+                    var value = TestEnum.First;
+                            System.Console.WriteLine(value.ToStringFast());
+                }
+            }
+            """);
+        await Verifier.VerifyCodeFixAsync(test, fix);
+    }
     
     private static string GetTestCodeWithExternalEnum(string testCode) => $$"""
         using System;
diff --git a/tests/NetEscapades.EnumGenerators.Tests/TryParseAnalyzerTests.cs b/tests/NetEscapades.EnumGenerators.Tests/TryParseAnalyzerTests.cs
index a1288e1..6ae2326 100644
--- a/tests/NetEscapades.EnumGenerators.Tests/TryParseAnalyzerTests.cs
+++ b/tests/NetEscapades.EnumGenerators.Tests/TryParseAnalyzerTests.cs
@@ -744,4 +744,103 @@ public static bool TryParse(ReadOnlySpan<char> name, out MyEnum value, bool igno
         {{TestHelpers.LoadEmbeddedAttribute()}}
         {{TestHelpers.LoadEmbeddedMetadataSource()}}
         """;
+
+    [Fact]
+    public async Task TryParseInIfStatementShouldPreserveWhitespace()
+    {
+        var test = GetTestCode(
+            /* lang=c# */
+            """
+            public class TestClass
+            {
+                public void TestMethod()
+                {
+                    if ({|NEEG011:Enum.TryParse(typeof(MyEnum), "First", out object result)|})
+                        System.Console.WriteLine("Parsed");
+                }
+            }
+            """);
+
+        var fix = GetTestCode(
+            /* lang=c# */
+            """
+            public class TestClass
+            {
+                public void TestMethod()
+                {
+                    if (MyEnumExtensions.TryParse("First", out object result))
+                        System.Console.WriteLine("Parsed");
+                }
+            }
+            """);
+        await Verifier.VerifyCodeFixAsync(test, fix);
+    }
+
+    [Fact]
+    public async Task TryParseAsMethodArgumentShouldPreserveWhitespace()
+    {
+        var test = GetTestCode(
+            /* lang=c# */
+            """
+            public class TestClass
+            {
+                public void TestMethod()
+                {
+                    SomeMethod({|NEEG011:Enum.TryParse(typeof(MyEnum), "First", out object result)|});
+                }
+                
+                private void SomeMethod(bool b) { }
+            }
+            """);
+
+        var fix = GetTestCode(
+            /* lang=c# */
+            """
+            public class TestClass
+            {
+                public void TestMethod()
+                {
+                    SomeMethod(MyEnumExtensions.TryParse("First", out object result));
+                }
+                
+                private void SomeMethod(bool b) { }
+            }
+            """);
+        await Verifier.VerifyCodeFixAsync(test, fix);
+    }
+
+    [Fact]
+    public async Task TryParseWithExtraWhitespaceShouldPreserveWhitespace()
+    {
+        var test = GetTestCode(
+            /* lang=c# */
+            """
+            public class TestClass
+            {
+                public void TestMethod()
+                {
+                            if ({|NEEG011:Enum.TryParse(typeof(MyEnum), "First", out object result)|})
+                            {
+                                System.Console.WriteLine("Parsed");
+                            }
+                }
+            }
+            """);
+
+        var fix = GetTestCode(
+            /* lang=c# */
+            """
+            public class TestClass
+            {
+                public void TestMethod()
+                {
+                            if (MyEnumExtensions.TryParse("First", out object result))
+                            {
+                                System.Console.WriteLine("Parsed");
+                            }
+                }
+            }
+            """);
+        await Verifier.VerifyCodeFixAsync(test, fix);
+    }
 }