Relax conversion requirements for pattern-matching involving type parameters.

src/Compilers/CSharp/Portable/Binder/Binder_Patterns.cs

@@ -197,8 +197,26 @@ private bool CheckValidPatternType(
                     //case ConversionKind.ImplicitConstant:
                     //case ConversionKind.ImplicitNumeric:
                     default:
-                        Error(diagnostics, ErrorCode.ERR_PatternWrongType, typeSyntax, operandType, patternType);
-                        return true;
+                        if (operandType.ContainsTypeParameter() || patternType.ContainsTypeParameter())
+                        {
+                            LanguageVersion requiredVersion = MessageID.IDS_FeatureGenericPatternMatching.RequiredVersion();
+                            if (requiredVersion > Compilation.LanguageVersion)
+                            {
+                                Error(diagnostics, ErrorCode.ERR_PatternWrongGenericTypeInVersion, typeSyntax,
+                                    operandType, patternType,
+                                    Compilation.LanguageVersion.ToDisplayString(),
+                                    new CSharpRequiredLanguageVersion(requiredVersion));
+                                return true;
+                            }
+
+                            // permit pattern-matching when one of the types is an open type in C# 7.1.
+                            break;
+                        }
+                        else
+                        {
+                            Error(diagnostics, ErrorCode.ERR_PatternWrongType, typeSyntax, operandType, patternType);
+                            return true;
+                        }
                 }
             }
 

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -4892,7 +4892,7 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
     <value>The switch case has already been handled by a previous case.</value>
   </data>
   <data name="ERR_PatternWrongType" xml:space="preserve">
-    <value>An expression of type {0} cannot be handled by a pattern of type {1}.</value>
+    <value>An expression of type '{0}' cannot be handled by a pattern of type '{1}'.</value>
   </data>
   <data name="WRN_AttributeIgnoredWhenPublicSigning" xml:space="preserve">
     <value>Attribute '{0}' is ignored when public signing is specified.</value>
@@ -5062,4 +5062,7 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_VoidInTuple" xml:space="preserve">
     <value>A tuple may not contain a value of type 'void'.</value>
   </data>
+  <data name="ERR_PatternWrongGenericTypeInVersion" xml:space="preserve">
+    <value>An expression of type '{0}' cannot be handled by a pattern of type '{1}' in C# {2}. Please use language version {3} or greater.</value>
+  </data>
 </root>

src/Compilers/CSharp/Portable/Errors/ErrorCode.cs

@@ -1474,8 +1474,13 @@ internal enum ErrorCode
         ERR_LanguageVersionCannotHaveLeadingZeroes = 8303,
         ERR_CompilerAndLanguageVersion = 8304,
 
+        #region diagnostics for C# 7.1
+
         ERR_BadDynamicMethodArgDefaultLiteral = 9000,
         ERR_DefaultLiteralNotValid = 9001,
         WRN_DefaultInSwitch = 9002,
+        ERR_PatternWrongGenericTypeInVersion = 9003,
+
+        #endregion diagnostics for C# 7.1
     }
 }

src/Compilers/CSharp/Portable/Errors/MessageID.cs

@@ -128,6 +128,7 @@ internal enum MessageID
         IDS_FeatureExpressionBodiedDeOrConstructor = MessageBase + 12716,
         IDS_ThrowExpression = MessageBase + 12717,
         IDS_FeatureDefaultLiteral = MessageBase + 12718,
+        IDS_FeatureGenericPatternMatching = MessageBase + 12719,
     }
 
     // Message IDs may refer to strings that need to be localized.
@@ -186,6 +187,7 @@ internal static LanguageVersion RequiredVersion(this MessageID feature)
             {
                 // C# 7.1 features.
                 case MessageID.IDS_FeatureDefaultLiteral:
+                case MessageID.IDS_FeatureGenericPatternMatching:
                     return LanguageVersion.CSharp7_1;
 
                 // C# 7 features.

src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Patterns.cs

@@ -145,10 +145,6 @@ BoundExpression MakeIsDeclarationPattern(SyntaxNode syntax, BoundExpression lowe
         {
             var type = loweredTarget.Type;
 
-            // The type here is not a Nullable<T> instance type, as that would have led to the semantic error:
-            // ERR_PatternNullableType: It is not legal to use nullable type '{0}' in a pattern; use the underlying type '{1}' instead.
-            Debug.Assert(!type.IsNullableType());
-
             // a pattern match of the form "expression is Type identifier" is equivalent to
             // an invocation of one of these helpers:
             if (type.IsReferenceType)
@@ -175,8 +171,13 @@ BoundExpression MakeIsDeclarationPattern(SyntaxNode syntax, BoundExpression lowe
             }
             else if (type.IsValueType)
             {
+                // The type here is not a Nullable<T> instance type, as that would have led to the semantic error:
+                // ERR_PatternNullableType: It is not legal to use nullable type '{0}' in a pattern; use the underlying type '{1}' instead.
+                Debug.Assert(!type.IsNullableType());
+
                 // It is possible that the input value is already of the correct type, in which case the pattern
-                // is irrefutable, and we can just do the assignment and return true.
+                // is irrefutable (there is no way for a non-nullable value type to be null), and we can just do
+                // the assignment and return true.
                 if (loweredInput.Type == type)
                 {
                     return _factory.MakeSequence(
@@ -207,18 +208,26 @@ BoundExpression MakeIsDeclarationPattern(SyntaxNode syntax, BoundExpression lowe
                 Debug.Assert(type.IsTypeParameter());
                 // bool Is<T>(this object i, out T o)
                 // {
-                //     // inefficient because it performs the type test twice.
+                //     // inefficient because it performs the type test twice, and also because it boxes the input.
                 //     bool s = i is T;
-                //     if (s) o = (T)i;
+                //     o = s ? (T)i : default(T);
                 //     return s;
                 // }
-                return _factory.Conditional(_factory.Is(loweredInput, type),
-                    _factory.MakeSequence(_factory.AssignmentExpression(
-                        loweredTarget,
-                        _factory.Convert(type, loweredInput)),
-                        _factory.Literal(true)),
-                    _factory.Literal(false),
-                    _factory.SpecialType(SpecialType.System_Boolean));
+
+                // Because a cast involving a type parameter is not necessarily a valid conversion (or, if it is, it might not
+                // be of a kind appropriate for pattern-matching), we use `object` as an intermediate type for the input expression.
+                var tmpType = _factory.SpecialType(SpecialType.System_Object);
+                var s = _factory.SynthesizedLocal(_factory.SpecialType(SpecialType.System_Boolean), syntax);
+                var i = _factory.SynthesizedLocal(tmpType, syntax); // we copy the input to avoid double evaluation
+                return _factory.Sequence(
+                    ImmutableArray.Create(s, i),
+                    ImmutableArray.Create<BoundExpression>(
+                        _factory.AssignmentExpression(_factory.Local(i), _factory.Convert(tmpType, loweredInput)),
+                        _factory.AssignmentExpression(_factory.Local(s), _factory.Is(_factory.Local(i), type)),
+                        _factory.AssignmentExpression(loweredTarget, _factory.Conditional(_factory.Local(s), _factory.Convert(type, _factory.Local(i)), _factory.Default(type), type))
+                        ),
+                    _factory.Local(s)
+                    );
             }
         }
     }

src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs

@@ -1104,6 +1104,7 @@ public BoundExpression Convert(TypeSymbol type, BoundExpression arg)
         {
             HashSet<DiagnosticInfo> useSiteDiagnostics = null;
             Conversion c = Compilation.Conversions.ClassifyConversionFromExpression(arg, type, ref useSiteDiagnostics);
+            Debug.Assert(c.Exists);
             Debug.Assert(useSiteDiagnostics.IsNullOrEmpty());
 
             // If this happens, we should probably check if the method has ObsoleteAttribute.

src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests.cs

@@ -5674,5 +5674,91 @@ public static void Main(string[] args)
             var compilation = CreateCompilationWithMscorlib45(source, references: new MetadataReference[] { CSharpRef, SystemCoreRef }, options: TestOptions.ReleaseExe);
             var comp = CompileAndVerify(compilation, expectedOutput: "roslyn");
         }
+
+        [Fact, WorkItem(16195, "https://github.com/dotnet/roslyn/issues/16195")]
+        public void OpenTypeMatch_01()
+        {
+            var source =
+@"using System;
+public class Base { }
+public class Derived : Base { }
+public class Program
+{
+    public static void Main(string[] args)
+    {
+        M(new Derived());
+        M(new Base());
+    }
+    public static void M<T>(T x) where T: Base
+    {
+        Console.Write(x is Derived b0);
+        switch (x)
+        {
+            case Derived b1:
+                Console.Write(1);
+                break;
+            default:
+                Console.Write(0);
+                break;
+        }
+    }
+}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, references: new MetadataReference[] { CSharpRef, SystemCoreRef }, options: TestOptions.ReleaseExe, parseOptions: TestOptions.Regular);
+            compilation.VerifyDiagnostics(
+                // (13,28): error CS9003: An expression of type 'T' cannot be handled by a pattern of type 'Derived' in C# 7. Please use language version 7.1 or greater.
+                //         Console.Write(x is Derived b0);
+                Diagnostic(ErrorCode.ERR_PatternWrongGenericTypeInVersion, "Derived").WithArguments("T", "Derived", "7", "7.1").WithLocation(13, 28),
+                // (16,18): error CS9003: An expression of type 'T' cannot be handled by a pattern of type 'Derived' in C# 7. Please use language version 7.1 or greater.
+                //             case Derived b1:
+                Diagnostic(ErrorCode.ERR_PatternWrongGenericTypeInVersion, "Derived").WithArguments("T", "Derived", "7", "7.1").WithLocation(16, 18)
+                );
+            compilation = CreateCompilationWithMscorlib45(source, references: new MetadataReference[] { CSharpRef, SystemCoreRef }, options: TestOptions.ReleaseExe, parseOptions: TestOptions.Regular7_1);
+            compilation.VerifyDiagnostics();
+            CompileAndVerify(compilation, expectedOutput: "True1False0");
+        }
+
+        [Fact, WorkItem(16195, "https://github.com/dotnet/roslyn/issues/16195")]
+        public void OpenTypeMatch_02()
+        {
+            var source =
+@"using System;
+public class Base { }
+public class Derived : Base { }
+public class Program
+{
+    public static void Main(string[] args)
+    {
+        M<Derived>(new Derived());
+        M<Derived>(new Base());
+    }
+    public static void M<T>(Base x)
+    {
+        Console.Write(x is T b0);
+        switch (x)
+        {
+            case T b1:
+                Console.Write(1);
+                break;
+            default:
+                Console.Write(0);
+                break;
+        }
+    }
+}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, references: new MetadataReference[] { CSharpRef, SystemCoreRef }, options: TestOptions.ReleaseExe, parseOptions: TestOptions.Regular);
+            compilation.VerifyDiagnostics(
+                // (13,28): error CS9003: An expression of type 'Base' cannot be handled by a pattern of type 'T' in C# 7. Please use language version 7.1 or greater.
+                //         Console.Write(x is T b0);
+                Diagnostic(ErrorCode.ERR_PatternWrongGenericTypeInVersion, "T").WithArguments("Base", "T", "7", "7.1").WithLocation(13, 28),
+                // (16,18): error CS9003: An expression of type 'Base' cannot be handled by a pattern of type 'T' in C# 7. Please use language version 7.1 or greater.
+                //             case T b1:
+                Diagnostic(ErrorCode.ERR_PatternWrongGenericTypeInVersion, "T").WithArguments("Base", "T", "7", "7.1")
+                );
+            compilation = CreateCompilationWithMscorlib45(source, references: new MetadataReference[] { CSharpRef, SystemCoreRef }, options: TestOptions.ReleaseExe, parseOptions: TestOptions.Regular7_1);
+            compilation.VerifyDiagnostics();
+            CompileAndVerify(compilation, expectedOutput: "True1False0");
+        }
     }
 }

src/EditorFeatures/CSharpTest/Diagnostics/UpgradeProject/UpgradeProjectTests.cs

@@ -111,6 +111,25 @@ class Program
                 index: 1);
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUpgradeProject)]
+        public async Task UpgradeProjectFromCSharp7ToCSharp7_1_B()
+        {
+            await TestLanguageVersionUpgradedAsync(
+@"public class Base { }
+public class Derived : Base { }
+public class Program
+{
+    public static void M<T>(T x) where T: Base
+    {
+        System.Console.Write(x is [|Derived|] b0);
+    }
+}
+",
+                LanguageVersion.CSharp7_1,
+                new CSharpParseOptions(LanguageVersion.CSharp7),
+                index: 1);
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUpgradeProject)]
         public async Task UpgradeAllProjectsToDefault()
         {

src/Features/CSharp/Portable/UpgradeProject/CSharpUpgradeProjectCodeFixProvider.cs

@@ -24,9 +24,10 @@ internal class CSharpUpgradeProjectCodeFixProvider : AbstractUpgradeProjectCodeF
         private const string CS8059 = nameof(CS8059); // error CS8059: Feature is not available in C# 6. Please use language version X or greater.
         private const string CS8107 = nameof(CS8107); // error CS8059: Feature is not available in C# 7.0. Please use language version X or greater.
         private const string CS8302 = nameof(CS8302); // error CS8302: Feature is not available in C# 7.1. Please use language version X or greater.
+        private const string CS9003 = nameof(CS9003); // error CS9003: An expression of type '{0}' cannot be handled by a pattern of type '{1}' in C# {2}. Please use language version {3} or greater.
 
         public override ImmutableArray<string> FixableDiagnosticIds { get; } =
-            ImmutableArray.Create(CS8022, CS8023, CS8024, CS8025, CS8026, CS8059, CS8107, CS8302);
+            ImmutableArray.Create(CS8022, CS8023, CS8024, CS8025, CS8026, CS8059, CS8107, CS8302, CS9003);
 
         public override string UpgradeThisProjectResource => CSharpFeaturesResources.Upgrade_this_project_to_csharp_language_version_0;
         public override string UpgradeAllProjectsResource => CSharpFeaturesResources.Upgrade_all_csharp_projects_to_language_version_0;