Use manual recursion for binary patterns

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

@@ -1734,100 +1734,145 @@ private BoundPattern BindBinaryPattern(
             bool hasErrors,
             BindingDiagnosticBag diagnostics)
         {
-            bool isDisjunction = node.Kind() == SyntaxKind.OrPattern;
-            if (isDisjunction)
+            // Users (such as ourselves) can have many, many nested binary patterns. To avoid crashing, do left recursion manually.
+
+            var binaryPatternStack = ArrayBuilder<(BinaryPatternSyntax pat, bool permitDesignations)>.GetInstance();
+            BinaryPatternSyntax? currentNode = node;
+
+            do
             {
-                MessageID.IDS_FeatureOrPattern.CheckFeatureAvailability(diagnostics, node.OperatorToken);
+                permitDesignations = permitDesignations && currentNode.IsKind(SyntaxKind.AndPattern);
+                binaryPatternStack.Push((currentNode, permitDesignations));
+                currentNode = currentNode.Left as BinaryPatternSyntax;
+            } while (currentNode != null);
 
-                permitDesignations = false; // prevent designators under 'or'
-                var left = BindPattern(node.Left, inputType, permitDesignations, hasErrors, diagnostics);
-                var right = BindPattern(node.Right, inputType, permitDesignations, hasErrors, diagnostics);
+            Debug.Assert(binaryPatternStack.Count > 0);
 
-                // Compute the common type. This algorithm is quadratic, but disjunctive patterns are unlikely to be huge
-                var narrowedTypeCandidates = ArrayBuilder<TypeSymbol>.GetInstance(2);
-                collectCandidates(left, narrowedTypeCandidates);
-                collectCandidates(right, narrowedTypeCandidates);
-                var narrowedType = leastSpecificType(node, narrowedTypeCandidates, diagnostics) ?? inputType;
-                narrowedTypeCandidates.Free();
+            var binaryPatternAndPermitDesignations = binaryPatternStack.Pop();
+            BoundPattern result = BindPattern(binaryPatternAndPermitDesignations.pat.Left, inputType, binaryPatternAndPermitDesignations.permitDesignations, hasErrors, diagnostics);
+            var narrowedTypeCandidates = ArrayBuilder<TypeSymbol>.GetInstance(2);
+            collectCandidates(result, narrowedTypeCandidates);
 
-                return new BoundBinaryPattern(node, disjunction: isDisjunction, left, right, inputType: inputType, narrowedType: narrowedType, hasErrors);
+            do
+            {
+                result = bindBinaryPattern(
+                    result,
+                    this,
+                    binaryPatternAndPermitDesignations.pat,
+                    binaryPatternAndPermitDesignations.permitDesignations,
+                    inputType,
+                    narrowedTypeCandidates,
+                    hasErrors,
+                    diagnostics);
+            } while (binaryPatternStack.TryPop(out binaryPatternAndPermitDesignations));
 
-                static void collectCandidates(BoundPattern pat, ArrayBuilder<TypeSymbol> candidates)
-                {
-                    if (pat is BoundBinaryPattern { Disjunction: true } p)
-                    {
-                        collectCandidates(p.Left, candidates);
-                        collectCandidates(p.Right, candidates);
-                    }
-                    else
-                    {
-                        candidates.Add(pat.NarrowedType);
-                    }
-                }
+            binaryPatternStack.Free();
+            narrowedTypeCandidates.Free();
+            return result;
 
-                TypeSymbol? leastSpecificType(SyntaxNode node, ArrayBuilder<TypeSymbol> candidates, BindingDiagnosticBag diagnostics)
+            static BoundPattern bindBinaryPattern(
+                BoundPattern preboundLeft,
+                Binder binder,
+                BinaryPatternSyntax node,
+                bool permitDesignations,
+                TypeSymbol inputType,
+                ArrayBuilder<TypeSymbol> narrowedTypeCandidates,
+                bool hasErrors,
+                BindingDiagnosticBag diagnostics)
+            {
+                bool isDisjunction = node.Kind() == SyntaxKind.OrPattern;
+                if (isDisjunction)
                 {
-                    Debug.Assert(candidates.Count >= 2);
-                    CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics);
-                    TypeSymbol? bestSoFar = candidates[0];
-                    // first pass: select a candidate for which no other has been shown to be an improvement.
-                    for (int i = 1, n = candidates.Count; i < n; i++)
+                    Debug.Assert(!permitDesignations);
+                    MessageID.IDS_FeatureOrPattern.CheckFeatureAvailability(diagnostics, node.OperatorToken);
+
+                    var right = binder.BindPattern(node.Right, inputType, permitDesignations, hasErrors, diagnostics);
+
+                    // Compute the common type. This algorithm is quadratic, but disjunctive patterns are unlikely to be huge
+                    collectCandidates(right, narrowedTypeCandidates);
+                    var narrowedType = leastSpecificType(node, narrowedTypeCandidates, diagnostics) ?? inputType;
+
+                    return new BoundBinaryPattern(node, disjunction: isDisjunction, preboundLeft, right, inputType: inputType, narrowedType: narrowedType, hasErrors);
+
+                    TypeSymbol? leastSpecificType(SyntaxNode node, ArrayBuilder<TypeSymbol> candidates, BindingDiagnosticBag diagnostics)
                     {
-                        TypeSymbol candidate = candidates[i];
-                        bestSoFar = lessSpecificCandidate(bestSoFar, candidate, ref useSiteInfo) ?? bestSoFar;
+                        Debug.Assert(candidates.Count >= 2);
+                        CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = binder.GetNewCompoundUseSiteInfo(diagnostics);
+                        TypeSymbol? bestSoFar = candidates[0];
+                        // first pass: select a candidate for which no other has been shown to be an improvement.
+                        for (int i = 1, n = candidates.Count; i < n; i++)
+                        {
+                            TypeSymbol candidate = candidates[i];
+                            bestSoFar = lessSpecificCandidate(bestSoFar, candidate, ref useSiteInfo) ?? bestSoFar;
+                        }
+                        // second pass: check that it is no more specific than any candidate.
+                        for (int i = 0, n = candidates.Count; i < n; i++)
+                        {
+                            TypeSymbol candidate = candidates[i];
+                            TypeSymbol? spoiler = lessSpecificCandidate(candidate, bestSoFar, ref useSiteInfo);
+                            if (spoiler is null)
+                            {
+                                bestSoFar = null;
+                                break;
+                            }
+
+                            // Our specificity criteria are transitive
+                            Debug.Assert(spoiler.Equals(bestSoFar, TypeCompareKind.ConsiderEverything));
+                        }
+
+                        diagnostics.Add(node, useSiteInfo);
+                        return bestSoFar;
                     }
-                    // second pass: check that it is no more specific than any candidate.
-                    for (int i = 0, n = candidates.Count; i < n; i++)
+
+                    // Given a candidate least specific type so far, attempt to refine it with a possibly less specific candidate.
+                    TypeSymbol? lessSpecificCandidate(TypeSymbol bestSoFar, TypeSymbol possiblyLessSpecificCandidate, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
                     {
-                        TypeSymbol candidate = candidates[i];
-                        TypeSymbol? spoiler = lessSpecificCandidate(candidate, bestSoFar, ref useSiteInfo);
-                        if (spoiler is null)
+                        if (bestSoFar.Equals(possiblyLessSpecificCandidate, TypeCompareKind.AllIgnoreOptions))
                         {
-                            bestSoFar = null;
-                            break;
+                            // When the types are equivalent, merge them.
+                            return bestSoFar.MergeEquivalentTypes(possiblyLessSpecificCandidate, VarianceKind.Out);
+                        }
+                        else if (binder.Conversions.HasImplicitReferenceConversion(bestSoFar, possiblyLessSpecificCandidate, ref useSiteInfo))
+                        {
+                            // When there is an implicit reference conversion from T to U, U is less specific
+                            return possiblyLessSpecificCandidate;
+                        }
+                        else if (binder.Conversions.HasBoxingConversion(bestSoFar, possiblyLessSpecificCandidate, ref useSiteInfo))
+                        {
+                            // when there is a boxing conversion from T to U, U is less specific.
+                            return possiblyLessSpecificCandidate;
+                        }
+                        else
+                        {
+                            // We have no improved candidate to offer.
+                            return null;
                         }
-
-                        // Our specificity criteria are transitive
-                        Debug.Assert(spoiler.Equals(bestSoFar, TypeCompareKind.ConsiderEverything));
                     }
+                }
+                else
+                {
+                    MessageID.IDS_FeatureAndPattern.CheckFeatureAvailability(diagnostics, node.OperatorToken);
 
-                    diagnostics.Add(node, useSiteInfo);
-                    return bestSoFar;
+                    var right = binder.BindPattern(node.Right, preboundLeft.NarrowedType, permitDesignations, hasErrors, diagnostics);
+                    narrowedTypeCandidates.Clear();
+                    narrowedTypeCandidates.Add(right.NarrowedType);
+                    return new BoundBinaryPattern(node, disjunction: isDisjunction, preboundLeft, right, inputType: inputType, narrowedType: right.NarrowedType, hasErrors);
                 }
+            }
 
-                // Given a candidate least specific type so far, attempt to refine it with a possibly less specific candidate.
-                TypeSymbol? lessSpecificCandidate(TypeSymbol bestSoFar, TypeSymbol possiblyLessSpecificCandidate, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
+            static void collectCandidates(BoundPattern pat, ArrayBuilder<TypeSymbol> candidates)
+            {
+                if (pat is BoundBinaryPattern { Disjunction: true } p)
                 {
-                    if (bestSoFar.Equals(possiblyLessSpecificCandidate, TypeCompareKind.AllIgnoreOptions))
-                    {
-                        // When the types are equivalent, merge them.
-                        return bestSoFar.MergeEquivalentTypes(possiblyLessSpecificCandidate, VarianceKind.Out);
-                    }
-                    else if (Conversions.HasImplicitReferenceConversion(bestSoFar, possiblyLessSpecificCandidate, ref useSiteInfo))
-                    {
-                        // When there is an implicit reference conversion from T to U, U is less specific
-                        return possiblyLessSpecificCandidate;
-                    }
-                    else if (Conversions.HasBoxingConversion(bestSoFar, possiblyLessSpecificCandidate, ref useSiteInfo))
-                    {
-                        // when there is a boxing conversion from T to U, U is less specific.
-                        return possiblyLessSpecificCandidate;
-                    }
-                    else
-                    {
-                        // We have no improved candidate to offer.
-                        return null;
-                    }
+                    collectCandidates(p.Left, candidates);
+                    collectCandidates(p.Right, candidates);
+                }
+                else
+                {
+                    candidates.Add(pat.NarrowedType);
                 }
             }
-            else
-            {
-                MessageID.IDS_FeatureAndPattern.CheckFeatureAvailability(diagnostics, node.OperatorToken);
 
-                var left = BindPattern(node.Left, inputType, permitDesignations, hasErrors, diagnostics);
-                var right = BindPattern(node.Right, left.NarrowedType, permitDesignations, hasErrors, diagnostics);
-                return new BoundBinaryPattern(node, disjunction: isDisjunction, left, right, inputType: inputType, narrowedType: right.NarrowedType, hasErrors);
-            }
         }
     }
 }

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

@@ -645,33 +645,59 @@ private Tests MakeTestsAndBindingsForBinaryPattern(
             out BoundDagTemp output,
             ArrayBuilder<BoundPatternBinding> bindings)
         {
-            var builder = ArrayBuilder<Tests>.GetInstance(2);
-            if (bin.Disjunction)
+            // Users (such as ourselves) can have many, many nested binary patterns. To avoid crashing, do left recursion manually.
+
+            var binaryPatternStack = ArrayBuilder<BoundBinaryPattern>.GetInstance();
+            var currentNode = bin;
+
+            do
+            {
+                binaryPatternStack.Push(currentNode);
+                currentNode = currentNode.Left as BoundBinaryPattern;
+            } while (currentNode != null);
+
+            currentNode = binaryPatternStack.Pop();
+            Tests result = MakeTestsAndBindings(input, currentNode.Left, out output, bindings);
+
+            do
+            {
+                result = makeTestsAndBindingsForBinaryPattern(this, result, output, input, currentNode, out output, bindings);
+            } while (binaryPatternStack.TryPop(out currentNode));
+
+            binaryPatternStack.Free();
+
+            return result;
+
+            static Tests makeTestsAndBindingsForBinaryPattern(DecisionDagBuilder @this, Tests leftTests, BoundDagTemp leftOutput, BoundDagTemp input, BoundBinaryPattern bin, out BoundDagTemp output, ArrayBuilder<BoundPatternBinding> bindings)
             {
-                builder.Add(MakeTestsAndBindings(input, bin.Left, bindings));
-                builder.Add(MakeTestsAndBindings(input, bin.Right, bindings));
-                var result = Tests.OrSequence.Create(builder);
-                if (bin.InputType.Equals(bin.NarrowedType))
+                var builder = ArrayBuilder<Tests>.GetInstance(2);
+                if (bin.Disjunction)
                 {
-                    output = input;
-                    return result;
+                    builder.Add(leftTests);
+                    builder.Add(@this.MakeTestsAndBindings(input, bin.Right, bindings));
+                    var result = Tests.OrSequence.Create(builder);
+                    if (bin.InputType.Equals(bin.NarrowedType))
+                    {
+                        output = input;
+                        return result;
+                    }
+                    else
+                    {
+                        builder = ArrayBuilder<Tests>.GetInstance(2);
+                        builder.Add(result);
+                        output = @this.MakeConvertToType(input: input, syntax: bin.Syntax, type: bin.NarrowedType, isExplicitTest: false, tests: builder);
+                        return Tests.AndSequence.Create(builder);
+                    }
                 }
                 else
                 {
-                    builder = ArrayBuilder<Tests>.GetInstance(2);
-                    builder.Add(result);
-                    output = MakeConvertToType(input: input, syntax: bin.Syntax, type: bin.NarrowedType, isExplicitTest: false, tests: builder);
+                    builder.Add(leftTests);
+                    builder.Add(@this.MakeTestsAndBindings(leftOutput, bin.Right, out var rightOutput, bindings));
+                    output = rightOutput;
+                    Debug.Assert(bin.HasErrors || output.Type.Equals(bin.NarrowedType, TypeCompareKind.AllIgnoreOptions));
                     return Tests.AndSequence.Create(builder);
                 }
             }
-            else
-            {
-                builder.Add(MakeTestsAndBindings(input, bin.Left, out var leftOutput, bindings));
-                builder.Add(MakeTestsAndBindings(leftOutput, bin.Right, out var rightOutput, bindings));
-                output = rightOutput;
-                Debug.Assert(bin.HasErrors || output.Type.Equals(bin.NarrowedType, TypeCompareKind.AllIgnoreOptions));
-                return Tests.AndSequence.Create(builder);
-            }
         }
 
         private Tests MakeTestsAndBindingsForRelationalPattern(

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

@@ -339,6 +339,28 @@ public override void VisitBinaryExpression(BinaryExpressionSyntax node)
             operands.Free();
         }
 
+        public override void VisitBinaryPattern(BinaryPatternSyntax node)
+        {
+            // Like binary expressions, binary patterns are left-associative, and can be deeply nested (even in our own code).
+            // Handle this with manual recursion.
+            PatternSyntax currentPattern = node;
+
+            var rightPatternStack = ArrayBuilder<PatternSyntax>.GetInstance();
+
+            while (currentPattern is BinaryPatternSyntax binaryPattern)
+            {
+                rightPatternStack.Push(binaryPattern.Right);
+                currentPattern = binaryPattern.Left;
+            }
+
+            do
+            {
+                Visit(currentPattern);
+            } while (rightPatternStack.TryPop(out currentPattern));
+
+            rightPatternStack.Free();
+        }
+
         public override void VisitInvocationExpression(InvocationExpressionSyntax node)
         {
             if (receiverIsInvocation(node, out InvocationExpressionSyntax nested))

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

@@ -796,6 +796,22 @@ public override void VisitSwitchExpression(SwitchExpressionSyntax node)
             }
         }
 
+        public override void VisitBinaryPattern(BinaryPatternSyntax node)
+        {
+            // Users (such as ourselves) can have many, many nested binary patterns. To avoid crashing, do left recursion manually.
+            while (true)
+            {
+                Visit(node.Right);
+                if (node.Left is not BinaryPatternSyntax binOp)
+                {
+                    Visit(node.Left);
+                    break;
+                }
+
+                node = binOp;
+            }
+        }
+
         public override void VisitIfStatement(IfStatementSyntax node)
         {
             Binder enclosing = _enclosing;

src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/OverloadResolution.cs

@@ -3239,7 +3239,7 @@ public override BoundNode Visit(BoundNode node)
                 return null;
             }
 
-            protected override BoundExpression VisitExpressionWithoutStackGuard(BoundExpression node)
+            protected override BoundNode VisitExpressionOrPatternWithoutStackGuard(BoundNode node)
             {
                 throw ExceptionUtilities.Unreachable();
             }