From e033f3b423c1bb454f9ac61d9d51327cda671099 Mon Sep 17 00:00:00 2001
From: Julien Couvreur <julien.couvreur@gmail.com>
Date: Sun, 21 Nov 2021 00:12:51 -0800
Subject: [PATCH 01/11] Add HasValidate

---
 .../CSharp/Portable/Binder/Binder_Patterns.cs   |  2 --
 .../Binder/DecisionDagBuilder_ListPatterns.cs   |  2 --
 .../Portable/BoundTree/BoundDagEvaluation.cs    |  8 ++++++++
 ...rAccess.cs => BoundImplicitIndexerAccess.cs} |  6 ++++++
 .../Portable/BoundTree/BoundListPattern.cs      | 17 +++++++++++++++++
 .../CSharp/Portable/BoundTree/BoundNodes.xml    | 10 +++++-----
 .../CSharp/Portable/BoundTree/BoundNodes.xsd    |  1 +
 .../Portable/BoundTree/BoundSlicePattern.cs     | 16 ++++++++++++++++
 .../Generated/BoundNodes.xml.Generated.cs       | 15 +++++++++++++++
 .../BoundTreeGenerator/BoundNodeClassWriter.cs  | 15 +++++++++++++++
 10 files changed, 83 insertions(+), 9 deletions(-)
 rename src/Compilers/CSharp/Portable/BoundTree/{BoundIndexOrRangePatternIndexerAccess.cs => BoundImplicitIndexerAccess.cs} (84%)
 create mode 100644 src/Compilers/CSharp/Portable/BoundTree/BoundListPattern.cs
 create mode 100644 src/Compilers/CSharp/Portable/BoundTree/BoundSlicePattern.cs

diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Patterns.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Patterns.cs
index 10ef681c61de6..bf19f78e71699 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Patterns.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Patterns.cs
@@ -238,7 +238,6 @@ private BoundPattern BindSlicePattern(
                 pattern = BindPattern(node.Pattern, sliceType, GetValEscape(sliceType, inputValEscape), permitDesignations, hasErrors, diagnostics);
             }
 
-            Debug.Assert(GetIndexerOrImplicitIndexerSymbol(indexerAccess) is var _);
             return new BoundSlicePattern(node, pattern, indexerAccess, receiverPlaceholder, argumentPlaceholder, inputType: inputType, narrowedType: inputType, hasErrors);
         }
 
@@ -317,7 +316,6 @@ private BoundListPattern BindListPattern(
                 inputValEscape, permitDesignations, typeSyntax: null, diagnostics, ref hasErrors,
                 out Symbol? variableSymbol, out BoundExpression? variableAccess);
 
-            Debug.Assert(GetIndexerOrImplicitIndexerSymbol(indexerAccess) is var _);
             return new BoundListPattern(
                 syntax: node, subpatterns: subpatterns, hasSlice: sawSlice, lengthAccess: lengthAccess,
                 indexerAccess: indexerAccess, receiverPlaceholder, argumentPlaceholder, variable: variableSymbol,
diff --git a/src/Compilers/CSharp/Portable/Binder/DecisionDagBuilder_ListPatterns.cs b/src/Compilers/CSharp/Portable/Binder/DecisionDagBuilder_ListPatterns.cs
index 9654b37e324db..1a23e72c651d4 100644
--- a/src/Compilers/CSharp/Portable/Binder/DecisionDagBuilder_ListPatterns.cs
+++ b/src/Compilers/CSharp/Portable/Binder/DecisionDagBuilder_ListPatterns.cs
@@ -60,7 +60,6 @@ private Tests MakeTestsAndBindingsForListPattern(BoundDagTemp input, BoundListPa
                             Debug.Assert(slice.ReceiverPlaceholder is not null);
                             Debug.Assert(slice.ArgumentPlaceholder is not null);
 
-                            Debug.Assert(slice.IndexerAccess is BoundIndexerAccess or BoundImplicitIndexerAccess or BoundArrayAccess);
                             var sliceEvaluation = new BoundDagSliceEvaluation(slicePattern.Syntax, slicePattern.InputType, lengthTemp, startIndex: startIndex, endIndex: index,
                                 slice.IndexerAccess, slice.ReceiverPlaceholder, slice.ArgumentPlaceholder, input);
 
@@ -76,7 +75,6 @@ private Tests MakeTestsAndBindingsForListPattern(BoundDagTemp input, BoundListPa
                     Debug.Assert(list.ReceiverPlaceholder is not null);
                     Debug.Assert(list.ArgumentPlaceholder is not null);
 
-                    Debug.Assert(list.IndexerAccess is BoundIndexerAccess or BoundImplicitIndexerAccess or BoundArrayAccess);
                     var indexEvaluation = new BoundDagIndexerEvaluation(subpattern.Syntax, subpattern.InputType, lengthTemp, index++,
                         list.IndexerAccess, list.ReceiverPlaceholder, list.ArgumentPlaceholder, input);
 
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundDagEvaluation.cs b/src/Compilers/CSharp/Portable/BoundTree/BoundDagEvaluation.cs
index a20ecdb9d9722..5a85b268fc965 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundDagEvaluation.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundDagEvaluation.cs
@@ -108,6 +108,10 @@ public override bool IsEquivalentTo(BoundDagEvaluation obj)
             return base.IsEquivalentTo(obj) &&
                 this.Index == ((BoundDagIndexerEvaluation)obj).Index;
         }
+        private partial void Validate()
+        {
+            Debug.Assert(IndexerAccess is BoundIndexerAccess or BoundImplicitIndexerAccess or BoundArrayAccess);
+        }
     }
 
     partial class BoundDagSliceEvaluation
@@ -119,6 +123,10 @@ public override bool IsEquivalentTo(BoundDagEvaluation obj)
                 (BoundDagSliceEvaluation)obj is var e &&
                 this.StartIndex == e.StartIndex && this.EndIndex == e.EndIndex;
         }
+        private partial void Validate()
+        {
+            Debug.Assert(IndexerAccess is BoundIndexerAccess or BoundImplicitIndexerAccess or BoundArrayAccess);
+        }
     }
 
     partial class BoundDagAssignmentEvaluation
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundIndexOrRangePatternIndexerAccess.cs b/src/Compilers/CSharp/Portable/BoundTree/BoundImplicitIndexerAccess.cs
similarity index 84%
rename from src/Compilers/CSharp/Portable/BoundTree/BoundIndexOrRangePatternIndexerAccess.cs
rename to src/Compilers/CSharp/Portable/BoundTree/BoundImplicitIndexerAccess.cs
index 8c962909e29af..667c866515993 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundIndexOrRangePatternIndexerAccess.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundImplicitIndexerAccess.cs
@@ -29,5 +29,11 @@ internal BoundExpression GetReceiver()
             Debug.Assert(receiver is not null);
             return receiver;
         }
+
+        private partial void Validate()
+        {
+            Debug.Assert(LengthOrCountAccess is BoundPropertyAccess or BoundLocal);
+            Debug.Assert(IndexerOrSliceAccess is BoundIndexerAccess or BoundCall);
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundListPattern.cs b/src/Compilers/CSharp/Portable/BoundTree/BoundListPattern.cs
new file mode 100644
index 0000000000000..94dc5559b57b1
--- /dev/null
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundListPattern.cs
@@ -0,0 +1,17 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Diagnostics;
+
+namespace Microsoft.CodeAnalysis.CSharp
+{
+    internal partial class BoundListPattern
+    {
+        private partial void Validate()
+        {
+            Debug.Assert(LengthAccess is BoundPropertyAccess or BoundBadExpression);
+            Debug.Assert(Binder.GetIndexerOrImplicitIndexerSymbol(IndexerAccess) is var _);
+        }
+    }
+}
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml b/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
index 3fa57b3b32270..bcba580fb3f5b 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
@@ -1519,7 +1519,7 @@
     <Field Name="Index" Type="int"/>
   </Node>
 
-  <Node Name="BoundDagIndexerEvaluation" Base="BoundDagEvaluation">
+  <Node Name="BoundDagIndexerEvaluation" Base="BoundDagEvaluation" HasValidate="true">
     <Field Name="IndexerType" Type="TypeSymbol"/>
     <Field Name="LengthTemp" Type="BoundDagTemp"/>
 
@@ -1539,7 +1539,7 @@
     <Field Name="ArgumentPlaceholder" Type="BoundListPatternIndexPlaceholder"/>
    </Node>
 
-  <Node Name="BoundDagSliceEvaluation" Base="BoundDagEvaluation">
+  <Node Name="BoundDagSliceEvaluation" Base="BoundDagEvaluation" HasValidate="true">
     <Field Name="SliceType" Type="TypeSymbol"/>
     <Field Name="LengthTemp" Type="BoundDagTemp"/>
     <Field Name="StartIndex" Type="int"/>
@@ -2066,7 +2066,7 @@
     <Field Name="OriginalIndexersOpt" Type="ImmutableArray&lt;PropertySymbol&gt;" Null="allow" SkipInNullabilityRewriter="true"/>
   </Node>
 
-  <Node Name="BoundImplicitIndexerAccess" Base="BoundExpression" SkipInNullabilityRewriter="true">
+  <Node Name="BoundImplicitIndexerAccess" Base="BoundExpression" SkipInNullabilityRewriter="true" HasValidate="true">
     <Field Name="Type" Type="TypeSymbol" Override="true" Null="disallow" />
 
     <!-- An expression with type Index or Range -->
@@ -2242,7 +2242,7 @@
     <Field Name="IsExplicitNotNullTest" Type="bool"/>
   </Node>
 
-  <Node Name="BoundListPattern" Base="BoundObjectPattern">
+  <Node Name="BoundListPattern" Base="BoundObjectPattern" HasValidate="true">
     <Field Name="Subpatterns" Type="ImmutableArray&lt;BoundPattern&gt;" Null="disallow"/>
     <Field Name="HasSlice" Type="bool"/>
     <Field Name="LengthAccess" Type="BoundExpression?" SkipInVisitor="true"/>
@@ -2260,7 +2260,7 @@
     <Field Name="ArgumentPlaceholder" Type="BoundListPatternIndexPlaceholder?" SkipInVisitor="true"/>
   </Node>
 
-  <Node Name="BoundSlicePattern" Base="BoundPattern">
+  <Node Name="BoundSlicePattern" Base="BoundPattern" HasValidate="true">
     <Field Name="Pattern" Type="BoundPattern?"/>
 
     <!--
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xsd b/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xsd
index 8911b9a75e511..4a6bbaa16b1b9 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xsd
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xsd
@@ -45,6 +45,7 @@
               <xs:attribute name="Name" type="xs:string" use="required" />
               <xs:attribute name="Base" type="xs:string" use="required" />
               <xs:attribute name="SkipInNullabilityRewriter" type="xs:boolean" use="optional" />
+              <xs:attribute name="HasValidate" type="xs:boolean" use="optional" />
             </xs:complexType>
           </xs:element>
         </xs:choice>
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundSlicePattern.cs b/src/Compilers/CSharp/Portable/BoundTree/BoundSlicePattern.cs
new file mode 100644
index 0000000000000..557cf96cce7a1
--- /dev/null
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundSlicePattern.cs
@@ -0,0 +1,16 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Diagnostics;
+
+namespace Microsoft.CodeAnalysis.CSharp
+{
+    internal partial class BoundSlicePattern
+    {
+        private partial void Validate()
+        {
+            Debug.Assert(Binder.GetIndexerOrImplicitIndexerSymbol(IndexerAccess) is var _);
+        }
+    }
+}
diff --git a/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs b/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
index 19c0f70810bb8..87570dbafc1ad 100644
--- a/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
+++ b/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
@@ -5453,8 +5453,11 @@ public BoundDagIndexerEvaluation(SyntaxNode syntax, TypeSymbol indexerType, Boun
             this.IndexerAccess = indexerAccess;
             this.ReceiverPlaceholder = receiverPlaceholder;
             this.ArgumentPlaceholder = argumentPlaceholder;
+            Validate();
         }
 
+        private partial void Validate();
+
 
         public TypeSymbol IndexerType { get; }
 
@@ -5502,8 +5505,11 @@ public BoundDagSliceEvaluation(SyntaxNode syntax, TypeSymbol sliceType, BoundDag
             this.IndexerAccess = indexerAccess;
             this.ReceiverPlaceholder = receiverPlaceholder;
             this.ArgumentPlaceholder = argumentPlaceholder;
+            Validate();
         }
 
+        private partial void Validate();
+
 
         public TypeSymbol SliceType { get; }
 
@@ -7338,8 +7344,11 @@ public BoundImplicitIndexerAccess(SyntaxNode syntax, BoundExpression argument, B
             this.ReceiverPlaceholder = receiverPlaceholder;
             this.IndexerOrSliceAccess = indexerOrSliceAccess;
             this.ArgumentPlaceholders = argumentPlaceholders;
+            Validate();
         }
 
+        private partial void Validate();
+
 
         public new TypeSymbol Type => base.Type!;
 
@@ -8046,8 +8055,11 @@ public BoundListPattern(SyntaxNode syntax, ImmutableArray<BoundPattern> subpatte
             this.IndexerAccess = indexerAccess;
             this.ReceiverPlaceholder = receiverPlaceholder;
             this.ArgumentPlaceholder = argumentPlaceholder;
+            Validate();
         }
 
+        private partial void Validate();
+
 
         public ImmutableArray<BoundPattern> Subpatterns { get; }
 
@@ -8088,8 +8100,11 @@ public BoundSlicePattern(SyntaxNode syntax, BoundPattern? pattern, BoundExpressi
             this.IndexerAccess = indexerAccess;
             this.ReceiverPlaceholder = receiverPlaceholder;
             this.ArgumentPlaceholder = argumentPlaceholder;
+            Validate();
         }
 
+        private partial void Validate();
+
 
         public BoundPattern? Pattern { get; }
 
diff --git a/src/Tools/Source/CompilerGeneratorTools/Source/BoundTreeGenerator/BoundNodeClassWriter.cs b/src/Tools/Source/CompilerGeneratorTools/Source/BoundTreeGenerator/BoundNodeClassWriter.cs
index fde6fa747ce1a..8c2469e487b1c 100644
--- a/src/Tools/Source/CompilerGeneratorTools/Source/BoundTreeGenerator/BoundNodeClassWriter.cs
+++ b/src/Tools/Source/CompilerGeneratorTools/Source/BoundTreeGenerator/BoundNodeClassWriter.cs
@@ -471,8 +471,23 @@ private void WriteConstructorWithHasErrors(TreeType node, bool isPublic, bool ha
                                 WriteLine("this.{0} = {1};", field.Name, FieldNullHandling(node, field.Name) == NullHandling.Always ? "null" : ToCamelCase(field.Name));
                             }
                         }
+
+                        bool hasValidate = HasValidate(node);
+
+                        if (hasValidate)
+                        {
+                            WriteLine("Validate();");
+                        }
+
                         Unbrace();
                         Blank();
+
+                        if (hasValidate)
+                        {
+                            WriteLine("private partial void Validate();");
+                            Blank();
+                        }
+
                         break;
                     }
 

From ea9f5d6f4edcf356eb5b61eb9351bcf2fded3444 Mon Sep 17 00:00:00 2001
From: Julien Couvreur <julien.couvreur@gmail.com>
Date: Sun, 21 Nov 2021 13:02:38 -0800
Subject: [PATCH 02/11] Test plan

---
 docs/contributing/Compiler Test Plan.md       |  2 +-
 .../PatternMatchingTests_ListPatterns.cs      | 84 +++++++++++++++++++
 .../Test/Utilities/CSharp/TestSources.cs      | 10 +++
 3 files changed, 95 insertions(+), 1 deletion(-)

diff --git a/docs/contributing/Compiler Test Plan.md b/docs/contributing/Compiler Test Plan.md
index aeb03d6ee561b..2de380f764673 100644
--- a/docs/contributing/Compiler Test Plan.md	
+++ b/docs/contributing/Compiler Test Plan.md	
@@ -93,7 +93,7 @@ This document provides guidance for thinking about language interactions and tes
 - Ref return, ref readonly return, ref ternary, ref readonly local, ref local re-assignment, ref foreach
 - `this = e;` in `struct` .ctor
 - Stackalloc (including initializers)
-- Patterns (constant, declaration, `var`, positional, property and extended property, discard, parenthesized, type, relational, `and`/`or`/`not`)
+- Patterns (constant, declaration, `var`, positional, property and extended property, discard, parenthesized, type, relational, `and`/`or`/`not`, list, slice)
 - Switch expressions
 - With expressions (on record classes and on value types)
 - Nullability annotations (`?`, attributes) and analysis
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests_ListPatterns.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests_ListPatterns.cs
index d5c191d7da402..d28ef21761360 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests_ListPatterns.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests_ListPatterns.cs
@@ -6692,6 +6692,7 @@ public void LengthPattern_NegativeLengthTest_MissingIndex()
 _ = a is { Length: -1 };
 ";
         var comp = CreateCompilation(src);
+        comp.MakeTypeMissing(WellKnownType.System_Index);
         comp.VerifyDiagnostics();
     }
 
@@ -7638,4 +7639,87 @@ public void Simple_Array_Slice_VerifyRangeMaths(string data, string pattern, str
         comp.VerifyEmitDiagnostics();
         CompileAndVerify(comp, expectedOutput: "(4, 2, 2, 4, 2, 2)");
     }
+
+    [Fact]
+    public void ListPattern_NotCountableInterface()
+    {
+        var source = @"
+_ = new C() is INotCountable and [var x, .. var y];
+
+interface INotCountable { }
+class C : INotCountable
+{
+    public int Length { get => 0; }
+    public int this[System.Index i] { get => 0; }
+    public int this[System.Range r] { get => 0; }
+}
+";
+        var comp = CreateCompilation(new[] { source, TestSources.Index, TestSources.Range });
+        comp.VerifyEmitDiagnostics(
+            // (2,34): error CS0021: Cannot apply indexing with [] to an expression of type 'INotCountable'
+            // _ = new C() is INotCountable and [var x, .. var y];
+            Diagnostic(ErrorCode.ERR_BadIndexLHS, "[var x, .. var y]").WithArguments("INotCountable").WithLocation(2, 34),
+            // (2,42): error CS0021: Cannot apply indexing with [] to an expression of type 'INotCountable'
+            // _ = new C() is INotCountable and [var x, .. var y];
+            Diagnostic(ErrorCode.ERR_BadIndexLHS, ".. var y").WithArguments("INotCountable").WithLocation(2, 42)
+            );
+    }
+
+    [Fact]
+    public void ListPattern_ExplicitInterfaceImplementation()
+    {
+        var source = @"
+if (new C() is Interface and [var x, .. var y])
+{
+    System.Console.Write((x, y));
+}
+
+interface Interface
+{
+    int Length { get; }
+    int this[System.Index i] { get; }
+    int this[System.Range r] { get; }
+}
+class C : Interface
+{
+    int Interface.Length { get => 2; }
+    int Interface.this[System.Index i] { get => 42; }
+    int Interface.this[System.Range r] { get => 43; }
+}
+";
+        var comp = CreateCompilation(new[] { source, TestSources.Index, TestSources.Range });
+        var verifier = CompileAndVerify(comp, expectedOutput: "(42, 43)");
+        verifier.VerifyDiagnostics();
+    }
+
+    [Fact]
+    public void ListPattern_Tuples()
+    {
+        var source = @"
+_ = (1, 2) is [var x, .. var y];
+
+System.Runtime.CompilerServices.ITuple ituple = default;
+_ = ituple is [var x2];
+_ = ituple is [..var y2];
+
+_ = ituple switch
+{
+    [1, 2] => 0,
+    (1, 2) => 0,
+    _ => 0,
+};
+";
+        var comp = CreateCompilation(new[] { source, TestSources.Index, TestSources.Range, TestSources.ITuple });
+        comp.VerifyEmitDiagnostics(
+            // (2,15): error CS0021: Cannot apply indexing with [] to an expression of type '(int, int)'
+            // _ = (1, 2) is [var x, .. var y];
+            Diagnostic(ErrorCode.ERR_BadIndexLHS, "[var x, .. var y]").WithArguments("(int, int)").WithLocation(2, 15),
+            // (2,23): error CS0021: Cannot apply indexing with [] to an expression of type '(int, int)'
+            // _ = (1, 2) is [var x, .. var y];
+            Diagnostic(ErrorCode.ERR_BadIndexLHS, ".. var y").WithArguments("(int, int)").WithLocation(2, 23),
+            // (6,16): error CS1503: Argument 1: cannot convert from 'System.Range' to 'int'
+            // _ = ituple is [..var y2];
+            Diagnostic(ErrorCode.ERR_BadArgType, "..var y2").WithArguments("1", "System.Range", "int").WithLocation(6, 16)
+            );
+    }
 }
diff --git a/src/Compilers/Test/Utilities/CSharp/TestSources.cs b/src/Compilers/Test/Utilities/CSharp/TestSources.cs
index e2c5dee05fada..b809c1a2e6997 100644
--- a/src/Compilers/Test/Utilities/CSharp/TestSources.cs
+++ b/src/Compilers/Test/Utilities/CSharp/TestSources.cs
@@ -407,5 +407,15 @@ public static T[] GetSubArray<T>(T[] array, Range range)
         }
     }
 }";
+
+        public const string ITuple = @"
+namespace System.Runtime.CompilerServices
+{
+    public interface ITuple
+    {
+        int Length { get; }
+        object this[int index] { get; }
+    }
+}";
     }
 }

From 36b4917c2db27fd79d25c8748ab2213680aeb9a3 Mon Sep 17 00:00:00 2001
From: Julien Couvreur <julien.couvreur@gmail.com>
Date: Sun, 21 Nov 2021 15:26:22 -0800
Subject: [PATCH 03/11] Enforce TODO2 marker in CI

---
 eng/test-build-correctness.ps1 | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/eng/test-build-correctness.ps1 b/eng/test-build-correctness.ps1
index 13e627f12bdcb..4e9fda9a26d65 100644
--- a/eng/test-build-correctness.ps1
+++ b/eng/test-build-correctness.ps1
@@ -53,6 +53,14 @@ try {
     }
   }
 
+  # Verify no TODO2 marker left
+  $prototypes = Get-ChildItem -Path src, eng, scripts -Exclude *.dll,*.exe,*.pdb,*.xlf,test-build-correctness.ps1 -Recurse | Select-String -Pattern 'TODO2' -CaseSensitive -SimpleMatch
+  if ($prototypes) {
+    Write-Host "Found TODO2 markers in source:"
+    Write-Host $prototypes
+    throw "TODO2 markers disallowed in compiler source"
+  }
+
   Write-Host "Building Roslyn"
   Exec-Block { & (Join-Path $PSScriptRoot "build.ps1") -restore -build -bootstrap -bootstrapConfiguration:Debug -ci:$ci -runAnalyzers:$true -configuration:$configuration -pack -binaryLog -useGlobalNuGetCache:$false -warnAsError:$true -properties "/p:RoslynEnforceCodeStyle=true"}
 

From 9695eae2fb3504fdaf584cd5c6cd477015ca346d Mon Sep 17 00:00:00 2001
From: Julien Couvreur <julien.couvreur@gmail.com>
Date: Mon, 22 Nov 2021 11:37:20 -0800
Subject: [PATCH 04/11] tweaks

---
 .../PatternMatchingTests_ListPatterns.cs      | 44 +++++++++++++++----
 1 file changed, 36 insertions(+), 8 deletions(-)

diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests_ListPatterns.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests_ListPatterns.cs
index d28ef21761360..ea554f182854e 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests_ListPatterns.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests_ListPatterns.cs
@@ -1385,6 +1385,11 @@ public void ListPattern_MemberLookup_StaticIndexer()
         var vbSource = @"
 Namespace System
     Public Structure Index
+        Public Sub New(ByVal value As Integer, ByVal Optional fromEnd As Boolean = False)
+        End Sub
+        Public Shared Widening Operator CType(ByVal i As Integer) As Index
+            Return Nothing
+        End Operator
     End Structure
 End Namespace
 Public Class Test1
@@ -1407,18 +1412,12 @@ public static void Main()
 }
 ";
         var vbCompilation = CreateVisualBasicCompilation(vbSource);
-        var csCompilation = CreateCompilation(csSource, parseOptions: TestOptions.RegularWithListPatterns, references: new[] { vbCompilation.EmitToImageReference() });
-        // PROTOTYPE(list-patterns) Unsupported because the lookup fails not that the indexer is static
+        var csCompilation = CreateCompilation(csSource, references: new[] { vbCompilation.EmitToImageReference() });
+        // Note: the VB indexer's name is "Item" but C# looks for "this[]", but we can't put Default on Shared indexer declaration
         csCompilation.VerifyEmitDiagnostics(
             // (6,28): error CS0021: Cannot apply indexing with [] to an expression of type 'Test1'
             //         _ = new Test1() is [0];
             Diagnostic(ErrorCode.ERR_BadIndexLHS, "[0]").WithArguments("Test1").WithLocation(6, 28),
-            // (6,28): error CS0656: Missing compiler required member 'System.Index.op_Implicit'
-            //         _ = new Test1() is [0];
-            Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "[0]").WithArguments("System.Index", "op_Implicit").WithLocation(6, 28),
-            // (6,28): error CS0656: Missing compiler required member 'System.Index..ctor'
-            //         _ = new Test1() is [0];
-            Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "[0]").WithArguments("System.Index", ".ctor").WithLocation(6, 28),
             // (7,13): error CS0021: Cannot apply indexing with [] to an expression of type 'Test1'
             //         _ = new Test1()[0];
             Diagnostic(ErrorCode.ERR_BadIndexLHS, "new Test1()[0]").WithArguments("Test1").WithLocation(7, 13));
@@ -7722,4 +7721,33 @@ public void ListPattern_Tuples()
             Diagnostic(ErrorCode.ERR_BadArgType, "..var y2").WithArguments("1", "System.Range", "int").WithLocation(6, 16)
             );
     }
+
+    [Fact]
+    public void ListPattern_NullTestOnSlice()
+    {
+        var source = @"
+using System;
+Span<int> s = default;
+switch (s)
+{
+    case [..[1],2,3]:
+    case [1,2,3]: // error
+        break;
+}
+
+int[] a = default;
+switch (a)
+{
+    case [..[1],2,3]:
+    case [1,2,3]: // no error
+        break;
+}
+";
+        var comp = CreateCompilationWithIndexAndRangeAndSpan(new[] { source, TestSources.GetSubArray });
+        comp.VerifyEmitDiagnostics(
+            // (7,10): error CS8120: The switch case is unreachable. It has already been handled by a previous case or it is impossible to match.
+            //     case [1,2,3]: // error
+            Diagnostic(ErrorCode.ERR_SwitchCaseSubsumed, "[1,2,3]").WithLocation(7, 10)
+            );
+    }
 }

From 5eeebe4b7a890a792bb60fb2aa23405618ff4c03 Mon Sep 17 00:00:00 2001
From: Julien Couvreur <julien.couvreur@gmail.com>
Date: Mon, 22 Nov 2021 23:04:40 -0800
Subject: [PATCH 05/11] tweak

---
 src/Compilers/CSharp/Portable/BoundTree/BoundListPattern.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundListPattern.cs b/src/Compilers/CSharp/Portable/BoundTree/BoundListPattern.cs
index 94dc5559b57b1..27640a26377b0 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundListPattern.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundListPattern.cs
@@ -10,7 +10,7 @@ internal partial class BoundListPattern
     {
         private partial void Validate()
         {
-            Debug.Assert(LengthAccess is BoundPropertyAccess or BoundBadExpression);
+            Debug.Assert(LengthAccess is null or BoundPropertyAccess or BoundBadExpression);
             Debug.Assert(Binder.GetIndexerOrImplicitIndexerSymbol(IndexerAccess) is var _);
         }
     }

From 3ed14b94a8be3386a52f78b6a7caa9a37f7d1665 Mon Sep 17 00:00:00 2001
From: Julien Couvreur <julien.couvreur@gmail.com>
Date: Tue, 23 Nov 2021 10:46:18 -0800
Subject: [PATCH 06/11] Add conditional attribute

---
 .../CSharp/Portable/Generated/BoundNodes.xml.Generated.cs    | 5 +++++
 .../Source/BoundTreeGenerator/BoundNodeClassWriter.cs        | 1 +
 2 files changed, 6 insertions(+)

diff --git a/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs b/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
index 87570dbafc1ad..72ea26ad18c28 100644
--- a/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
+++ b/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
@@ -5456,6 +5456,7 @@ public BoundDagIndexerEvaluation(SyntaxNode syntax, TypeSymbol indexerType, Boun
             Validate();
         }
 
+        [Conditional("DEBUG")]
         private partial void Validate();
 
 
@@ -5508,6 +5509,7 @@ public BoundDagSliceEvaluation(SyntaxNode syntax, TypeSymbol sliceType, BoundDag
             Validate();
         }
 
+        [Conditional("DEBUG")]
         private partial void Validate();
 
 
@@ -7347,6 +7349,7 @@ public BoundImplicitIndexerAccess(SyntaxNode syntax, BoundExpression argument, B
             Validate();
         }
 
+        [Conditional("DEBUG")]
         private partial void Validate();
 
 
@@ -8058,6 +8061,7 @@ public BoundListPattern(SyntaxNode syntax, ImmutableArray<BoundPattern> subpatte
             Validate();
         }
 
+        [Conditional("DEBUG")]
         private partial void Validate();
 
 
@@ -8103,6 +8107,7 @@ public BoundSlicePattern(SyntaxNode syntax, BoundPattern? pattern, BoundExpressi
             Validate();
         }
 
+        [Conditional("DEBUG")]
         private partial void Validate();
 
 
diff --git a/src/Tools/Source/CompilerGeneratorTools/Source/BoundTreeGenerator/BoundNodeClassWriter.cs b/src/Tools/Source/CompilerGeneratorTools/Source/BoundTreeGenerator/BoundNodeClassWriter.cs
index 8c2469e487b1c..b3108a684985d 100644
--- a/src/Tools/Source/CompilerGeneratorTools/Source/BoundTreeGenerator/BoundNodeClassWriter.cs
+++ b/src/Tools/Source/CompilerGeneratorTools/Source/BoundTreeGenerator/BoundNodeClassWriter.cs
@@ -484,6 +484,7 @@ private void WriteConstructorWithHasErrors(TreeType node, bool isPublic, bool ha
 
                         if (hasValidate)
                         {
+                            WriteLine(@"[Conditional(""DEBUG"")]");
                             WriteLine("private partial void Validate();");
                             Blank();
                         }

From b6d11390db810a04165da6cc1c9ce393938f88f7 Mon Sep 17 00:00:00 2001
From: Julien Couvreur <julien.couvreur@gmail.com>
Date: Tue, 23 Nov 2021 13:03:45 -0800
Subject: [PATCH 07/11] Address feedback

---
 .../Portable/BoundTree/BoundDagEvaluation.cs  |   2 +
 .../BoundTree/BoundImplicitIndexerAccess.cs   |   4 +-
 .../Portable/BoundTree/BoundListPattern.cs    |   1 +
 .../Portable/BoundTree/BoundSlicePattern.cs   |   1 +
 .../PatternMatchingTests_ListPatterns.cs      | 140 ++++++++++++++++++
 5 files changed, 146 insertions(+), 2 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundDagEvaluation.cs b/src/Compilers/CSharp/Portable/BoundTree/BoundDagEvaluation.cs
index 5a85b268fc965..ea57c9e342e17 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundDagEvaluation.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundDagEvaluation.cs
@@ -108,6 +108,7 @@ public override bool IsEquivalentTo(BoundDagEvaluation obj)
             return base.IsEquivalentTo(obj) &&
                 this.Index == ((BoundDagIndexerEvaluation)obj).Index;
         }
+
         private partial void Validate()
         {
             Debug.Assert(IndexerAccess is BoundIndexerAccess or BoundImplicitIndexerAccess or BoundArrayAccess);
@@ -123,6 +124,7 @@ public override bool IsEquivalentTo(BoundDagEvaluation obj)
                 (BoundDagSliceEvaluation)obj is var e &&
                 this.StartIndex == e.StartIndex && this.EndIndex == e.EndIndex;
         }
+
         private partial void Validate()
         {
             Debug.Assert(IndexerAccess is BoundIndexerAccess or BoundImplicitIndexerAccess or BoundArrayAccess);
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundImplicitIndexerAccess.cs b/src/Compilers/CSharp/Portable/BoundTree/BoundImplicitIndexerAccess.cs
index 667c866515993..7e8019e2a4d5a 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundImplicitIndexerAccess.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundImplicitIndexerAccess.cs
@@ -32,8 +32,8 @@ internal BoundExpression GetReceiver()
 
         private partial void Validate()
         {
-            Debug.Assert(LengthOrCountAccess is BoundPropertyAccess or BoundLocal);
-            Debug.Assert(IndexerOrSliceAccess is BoundIndexerAccess or BoundCall);
+            Debug.Assert(LengthOrCountAccess is BoundPropertyAccess or BoundLocal or BoundBadExpression);
+            Debug.Assert(IndexerOrSliceAccess is BoundIndexerAccess or BoundCall or BoundArrayAccess);
         }
     }
 }
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundListPattern.cs b/src/Compilers/CSharp/Portable/BoundTree/BoundListPattern.cs
index 27640a26377b0..5a036267a663f 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundListPattern.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundListPattern.cs
@@ -11,6 +11,7 @@ internal partial class BoundListPattern
         private partial void Validate()
         {
             Debug.Assert(LengthAccess is null or BoundPropertyAccess or BoundBadExpression);
+            Debug.Assert(IndexerAccess is BoundIndexerAccess or BoundImplicitIndexerAccess or BoundArrayAccess or BoundBadExpression or BoundDynamicIndexerAccess);
             Debug.Assert(Binder.GetIndexerOrImplicitIndexerSymbol(IndexerAccess) is var _);
         }
     }
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundSlicePattern.cs b/src/Compilers/CSharp/Portable/BoundTree/BoundSlicePattern.cs
index 557cf96cce7a1..d916e249834de 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundSlicePattern.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundSlicePattern.cs
@@ -10,6 +10,7 @@ internal partial class BoundSlicePattern
     {
         private partial void Validate()
         {
+            Debug.Assert(IndexerAccess is BoundIndexerAccess or BoundImplicitIndexerAccess or BoundArrayAccess or BoundBadExpression or BoundDynamicIndexerAccess);
             Debug.Assert(Binder.GetIndexerOrImplicitIndexerSymbol(IndexerAccess) is var _);
         }
     }
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests_ListPatterns.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests_ListPatterns.cs
index ea554f182854e..577d6637a1acc 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests_ListPatterns.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests_ListPatterns.cs
@@ -1423,6 +1423,146 @@ public static void Main()
             Diagnostic(ErrorCode.ERR_BadIndexLHS, "new Test1()[0]").WithArguments("Test1").WithLocation(7, 13));
     }
 
+    [Fact]
+    public void ListPattern_MemberLookup_StaticDefaultIndexer()
+    {
+        var ilSource = @"
+.class public sequential ansi sealed System.Index
+    extends [mscorlib]System.ValueType
+{
+    .method public specialname rtspecialname instance void .ctor ( int32 'value', [opt] bool fromEnd ) cil managed
+    {
+        .param [2] = bool(false)
+        IL_0000: nop
+        IL_0001: ldarg.0
+        IL_0002: initobj System.Index
+        IL_0008: ret
+    }
+
+    .method public specialname static valuetype System.Index op_Implicit ( int32 i ) cil managed
+    {
+        .locals init (
+            [0] valuetype System.Index
+        )
+
+        IL_0000: nop
+        IL_0001: ldloca.s 0
+        IL_0003: initobj System.Index
+        IL_0009: br.s IL_000b
+
+        IL_000b: ldloc.0
+        IL_000c: ret
+    }
+}
+
+.class public auto ansi Test1
+    extends [mscorlib]System.Object
+{
+    .custom instance void [mscorlib]System.Reflection.DefaultMemberAttribute::.ctor(string) = (
+        01 00 04 49 74 65 6d 00 00
+    )
+
+    .field private int32 _Length
+
+    .method public specialname rtspecialname instance void .ctor () cil managed
+    {
+        IL_0000: ldarg.0
+        IL_0001: call instance void [mscorlib]System.Object::.ctor()
+        IL_0006: nop
+        IL_0007: ldarg.0
+        IL_0008: ldc.i4.0
+        IL_0009: call instance void Test1::set_Length(int32)
+        IL_000e: nop
+        IL_000f: ret
+    }
+
+    .method public specialname static int32 get_Item ( valuetype System.Index i ) cil managed
+    {
+        .locals init (
+            [0] int32 Item
+        )
+
+        IL_0000: nop
+        IL_0001: ldc.i4.0
+        IL_0002: stloc.0
+        IL_0003: br.s IL_0005
+
+        IL_0005: ldloc.0
+        IL_0006: ret
+    }
+
+    .method public specialname instance int32 get_Length () cil managed
+    {
+        IL_0000: ldarg.0
+        IL_0001: ldfld int32 Test1::_Length
+        IL_0006: br.s IL_0008
+
+        IL_0008: ret
+    }
+
+    .method public specialname instance void set_Length ( int32 AutoPropertyValue ) cil managed
+    {
+        IL_0000: ldarg.0
+        IL_0001: ldarg.1
+        IL_0002: stfld int32 Test1::_Length
+        IL_0007: ret
+    }
+
+    .property int32 Item( valuetype System.Index i )
+    {
+        .get int32 Test1::get_Item(valuetype System.Index)
+    }
+    .property instance int32 Length()
+    {
+        .get instance int32 Test1::get_Length()
+        .set instance void Test1::set_Length(int32)
+    }
+}
+";
+        var csSource = @"
+System.Console.Write((new Test1() is [42], new Test1()[0]));
+";
+        var csCompilation = CreateCompilationWithIL(csSource, ilSource);
+        csCompilation.VerifyEmitDiagnostics(
+            // (2,38): error CS0176: Member 'Test1.this[Index]' cannot be accessed with an instance reference; qualify it with a type name instead
+            // System.Console.Write((new Test1() is [42], new Test1()[0]));
+            Diagnostic(ErrorCode.ERR_ObjectProhibited, "[42]").WithArguments("Test1.this[System.Index]").WithLocation(2, 38),
+            // (2,44): error CS0176: Member 'Test1.this[Index]' cannot be accessed with an instance reference; qualify it with a type name instead
+            // System.Console.Write((new Test1() is [42], new Test1()[0]));
+            Diagnostic(ErrorCode.ERR_ObjectProhibited, "new Test1()[0]").WithArguments("Test1.this[System.Index]").WithLocation(2, 44)
+            );
+    }
+
+    [Fact]
+    public void ListPattern_MemberLookup_DefaultIndexerWithDifferentName()
+    {
+        var vbSource = @"
+Namespace System
+    Public Structure Index
+        Public Sub New(ByVal value As Integer, ByVal Optional fromEnd As Boolean = False)
+        End Sub
+        Public Shared Widening Operator CType(ByVal i As Integer) As Index
+            Return Nothing
+        End Operator
+    End Structure
+End Namespace
+Public Class Test1
+    Public Default ReadOnly Property Name(i As System.Index) As Integer
+        Get
+            Return 42
+        End Get
+    End Property
+    Public Property Length As Integer = 1
+End Class
+";
+        var csSource = @"
+System.Console.Write((new Test1() is [42], new Test1()[0]));
+";
+        var vbCompilation = CreateVisualBasicCompilation(vbSource);
+        var csCompilation = CreateCompilation(csSource, references: new[] { vbCompilation.EmitToImageReference() });
+        CompileAndVerify(csCompilation, expectedOutput: "(True, 42)").VerifyDiagnostics();
+    }
+
     [Fact]
     public void ListPattern_MemberLookup_Index_ErrorCases_1()
     {

From 439867229d46b471e4f29076b79429f915353b30 Mon Sep 17 00:00:00 2001
From: Julien Couvreur <julien.couvreur@gmail.com>
Date: Tue, 23 Nov 2021 13:26:40 -0800
Subject: [PATCH 08/11] Add BoundBadExpression case for safety

---
 .../CSharp/Portable/BoundTree/BoundImplicitIndexerAccess.cs     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundImplicitIndexerAccess.cs b/src/Compilers/CSharp/Portable/BoundTree/BoundImplicitIndexerAccess.cs
index 7e8019e2a4d5a..eb76e2684fb2e 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundImplicitIndexerAccess.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundImplicitIndexerAccess.cs
@@ -33,7 +33,7 @@ internal BoundExpression GetReceiver()
         private partial void Validate()
         {
             Debug.Assert(LengthOrCountAccess is BoundPropertyAccess or BoundLocal or BoundBadExpression);
-            Debug.Assert(IndexerOrSliceAccess is BoundIndexerAccess or BoundCall or BoundArrayAccess);
+            Debug.Assert(IndexerOrSliceAccess is BoundIndexerAccess or BoundCall or BoundArrayAccess or BoundBadExpression);
         }
     }
 }

From 9135c4a694563b48f8405913659973b4d90cac9a Mon Sep 17 00:00:00 2001
From: Julien Couvreur <julien.couvreur@gmail.com>
Date: Tue, 23 Nov 2021 13:48:16 -0800
Subject: [PATCH 09/11] Test with non-default indexer named Item

---
 .../Portable/BoundTree/BoundListPattern.cs    |  2 +-
 .../Portable/BoundTree/BoundSlicePattern.cs   |  2 +-
 .../PatternMatchingTests_ListPatterns.cs      | 37 +++++++++++++++++++
 3 files changed, 39 insertions(+), 2 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundListPattern.cs b/src/Compilers/CSharp/Portable/BoundTree/BoundListPattern.cs
index 5a036267a663f..7522e92dcf8ff 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundListPattern.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundListPattern.cs
@@ -11,7 +11,7 @@ internal partial class BoundListPattern
         private partial void Validate()
         {
             Debug.Assert(LengthAccess is null or BoundPropertyAccess or BoundBadExpression);
-            Debug.Assert(IndexerAccess is BoundIndexerAccess or BoundImplicitIndexerAccess or BoundArrayAccess or BoundBadExpression or BoundDynamicIndexerAccess);
+            Debug.Assert(IndexerAccess is null or BoundIndexerAccess or BoundImplicitIndexerAccess or BoundArrayAccess or BoundBadExpression or BoundDynamicIndexerAccess);
             Debug.Assert(Binder.GetIndexerOrImplicitIndexerSymbol(IndexerAccess) is var _);
         }
     }
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundSlicePattern.cs b/src/Compilers/CSharp/Portable/BoundTree/BoundSlicePattern.cs
index d916e249834de..c1434c854ca58 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundSlicePattern.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundSlicePattern.cs
@@ -10,7 +10,7 @@ internal partial class BoundSlicePattern
     {
         private partial void Validate()
         {
-            Debug.Assert(IndexerAccess is BoundIndexerAccess or BoundImplicitIndexerAccess or BoundArrayAccess or BoundBadExpression or BoundDynamicIndexerAccess);
+            Debug.Assert(IndexerAccess is null or BoundIndexerAccess or BoundImplicitIndexerAccess or BoundArrayAccess or BoundBadExpression or BoundDynamicIndexerAccess);
             Debug.Assert(Binder.GetIndexerOrImplicitIndexerSymbol(IndexerAccess) is var _);
         }
     }
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests_ListPatterns.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests_ListPatterns.cs
index 577d6637a1acc..a6dcfda825f2f 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests_ListPatterns.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests_ListPatterns.cs
@@ -1563,6 +1563,43 @@ End Class
         CompileAndVerify(csCompilation, expectedOutput: "(True, 42)").VerifyDiagnostics();
     }
 
+    [Fact]
+    public void ListPattern_MemberLookup_NonDefaultIndexerNamedItem()
+    {
+        var vbSource = @"
+Namespace System
+    Public Structure Index
+        Public Sub New(ByVal value As Integer, ByVal Optional fromEnd As Boolean = False)
+        End Sub
+        Public Shared Widening Operator CType(ByVal i As Integer) As Index
+            Return Nothing
+        End Operator
+    End Structure
+End Namespace
+Public Class Test1
+    Public ReadOnly Property Item(i As System.Index) As Integer
+        Get
+            Return 0
+        End Get
+    End Property
+    Public Property Length As Integer = 0
+End Class
+";
+        var csSource = @"
+System.Console.Write((new Test1() is [42], new Test1()[0]));
+";
+        var vbCompilation = CreateVisualBasicCompilation(vbSource);
+        var csCompilation = CreateCompilation(csSource, references: new[] { vbCompilation.EmitToImageReference() });
+        csCompilation.VerifyEmitDiagnostics(
+            // (2,38): error CS0021: Cannot apply indexing with [] to an expression of type 'Test1'
+            // System.Console.Write((new Test1() is [42], new Test1()[0]));
+            Diagnostic(ErrorCode.ERR_BadIndexLHS, "[42]").WithArguments("Test1").WithLocation(2, 38),
+            // (2,44): error CS0021: Cannot apply indexing with [] to an expression of type 'Test1'
+            // System.Console.Write((new Test1() is [42], new Test1()[0]));
+            Diagnostic(ErrorCode.ERR_BadIndexLHS, "new Test1()[0]").WithArguments("Test1").WithLocation(2, 44)
+            );
+    }
+
     [Fact]
     public void ListPattern_MemberLookup_Index_ErrorCases_1()
     {

From 88e450309b7532e68f2c9e2c863335d2cc05d6cf Mon Sep 17 00:00:00 2001
From: Julien Couvreur <julien.couvreur@gmail.com>
Date: Tue, 23 Nov 2021 14:43:11 -0800
Subject: [PATCH 10/11] Remove BoundBadExpression

---
 .../CSharp/Portable/BoundTree/BoundImplicitIndexerAccess.cs     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundImplicitIndexerAccess.cs b/src/Compilers/CSharp/Portable/BoundTree/BoundImplicitIndexerAccess.cs
index eb76e2684fb2e..7e8019e2a4d5a 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundImplicitIndexerAccess.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundImplicitIndexerAccess.cs
@@ -33,7 +33,7 @@ internal BoundExpression GetReceiver()
         private partial void Validate()
         {
             Debug.Assert(LengthOrCountAccess is BoundPropertyAccess or BoundLocal or BoundBadExpression);
-            Debug.Assert(IndexerOrSliceAccess is BoundIndexerAccess or BoundCall or BoundArrayAccess or BoundBadExpression);
+            Debug.Assert(IndexerOrSliceAccess is BoundIndexerAccess or BoundCall or BoundArrayAccess);
         }
     }
 }

From 92622a07cee230d184350409b677f788561ecebb Mon Sep 17 00:00:00 2001
From: Julien Couvreur <julien.couvreur@gmail.com>
Date: Tue, 23 Nov 2021 16:25:14 -0800
Subject: [PATCH 11/11] Merge with array change

---
 .../CSharp/Portable/BoundTree/BoundImplicitIndexerAccess.cs     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundImplicitIndexerAccess.cs b/src/Compilers/CSharp/Portable/BoundTree/BoundImplicitIndexerAccess.cs
index c0b73e34a76d4..e86bc8d6e47b7 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundImplicitIndexerAccess.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundImplicitIndexerAccess.cs
@@ -33,7 +33,7 @@ internal BoundExpression GetReceiver()
 
         private partial void Validate()
         {
-            Debug.Assert(LengthOrCountAccess is BoundPropertyAccess or BoundLocal or BoundBadExpression);
+            Debug.Assert(LengthOrCountAccess is BoundPropertyAccess or BoundArrayLength or BoundLocal or BoundBadExpression);
             Debug.Assert(IndexerOrSliceAccess is BoundIndexerAccess or BoundCall or BoundArrayAccess);
         }
     }