Fix single quote and space in F# pretty methods

src/Microsoft.TestPlatform.AdapterUtilities/ManagedNameUtilities/ManagedNameParser.cs

@@ -82,12 +82,21 @@ private static int ParseMethodName(string managedMethodName, int start, out stri
     {
         var i = start;
         var quoted = false;
+        char? previousChar = null;
+        // Consume all characters that are in single quotes as is. Because F# methods wrapped in `` can have any text, like ``method name``.
+        // and will be emitted into CIL  as 'method name'.
+        // Make sure you ignore \', because that is how F# will escape ' if it appears in the method name.
         for (; i < managedMethodName.Length; i++)
         {
+            if ((i - 1) > 0)
+            {
+                previousChar = managedMethodName[i - 1];
+            }
+
             var c = managedMethodName[i];
-            if (c == '\'' || quoted)
+            if ((c == '\'' && previousChar != '\\') || quoted)
             {
-                quoted = c == '\'' ? !quoted : quoted;
+                quoted = (c == '\'' && previousChar != '\\') ? !quoted : quoted;
                 continue;
             }
 

test/Microsoft.TestPlatform.Acceptance.IntegrationTests/ManagedNameTests/SpecialNameTests.cs

@@ -1,6 +1,8 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System;
+using System.Linq;
 using System.Reflection;
 
 using Microsoft.TestPlatform.AcceptanceTests;
@@ -22,13 +24,24 @@ public void VerifyThatInvalidIdentifierNamesAreParsed()
         var assembly = Assembly.LoadFrom(asset);
         var types = assembly.GetTypes();
 
-        foreach (var type in types)
+        // Some methods can be implemented directly on the module, and are not in any class. This is how we get them.
+        var modules = assembly.GetModules().Select(m => new { Module = m, Type = m.GetType() });
+        var moduleTypes = modules.Select(m =>
         {
-            var methods = type.GetMethods();
+            var runtimeTypeProperty = m.Type.GetProperty("RuntimeType", BindingFlags.Instance | BindingFlags.NonPublic);
+            var moduleType = (Type?)runtimeTypeProperty!.GetValue(m.Module, null)!;
+
+            return moduleType;
+        });
+
+        foreach (var type in types.Concat(moduleTypes).Where(t => t != null))
+        {
+            var methods = type!.GetMethods();
 
             foreach (var method in methods)
             {
-                if (method.DeclaringType != type) continue;
+                // Module methods have null Declaring type.
+                if (method.DeclaringType != null && method.DeclaringType != type) continue;
 
                 ManagedNameHelper.GetManagedName(method, out var typeName, out var methodName);
                 var methodInfo = ManagedNameHelper.GetMethod(assembly, typeName, methodName);

test/Microsoft.TestPlatform.AdapterUtilities.UnitTests/ManagedNameUtilities/ManagedNameParserTests.cs

@@ -50,6 +50,15 @@ void AssertParse(string expectedMethod, int expectedArity, string[] expectedPara
         AssertParse("Method", 1, new string[] { "B", "List<B>" }, "Method`1(B,List<B>)");
         AssertParse("Method", 0, new string[] { "B[]" }, "Method(B[])");
         AssertParse("Method", 0, new string[] { "A[,]", "B[,,][]" }, "Method(A[,],B[,,][])");
+
+        // An F# method that would look like this in code: member _.``method that does not pass`` () =
+        // And like this in CIL: instance void 'method that does not pass' () cil managed
+        Assert.AreEqual(("Method that does not pass", 0, null), Parse("'Method that does not pass'()"));
+
+        // An F# method that would look like this in code: member _.``method that doesn't pass`` () =
+        // And like this in CIL: instance void 'method that doesn\'t pass' () cil managed
+        // Notice the ' escaped by \.
+        Assert.AreEqual(("Method that doesn't pass", 0, null), Parse(@"'Method that doesn\'t pass'()"));
     }
 
     [TestMethod]

test/TestAssets/CILProject/OrphanMethod.il

@@ -2,24 +2,43 @@
 .assembly extern mscorlib {}
 .assembly extern System.Core {}
 
-.method static public int32 Add(int32 x, int32 y) cil managed 
+.class public CleanNamespaceName.ClassName
 {
-    .maxstack 2
+    .method static public int32 Add(int32 x, int32 y) cil managed 
+    {
+        .maxstack 2
 
-    ldarg.0
-    ldarg.1
-    add
-    ret
-}
+        ldarg.0
+        ldarg.1
+        add
+        ret
+    }
 
-.method static public int32 'An awesome method to add 𝓧➕𝓨'(int32 '𝓧', int32 '𝓨') cil managed 
-{
-    .maxstack 2
+    .method static public int32 'An awesome method to add 𝓧➕𝓨'(int32 '𝓧', int32 '𝓨') cil managed 
+    {
+        .maxstack 2
+
+        ldarg.0
+        ldarg.1
+        add
+        ret
+    }
+
+    // has ' and no spaces, e.g. coming from F# method ``don't``
+    .method static public void 'don\'t'() cil managed 
+    {
+        .maxstack 1
+
+        ret
+    }
 
-    ldarg.0
-    ldarg.1
-    add
-    ret
+    // has ' and a space, e.g. coming from F# method ``don't pass``
+    .method static public void 'don\'t pass'() cil managed 
+    {
+        .maxstack 1
+
+        ret
+    }
 }
 
 .class public CleanNamespaceName.SecondLevel.'𝐌𝐲 𝗮𝘄𝗲𝘀𝗼𝗺𝗲 𝘤𝘭𝘢𝘴𝘴 𝘢𝘯 𝒊𝒏𝒂𝒄𝒄𝒆𝒔𝒔𝒊𝒃𝒍𝒆 𝙣𝙖𝙢𝙚 😭'