[Version 11.0] Feature support for pattern match span char on constant string

standard/patterns.md

@@ -1,27 +1,27 @@
 # 11 Patterns and pattern matching
 
 ## 11.1 General
 
 A ***pattern*** may be used with the `is` operator ([§12.15.12](expressions.md#121512-the-is-operator)), in a *switch_statement* ([§13.8.3](statements.md#1383-the-switch-statement)), and in a *switch_expression* ([§12.12](expressions.md#1212-switch-expression)) to describe the shape of data against which incoming data is to be compared. Patterns may be nested, with parts of the data being matched against ***sub-patterns***.
 
 A pattern is tested against a value in a number of contexts:
 
 - In a *switch_statement*, the *pattern* of a *switch_label* is tested against the *selector_expression* of the *switch_statement*.
 - With an *is-pattern* operator, the *pattern* on the right-hand-side is tested against the expression on the left.
 - In a *switch_expression*, the *pattern* of a *switch_expression_arm* is tested against the expression on the *switch_expression*’s left-hand-side.
 - In nested contexts, the *sub-pattern* is tested against values retrieved from properties, fields, or indexed from other input values, depending on the pattern form.
 
 The value against which a pattern is tested is called the ***pattern input value***.
 
 A pattern `P` is *subsumed* by set of unguarded patterns `Q` if any input value matched by `P` is matched by one of the members of `Q`.
 
 In a switch statement ([§13.8.3](statements.md#1383-the-switch-statement)), it is an error if a case’s pattern is *subsumed* by the preceding set of *unguarded* ([§13.8.3](statements.md#1383-the-switch-statement)) cases. In a switch expression ([§12.12](expressions.md#1212-switch-expression)), it is an error if a *switch_expression_arm*’s pattern is *subsumed* by the preceding set of *unguarded* *switch_expression_arm*s’ patterns.
 
 A set of patterns is exhaustive if, for every possible input value, some pattern in the set is applicable. When an implementation detects that a set of patterns is not exhaustive, it shall issue a warning.
 
 ## 11.2 Pattern forms
 
 ### 11.2.1 General
 
 A pattern may have one of the following forms:
 
@@ -160,7 +160,7 @@
     ;
 ```
 
-A constant pattern `P` is *applicable to* a type `T` if there is an implicit conversion from the constant expression of `P` to the type `T`.
+A constant pattern `P` is *applicable to* a type `T` if there is an implicit conversion from the constant expression of `P` to the type `T`, or if `T` is `System.Span<char>` or `System.ReadOnlySpan<char>` and the constant expression of `P` is of type `string` and is not the `null` literal.
 
 For a constant pattern `P`, its *converted value* is
 
@@ -171,6 +171,7 @@
 Given a pattern input value *e* and a constant pattern `P` with converted value *v*,
 
 - if *e* has integral type or enum type, or a nullable form of one of those, and *v* has integral type, the pattern `P` *matches* the value *e* if result of the expression `e == v` is `true`; otherwise
+- if *e* is of type `System.Span<char>` or `System.ReadOnlySpan<char>`, and *v* is a constant string, and *v* does not have a constant value of `null`, the pattern `P` *matches* the value *e* if `System.MemoryExtensions.SequenceEqual<char>(e, System.MemoryExtensions.AsSpan(v))` returns `true`; otherwise
 - the pattern `P` *matches* the value *e* if `object.Equals(e, v)` returns `true`.
 
 > *Example*: The `switch` statement in the following method uses five constant patterns in its case labels.

standard/standard-library.md

@@ -404,6 +404,15 @@ namespace System
 
     public abstract class FormattableString : IFormattable { }
 
+    public static class MemoryExtensions
+    {
+        public static ReadOnlySpan<char> AsSpan (this string? text);
+        public static bool SequenceEqual<T> (this Span<T> span, ReadOnlySpan<T> other)
+          where T : IEquatable<T>;
+        public static bool SequenceEqual<T> (this ReadOnlySpan<T> span,
+          ReadOnlySpan<T> other) where T : IEquatable<T>;
+    }
+
     public class OperationCanceledException : Exception
     {
         public OperationCanceledException();
@@ -1418,6 +1427,7 @@ The following library types are referenced in this specification. The full names
 - `global::System.IntPtr`
 - `global::System.InvalidCastException`
 - `global::System.InvalidOperationException`
+- `global::System.MemoryExtensions`
 - `global::System.NotSupportedException`
 - `global::System.Nullable<T>`
 - `global::System.NullReferenceException`