Targeted perf changes to CommandLineParser (#78446)

CommandLineParser shows up as surprisingly expensive in the speedometer traces I've been looking at for solution load. This PR attempts a couple small, targeted fixes for a slight improvement.

IsOptionName was doing either 1 or 2 passes in the standard ascii case. Instead, do a length check upfront so that we commonly do 0 passes, and if the lengths match, do 1 pass in the ascii case. In the non-ascii case, fall back to using the ReadOnlySpan's Equals as the code did before. This is a small CPU win reflected by the first two images below.

TryParseOption's calls to IndexOf are showing up in the trace. We can limit the span we search significantly as colon typically is found towards the beginning of arg and arg can be quite long. Small CPU win again, reflected by the 3rd and 4th images below.

ParseSeparatedStrings is a very commonly tread codepath. Small micro-optimizations in the loop to not do the IndexOf call when c is a quote and to check the common condition first.

See PR for performance details from speedometer runs.

Author: ToddGrun

src/Compilers/Core/Portable/CommandLine/CommandLineParser.cs

@@ -98,32 +98,39 @@ internal static bool IsOptionName(string shortOptionName, string longOptionName,
         /// </remarks>
         internal static bool IsOptionName(string optionName, ReadOnlySpan<char> value)
         {
-            Debug.Assert(isAllAscii(optionName.AsSpan()));
-            if (isAllAscii(value))
+            assertAllAscii(optionName.AsSpan());
+
+            if (optionName.Length != value.Length)
+                return false;
+
+            for (int i = 0; i < optionName.Length; i++)
             {
-                if (optionName.Length != value.Length)
-                    return false;
+                char ch = value[i];
+                if (ch > 127)
+                {
+                    // If a non-ascii character is encountered, do an InvariantCultureIgnoreCase comparison
+                    return optionName.AsSpan().Equals(value, StringComparison.InvariantCultureIgnoreCase);
+                }
 
-                for (int i = 0; i < optionName.Length; i++)
+                if (optionName[i] != char.ToLowerInvariant(ch))
                 {
-                    if (optionName[i] != char.ToLowerInvariant(value[i]))
-                    {
-                        return false;
-                    }
+                    return false;
                 }
-                return true;
             }
 
-            return optionName.AsSpan().Equals(value, StringComparison.InvariantCultureIgnoreCase);
+            return true;
 
-            static bool isAllAscii(ReadOnlySpan<char> span)
+            [Conditional("DEBUG")]
+            static void assertAllAscii(ReadOnlySpan<char> span)
             {
                 foreach (char ch in span)
                 {
                     if (ch > 127)
-                        return false;
+                    {
+                        Debug.Assert(false);
+                        break;
+                    }
                 }
-                return true;
             }
         }
 
@@ -167,16 +174,19 @@ internal static bool TryParseOption(string arg, out ReadOnlyMemory<char> name, o
                 return true;
             }
 
-            int colon = arg.IndexOf(':');
+            int colon = arg.IndexOf(':', 1);
 
             // temporary heuristic to detect Unix-style rooted paths
             // pattern /goo/*  or  //* will not be treated as a compiler option
             //
             // TODO: consider introducing "/s:path" to disambiguate paths starting with /
             if (arg.Length > 1 && arg[0] != '-')
             {
-                int separator = arg.IndexOf('/', 1);
-                if (separator > 0 && (colon < 0 || separator < colon))
+                int separator = colon < 0
+                    ? arg.IndexOf('/', 1)
+                    : arg.IndexOf('/', 1, colon - 1);
+
+                if (separator > 0)
                 {
                     //   "/goo/
                     //   "//
@@ -1064,11 +1074,10 @@ internal static void ParseSeparatedStrings(ReadOnlyMemory<char>? strMemory, char
                 {
                     inQuotes = !inQuotes;
                 }
-
-                if (!inQuotes && separators.IndexOf(c) >= 0)
+                else if (!inQuotes && separators.Contains(c))
                 {
                     var current = memory.Slice(nextPiece, i - nextPiece);
-                    if (!removeEmptyEntries || current.Length > 0)
+                    if (current.Length > 0 || !removeEmptyEntries)
                     {
                         builder.Add(current);
                     }
@@ -1078,7 +1087,7 @@ internal static void ParseSeparatedStrings(ReadOnlyMemory<char>? strMemory, char
             }
 
             var last = memory.Slice(nextPiece);
-            if (!removeEmptyEntries || last.Length > 0)
+            if (last.Length > 0 || !removeEmptyEntries)
             {
                 builder.Add(last);
             }