Learn from bool constants and conditional accesses inside ==/!=

src/Compilers/CSharp/Portable/FlowAnalysis/AbstractFlowPass.cs

@@ -121,6 +121,11 @@ internal abstract partial class AbstractFlowPass<TLocalState, TLocalFunctionStat
         /// </summary>
         private readonly bool _nonMonotonicTransfer;
 
+        protected void SetConditionalState((TLocalState whenTrue, TLocalState whenFalse) state)
+        {
+            SetConditionalState(state.whenTrue, state.whenFalse);
+        }
+
         protected void SetConditionalState(TLocalState whenTrue, TLocalState whenFalse)
         {
             IsConditionalState = true;
@@ -2235,20 +2240,101 @@ private void VisitBinaryOperatorChildren(BoundBinaryOperator node)
         protected virtual void VisitBinaryOperatorChildren(ArrayBuilder<BoundBinaryOperator> stack)
         {
             var binary = stack.Pop();
-            VisitRvalue(binary.Left);
 
-            while (true)
+            // Only the leftmost operator of a left-associative binary operator chain can learn from a conditional access on the left
+            // For simplicity, we just special case it here.
+            if (VisitPossibleConditionalAccess(binary.Left, out var stateWhenNotNull)
+                && canLearnFromOperator()
+                && (isNullableValueTypeConversion(binary.Right) || binary.Right.ConstantValue is object))
             {
                 VisitRvalue(binary.Right);
+                Meet(ref stateWhenNotNull, ref State);
+                var isNullConstant = binary.Right.ConstantValue?.IsNull == true;
+                SetConditionalState(isNullConstant == isEquals(binary)
+                    ? (State, stateWhenNotNull)
+                    : (stateWhenNotNull, State));
+
+                if (stack.Count == 0)
+                {
+                    return;
+                }
+
+                binary = stack.Pop();
+            }
+
+            while (true)
+            {
+                if (!canLearnFromOperator()
+                    || !learnFromOperator())
+                {
+                    Unsplit();
+                    Visit(binary.Right);
+                }
 
                 if (stack.Count == 0)
                 {
                     break;
                 }
 
-                Unsplit(); // VisitRvalue does this
                 binary = stack.Pop();
             }
+
+            bool canLearnFromOperator()
+            {
+                var kind = binary.OperatorKind;
+                var op = kind.Operator();
+                return op is BinaryOperatorKind.Equal or BinaryOperatorKind.NotEqual
+                    && (!kind.IsUserDefined() || kind.IsLifted());
+            }
+
+            static bool isNullableValueTypeConversion(BoundExpression expr)
+            {
+                return expr is BoundConversion
+                {
+                    ConversionKind: ConversionKind.ExplicitNullable or ConversionKind.ImplicitNullable,
+                } conv && conv.Operand.Type.IsNonNullableValueType();
+            }
+
+            static bool isEquals(BoundBinaryOperator binary)
+                => binary.OperatorKind.Operator() == BinaryOperatorKind.Equal;
+
+            bool learnFromOperator()
+            {
+                if ((isNullableValueTypeConversion(binary.Left) || binary.Left.ConstantValue is object)
+                    && TryVisitConditionalAccess(binary.Right, out var stateWhenNotNull))
+                {
+                    var isNullConstant = binary.Left.ConstantValue?.IsNull == true;
+                    SetConditionalState(isNullConstant == isEquals(binary)
+                        ? (State, stateWhenNotNull)
+                        : (stateWhenNotNull, State));
+
+                    return true;
+                }
+                else if (IsConditionalState && binary.Right.ConstantValue is { IsBoolean: true } rightConstant)
+                {
+                    var (stateWhenTrue, stateWhenFalse) = (StateWhenTrue.Clone(), StateWhenFalse.Clone());
+                    Unsplit();
+                    Visit(binary.Right);
+                    SetConditionalState(isEquals(binary) == rightConstant.BooleanValue
+                        ? (stateWhenTrue, stateWhenFalse)
+                        : (stateWhenFalse, stateWhenTrue));
+
+                    return true;
+                }
+                else if (binary.Left.ConstantValue is { IsBoolean: true } leftConstant)
+                {
+                    Unsplit();
+                    Visit(binary.Right);
+                    if (IsConditionalState && isEquals(binary) != leftConstant.BooleanValue)
+                    {
+                        SetConditionalState(StateWhenFalse, StateWhenTrue);
+                    }
+
+                    return true;
+                }
+
+                return false;
+            }
         }
 
         public override BoundNode VisitUnaryOperator(BoundUnaryOperator node)
@@ -2445,9 +2531,17 @@ public override BoundNode VisitMethodGroup(BoundMethodGroup node)
             }
             else
             {
-                TLocalState savedState = VisitPossibleConditionalAccess(node.LeftOperand, out var stateWhenNotNull)
-                    ? stateWhenNotNull
-                    : State.Clone();
+                TLocalState savedState;
+                if (VisitPossibleConditionalAccess(node.LeftOperand, out var stateWhenNotNull))
+                {
+                    Debug.Assert(!IsConditionalState);
+                    savedState = stateWhenNotNull;
+                }
+                else
+                {
+                    Unsplit();
+                    savedState = State.Clone();
+                }
 
                 if (node.LeftOperand.ConstantValue != null)
                 {
@@ -2467,41 +2561,28 @@ public override BoundNode VisitMethodGroup(BoundMethodGroup node)
             return null;
         }
 
-        /// <summary>
-        /// Unconditionally visits an expression.
-        /// If the expression has "state when not null" after visiting,
-        /// the method returns 'true' and writes the state to <paramref name="stateWhenNotNull" />.
-        /// </summary>
-        protected bool VisitPossibleConditionalAccess(BoundExpression node, [NotNullWhen(true)] out TLocalState? stateWhenNotNull)
+        private bool TryVisitConditionalAccess(BoundExpression node, [NotNullWhen(true)] out TLocalState? stateWhenNotNull)
         {
-            EnterRegionIfNeeded(node);
-            var hasStateWhenNotNull = visit(out stateWhenNotNull);
-            Debug.Assert(!IsConditionalState);
-            LeaveRegionIfNeeded(node);
-            return hasStateWhenNotNull;
-
-            bool visit([NotNullWhen(true)] out TLocalState? stateWhenNotNull)
+            var access = node switch
             {
-                var access = node switch
-                {
-                    BoundConditionalAccess ca => ca,
-                    BoundConversion { Conversion: Conversion innerConversion, Operand: BoundConditionalAccess ca } when isAcceptableConversion(ca, innerConversion) => ca,
-                    _ => null
-                };
+                BoundConditionalAccess ca => ca,
+                BoundConversion { Conversion: Conversion innerConversion, Operand: BoundConditionalAccess ca } when isAcceptableConversion(ca, innerConversion) => ca,
+                _ => null
+            };
 
-                if (access is not null)
-                {
-                    return VisitConditionalAccess(access, out stateWhenNotNull);
-                }
-                else
-                {
-                    stateWhenNotNull = default;
-                    VisitWithStackGuard(node);
-                    Unsplit();
-                    return false;
-                }
+            if (access is not null)
+            {
+                EnterRegionIfNeeded(access);
+                Unsplit();
+                var hasStateWhenNotNull = VisitConditionalAccess(access, out stateWhenNotNull);
+                Debug.Assert(!IsConditionalState);
+                LeaveRegionIfNeeded(access);
+                return hasStateWhenNotNull;
             }
 
+            stateWhenNotNull = default;
+            return false;
+
             // "State when not null" can only propagate out of a conditional access if
             // it is not subject to a user-defined conversion whose parameter is not of a non-nullable value type.
             static bool isAcceptableConversion(BoundConditionalAccess operand, Conversion conversion)
@@ -2524,6 +2605,25 @@ static bool isAcceptableConversion(BoundConditionalAccess operand, Conversion co
             }
         }
 
+        /// <summary>
+        /// Unconditionally visits an expression.
+        /// If the expression has "state when not null" after visiting,
+        /// the method returns 'true' and writes the state to <paramref name="stateWhenNotNull" />.
+        /// </summary>
+        private bool VisitPossibleConditionalAccess(BoundExpression node, [NotNullWhen(true)] out TLocalState? stateWhenNotNull)
+        {
+            stateWhenNotNull = default;
+            if (TryVisitConditionalAccess(node, out stateWhenNotNull))
+            {
+                return true;
+            }
+            else
+            {
+                Visit(node);
+                return false;
+            }
+        }
+
         private bool VisitConditionalAccess(BoundConditionalAccess node, [NotNullWhen(true)] out TLocalState? stateWhenNotNull)
         {
             VisitRvalue(node.Receiver);