List-patterns: mitigate break with Length property patterns

docs/compilers/CSharp/Compiler Breaking Changes - DotNet 7.md

@@ -0,0 +1,12 @@
+## This document lists known breaking changes in Roslyn after .NET 6 all the way to .NET 7.
+
+1. Beginning with C# 11.0, `Length` and `Count` properties on countable and indexable types
+are assumed to be non-negative for purpose of subsumption and exhaustiveness analysis of patterns and switches.
+Those types can be used with implicit Index indexer and list patterns.
+
+    ```csharp
+    void M(int[] i)
+    {
+        if (i is { Length: -1 }) {} // warning: impossible under assumption of non-negative length
+    }
+    ```

docs/compilers/CSharp/readme.md

@@ -1,5 +1,6 @@
 Breaking changes (newest release on top):
 
+- [.NET 7](https://github.com/dotnet/roslyn/blob/main/docs/compilers/CSharp/Compiler%20Breaking%20Changes%20-%20DotNet%207.md)
 - [.NET 6 and Visual Studio 2022](https://github.com/dotnet/roslyn/blob/main/docs/compilers/CSharp/Compiler%20Breaking%20Changes%20-%20DotNet%206.md)
 - [Minor releases following .NET 5 and Visual Studio 2019 version 16.9](https://github.com/dotnet/roslyn/blob/main/docs/compilers/CSharp/Compiler%20Breaking%20Changes%20-%20post%20DotNet%205.md)
 - [.NET 5 and Visual Studio 2019 version 16.9](https://github.com/dotnet/roslyn/blob/main/docs/compilers/CSharp/Compiler%20Breaking%20Changes%20-%20DotNet%205.md)

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

@@ -57,13 +57,20 @@ private BoundExpression MakeIsPatternExpression(
             BoundDecisionDag decisionDag = DecisionDagBuilder.CreateDecisionDagForIsPattern(
                 this.Compilation, pattern.Syntax, expression, innerPattern, whenTrueLabel: whenTrueLabel, whenFalseLabel: whenFalseLabel, diagnostics);
 
-            if (!hasErrors && getConstantResult(decisionDag, negated, whenTrueLabel, whenFalseLabel) is { } constantResult)
+            if (!hasErrors && getConstantResult(decisionDag, negated, whenTrueLabel, whenFalseLabel) is ({ } constantResult, var isWeakConstantResult))
             {
                 if (!constantResult)
                 {
                     Debug.Assert(expression.Type is object);
-                    diagnostics.Add(ErrorCode.ERR_IsPatternImpossible, node.Location, expression.Type);
-                    hasErrors = true;
+                    if (isWeakConstantResult)
+                    {
+                        diagnostics.Add(ErrorCode.WRN_IsPatternImpossibleIfNonNegativeLength, node.Location, expression.Type);
+                    }
+                    else
+                    {
+                        diagnostics.Add(ErrorCode.ERR_IsPatternImpossible, node.Location, expression.Type);
+                        hasErrors = true;
+                    }
                 }
                 else
                 {
@@ -79,7 +86,7 @@ private BoundExpression MakeIsPatternExpression(
                         case BoundNegatedPattern _:
                         case BoundBinaryPattern _:
                             Debug.Assert(expression.Type is object);
-                            diagnostics.Add(ErrorCode.WRN_IsPatternAlways, node.Location, expression.Type);
+                            diagnostics.Add(isWeakConstantResult ? ErrorCode.WRN_IsPatternAlwaysIfNonNegativeLength : ErrorCode.WRN_IsPatternAlways, node.Location, expression.Type);
                             break;
                         case BoundDiscardPattern _:
                             // we do not give a warning on this because it is an existing scenario, and it should
@@ -94,8 +101,9 @@ private BoundExpression MakeIsPatternExpression(
             }
             else if (expression.ConstantValue != null)
             {
+                // TODO2
                 decisionDag = decisionDag.SimplifyDecisionDagIfConstantInput(expression);
-                if (!hasErrors && getConstantResult(decisionDag, negated, whenTrueLabel, whenFalseLabel) is { } simplifiedResult)
+                if (!hasErrors && getConstantResult(decisionDag, negated, whenTrueLabel, whenFalseLabel) is ({ } simplifiedResult, var isWeakSimplifiedResult))
                 {
                     if (!simplifiedResult)
                     {
@@ -125,17 +133,26 @@ private BoundExpression MakeIsPatternExpression(
             return new BoundIsPatternExpression(
                 node, expression, pattern, negated, decisionDag, whenTrueLabel: whenTrueLabel, whenFalseLabel: whenFalseLabel, boolType, hasErrors);
 
-            static bool? getConstantResult(BoundDecisionDag decisionDag, bool negated, LabelSymbol whenTrueLabel, LabelSymbol whenFalseLabel)
+            static (bool? Result, bool IsWeakResult) getConstantResult(BoundDecisionDag decisionDag, bool negated, LabelSymbol whenTrueLabel, LabelSymbol whenFalseLabel)
             {
+                // TODO2 discount null tests from analysis
                 if (!decisionDag.ReachableLabels.Contains(whenTrueLabel))
                 {
-                    return negated;
+                    return (negated, false);
                 }
                 else if (!decisionDag.ReachableLabels.Contains(whenFalseLabel))
                 {
-                    return !negated;
+                    return (!negated, false);
+                }
+                else if (!decisionDag.ReachableWithoutNegativeBranchLabels.Contains(whenTrueLabel))
+                {
+                    return (negated, true);
+                }
+                else if (!decisionDag.ReachableWithoutNegativeBranchLabels.Contains(whenFalseLabel))
+                {
+                    return (!negated, true);
                 }
-                return null;
+                return (null, false);
             }
         }