Extend regex switch alternation optimization to IgnoreCase

[stephentoub]

IgnoreCase now results in producing sets (e.g. an 'a' becomes '[Aa]') but the source generator's optimization that produces a switch statements for alternations with non-overlapping branches doesn't yet understand such sets. This augments that logic to fix that.
Fixes #62438

Example pattern:
abc|def with RegexOptions.IgnoreCase

Before:

// Match with 2 alternative expressions, atomically.
{
    int alternation_starting_pos = pos;
                        
    // Branch 0
    {
        if ((uint)slice.Length < 3 ||
            ((slice[0] | 0x20) != 'a') || // Match a character in the set [Aa].
            ((slice[1] | 0x20) != 'b') || // Match a character in the set [Bb].
            ((slice[2] | 0x20) != 'c')) // Match a character in the set [Cc].
        {
            goto AlternationBranch;
        }
                            
        pos += 3;
        slice = slice.Slice(3);
        goto AlternationMatch;
                            
        AlternationBranch:
        pos = alternation_starting_pos;
        slice = inputSpan.Slice(pos, end - pos);
    }
                        
    // Branch 1
    {
        if ((uint)slice.Length < 3 ||
            ((slice[0] | 0x20) != 'd') || // Match a character in the set [Dd].
            ((slice[1] | 0x20) != 'e') || // Match a character in the set [Ee].
            ((slice[2] | 0x20) != 'f')) // Match a character in the set [Ff].
        {
            goto NoMatch;
        }
                            
        pos += 3;
        slice = slice.Slice(3);
    }
                        
    AlternationMatch:;
}

After:

// Match with 2 alternative expressions, atomically.
{
    if (slice.IsEmpty)
    {
        goto NoMatch;
    }

    switch (slice[0])
    {
        case 'A' or 'a':
            if ((uint)slice.Length < 3 ||
                ((slice[1] | 0x20) != 'b') || // Match a character in the set [Bb].
                ((slice[2] | 0x20) != 'c')) // Match a character in the set [Cc].
            {
                goto NoMatch;
            }

            pos += 3;
            slice = slice.Slice(3);
            break;

        case 'D' or 'd':
            if ((uint)slice.Length < 3 ||
                ((slice[1] | 0x20) != 'e') || // Match a character in the set [Ee].
                ((slice[2] | 0x20) != 'f')) // Match a character in the set [Ff].
            {
                goto NoMatch;
            }

            pos += 3;
            slice = slice.Slice(3);
            break;

        default: goto NoMatch;
    }
}

[ghost]

Tagging subscribers to this area: @dotnet/area-system-text-regularexpressions
See info in area-owners.md if you want to be subscribed.

Issue Details

---

IgnoreCase now results in producing sets (e.g. an 'a' becomes '[Aa]') but the source generator's optimization that produces a switch statements for alternations with non-overlapping branches doesn't yet understand such sets. This augments that logic to fix that.

Example pattern:
abc|def with RegexOptions.IgnoreCase

Before:

// Match with 2 alternative expressions, atomically.
{
    int alternation_starting_pos = pos;
                        
    // Branch 0
    {
        if ((uint)slice.Length < 3 ||
            ((slice[0] | 0x20) != 'a') || // Match a character in the set [Aa].
            ((slice[1] | 0x20) != 'b') || // Match a character in the set [Bb].
            ((slice[2] | 0x20) != 'c')) // Match a character in the set [Cc].
        {
            goto AlternationBranch;
        }
                            
        pos += 3;
        slice = slice.Slice(3);
        goto AlternationMatch;
                            
        AlternationBranch:
        pos = alternation_starting_pos;
        slice = inputSpan.Slice(pos, end - pos);
    }
                        
    // Branch 1
    {
        if ((uint)slice.Length < 3 ||
            ((slice[0] | 0x20) != 'd') || // Match a character in the set [Dd].
            ((slice[1] | 0x20) != 'e') || // Match a character in the set [Ee].
            ((slice[2] | 0x20) != 'f')) // Match a character in the set [Ff].
        {
            goto NoMatch;
        }
                            
        pos += 3;
        slice = slice.Slice(3);
    }
                        
    AlternationMatch:;
}

After:

// Match with 2 alternative expressions, atomically.
{
    if (slice.IsEmpty)
    {
        goto NoMatch;
    }

    switch (textInfo.ToLower(slice[0]))
    {
        case 'A' or 'a':
            if ((uint)slice.Length < 3 ||
                ((slice[1] | 0x20) != 'b') || // Match a character in the set [Bb].
                ((slice[2] | 0x20) != 'c')) // Match a character in the set [Cc].
            {
                goto NoMatch;
            }

            pos += 3;
            slice = slice.Slice(3);
            break;

        case 'D' or 'd':
            if ((uint)slice.Length < 3 ||
                ((slice[1] | 0x20) != 'e') || // Match a character in the set [Ee].
                ((slice[2] | 0x20) != 'f')) // Match a character in the set [Ff].
            {
                goto NoMatch;
            }

            pos += 3;
            slice = slice.Slice(3);
            break;

        default: goto NoMatch;
    }
}

Author:	stephentoub
Assignees:	-
Labels:	area-System.Text.RegularExpressions, tenet-performance
Milestone:	7.0.0