diff --git a/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs b/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs
index c55c78745d1d7..6ff752fbfba82 100644
--- a/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs
+++ b/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs
@@ -2519,6 +2519,7 @@ private void EnterParameter(ParameterSymbol parameter, TypeWithAnnotations param
                 useLegacyWarnings: false,
                 trackMembers: false,
                 assignmentKind: AssignmentKind.Assignment);
+            Unsplit();
 
             // If the LHS has annotations, we perform an additional check for nullable value types
             CheckDisallowedNullAssignment(resultType, parameterAnnotations, equalsValue.Value.Syntax.Location);
@@ -3037,6 +3038,7 @@ private void DeclareLocals(ImmutableArray<LocalSymbol> locals)
             else
             {
                 valueType = VisitOptionalImplicitConversion(initializer, targetTypeOpt: inferredType ? default : type, useLegacyWarnings: true, trackMembers: true, AssignmentKind.Assignment);
+                Unsplit();
             }
 
             if (inferredType)
@@ -3600,6 +3602,7 @@ int getOrCreateSlot(int containingSlot, Symbol symbol)
                     conversionCompletion is not null ?
                         (conversionCompletion(type), null) :
                         VisitOptionalImplicitConversion(node.Right, type, useLegacyWarnings: false, trackMembers: true, AssignmentKind.Assignment, delayCompletionForType);
+                Unsplit();
 
                 if (delayCompletionForType)
                 {
@@ -3897,6 +3900,7 @@ private int GetOrCreatePlaceholderSlot(object identifier, TypeWithAnnotations ty
                 foreach (var expr in expressions)
                 {
                     _ = VisitOptionalImplicitConversion(expr, elementType, useLegacyWarnings: false, trackMembers: false, AssignmentKind.Assignment);
+                    Unsplit();
                 }
             }
             else
@@ -4356,25 +4360,26 @@ private void ReinferBinaryOperatorAndSetResult(
 
                 // Analyze operator call properly (honoring [Disallow|Allow|Maybe|NotNull] attribute annotations) https://github.com/dotnet/roslyn/issues/32671
                 var parameters = method.Parameters;
-                visitOperandConversion(binary.Left, leftOperand, leftConversion, parameters[0], leftUnderlyingType);
-                visitOperandConversion(binary.Right, rightOperand, rightConversion, parameters[1], rightUnderlyingType);
+                visitOperandConversionAndPostConditions(binary.Left, leftOperand, leftConversion, parameters[0], leftUnderlyingType);
+                visitOperandConversionAndPostConditions(binary.Right, rightOperand, rightConversion, parameters[1], rightUnderlyingType);
                 SetUpdatedSymbol(binary, binary.Method!, method);
 
-                void visitOperandConversion(
+                void visitOperandConversionAndPostConditions(
                     BoundExpression expr,
                     BoundExpression operand,
                     Conversion conversion,
                     ParameterSymbol parameter,
                     TypeWithState operandType)
                 {
-                    TypeWithAnnotations targetTypeWithNullability = parameter.TypeWithAnnotations;
+                    var parameterAnnotations = GetParameterAnnotations(parameter);
+                    var targetTypeWithNullability = ApplyLValueAnnotations(parameter.TypeWithAnnotations, parameterAnnotations);
 
                     if (isLifted && targetTypeWithNullability.Type.IsNonNullableValueType())
                     {
                         targetTypeWithNullability = TypeWithAnnotations.Create(MakeNullableOf(targetTypeWithNullability));
                     }
 
-                    _ = VisitConversion(
+                    var resultType = VisitConversion(
                         expr as BoundConversion,
                         operand,
                         conversion,
@@ -4385,6 +4390,9 @@ void visitOperandConversion(
                         useLegacyWarnings: false,
                         AssignmentKind.Argument,
                         parameter);
+                    CheckDisallowedNullAssignment(resultType, parameterAnnotations, expr.Syntax.Location, operand);
+
+                    LearnFromPostConditions(operand, parameterAnnotations);
                 }
             }
             else
@@ -6404,7 +6412,7 @@ private void VisitArgumentOutboundAssignmentsAndPostConditions(
                 case RefKind.In:
                     {
                         // learn from post-conditions [Maybe/NotNull, Maybe/NotNullWhen] without using an assignment
-                        learnFromPostConditions(argument, parameterType, parameterAnnotations);
+                        LearnFromPostConditions(argument, parameterAnnotations);
                     }
                     break;
                 case RefKind.Ref:
@@ -6587,50 +6595,53 @@ static TypeWithState applyPostConditionsWhenFalse(TypeWithState typeWithState, F
 
                 return typeWithState;
             }
+        }
 
-            void learnFromPostConditions(BoundExpression argument, TypeWithAnnotations parameterType, FlowAnalysisAnnotations parameterAnnotations)
-            {
-                // Note: NotNull = NotNullWhen(true) + NotNullWhen(false)
-                bool notNullWhenTrue = (parameterAnnotations & FlowAnalysisAnnotations.NotNullWhenTrue) != 0;
-                bool notNullWhenFalse = (parameterAnnotations & FlowAnalysisAnnotations.NotNullWhenFalse) != 0;
+        /// <summary>
+        /// Learn from postconditions on a by-value or 'in' argument.
+        /// </summary>
+        private void LearnFromPostConditions(BoundExpression argument, FlowAnalysisAnnotations parameterAnnotations)
+        {
+            // Note: NotNull = NotNullWhen(true) + NotNullWhen(false)
+            bool notNullWhenTrue = (parameterAnnotations & FlowAnalysisAnnotations.NotNullWhenTrue) != 0;
+            bool notNullWhenFalse = (parameterAnnotations & FlowAnalysisAnnotations.NotNullWhenFalse) != 0;
 
-                // Note: MaybeNull = MaybeNullWhen(true) + MaybeNullWhen(false)
-                bool maybeNullWhenTrue = (parameterAnnotations & FlowAnalysisAnnotations.MaybeNullWhenTrue) != 0;
-                bool maybeNullWhenFalse = (parameterAnnotations & FlowAnalysisAnnotations.MaybeNullWhenFalse) != 0;
+            // Note: MaybeNull = MaybeNullWhen(true) + MaybeNullWhen(false)
+            bool maybeNullWhenTrue = (parameterAnnotations & FlowAnalysisAnnotations.MaybeNullWhenTrue) != 0;
+            bool maybeNullWhenFalse = (parameterAnnotations & FlowAnalysisAnnotations.MaybeNullWhenFalse) != 0;
 
-                if (maybeNullWhenTrue && maybeNullWhenFalse && !IsConditionalState && !(notNullWhenTrue && notNullWhenFalse))
+            if (maybeNullWhenTrue && maybeNullWhenFalse && !IsConditionalState && !(notNullWhenTrue && notNullWhenFalse))
+            {
+                LearnFromNullTest(argument, ref State);
+            }
+            else if (notNullWhenTrue && notNullWhenFalse
+                && !IsConditionalState
+                && !(maybeNullWhenTrue || maybeNullWhenFalse))
+            {
+                LearnFromNonNullTest(argument, ref State);
+            }
+            else if (notNullWhenTrue || notNullWhenFalse || maybeNullWhenTrue || maybeNullWhenFalse)
+            {
+                Split();
+
+                if (notNullWhenTrue)
                 {
-                    LearnFromNullTest(argument, ref State);
+                    LearnFromNonNullTest(argument, ref StateWhenTrue);
                 }
-                else if (notNullWhenTrue && notNullWhenFalse
-                    && !IsConditionalState
-                    && !(maybeNullWhenTrue || maybeNullWhenFalse))
+
+                if (notNullWhenFalse)
                 {
-                    LearnFromNonNullTest(argument, ref State);
+                    LearnFromNonNullTest(argument, ref StateWhenFalse);
                 }
-                else if (notNullWhenTrue || notNullWhenFalse || maybeNullWhenTrue || maybeNullWhenFalse)
-                {
-                    Split();
-
-                    if (notNullWhenTrue)
-                    {
-                        LearnFromNonNullTest(argument, ref StateWhenTrue);
-                    }
 
-                    if (notNullWhenFalse)
-                    {
-                        LearnFromNonNullTest(argument, ref StateWhenFalse);
-                    }
-
-                    if (maybeNullWhenTrue)
-                    {
-                        LearnFromNullTest(argument, ref StateWhenTrue);
-                    }
+                if (maybeNullWhenTrue)
+                {
+                    LearnFromNullTest(argument, ref StateWhenTrue);
+                }
 
-                    if (maybeNullWhenFalse)
-                    {
-                        LearnFromNullTest(argument, ref StateWhenFalse);
-                    }
+                if (maybeNullWhenFalse)
+                {
+                    LearnFromNullTest(argument, ref StateWhenFalse);
                 }
             }
         }
@@ -8260,6 +8271,8 @@ private TypeWithState VisitUserDefinedConversion(
                 fromExplicitCast: conversionOpt?.ExplicitCastInCode ?? false,
                 diagnosticLocation);
 
+            LearnFromPostConditions(conversionOperand, parameterAnnotations);
+
             TrackAnalyzedNullabilityThroughConversionGroup(operandType, conversionOpt, conversionOperand);
 
             return operandType;
@@ -8756,6 +8769,7 @@ private void VisitThisOrBaseReference(BoundExpression node)
                 {
                     var discarded = left is BoundDiscardExpression;
                     rightState = VisitOptionalImplicitConversion(right, targetTypeOpt: discarded ? default : leftLValueType, UseLegacyWarnings(left, leftLValueType), trackMembers: true, AssignmentKind.Assignment);
+                    Unsplit();
                 }
                 else
                 {
@@ -9077,6 +9091,7 @@ private void VisitTupleDeconstructionArguments(ArrayBuilder<DeconstructionVariab
                         {
                             operandType = default;
                             valueType = VisitOptionalImplicitConversion(rightPart, lvalueType, useLegacyWarnings: true, trackMembers: true, AssignmentKind.Assignment);
+                            Unsplit();
                         }
                         valueSlot = MakeSlot(rightPart);
                     }
@@ -10742,6 +10757,7 @@ private void VisitThrow(BoundExpression? expr)
                 method.ReturnType, errorLocation: null, diagnostics: null);
 
             _ = VisitOptionalImplicitConversion(expr, elementType, useLegacyWarnings: false, trackMembers: false, AssignmentKind.Return);
+            Unsplit();
             return null;
         }
 
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
index 76b8fa7dab060..ebac5c6145f14 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
@@ -20427,6 +20427,346 @@ public C()
                 );
         }
 
+        [Fact, WorkItem(32671, "https://github.com/dotnet/roslyn/issues/32671")]
+        public void NotNullWhenTrue_UserDefinedOperator_Implicit()
+        {
+            CSharpCompilation c = CreateCompilation(new[] { @"
+using System.Diagnostics.CodeAnalysis;
+class C
+{
+  void M(C? c)
+  {
+    if (c)
+    {
+      c.ToString(); // ok
+    }
+    else
+    {
+      c.ToString(); // 1
+    }
+  }
+
+  void M2(C? c)
+  {
+    bool b = c;
+    if (b)
+    {
+      c.ToString(); // 2 (not tracked through assignment)
+    }
+  }
+
+  public static implicit operator bool([NotNullWhen(true)] C? c) { return true; }
+}
+", NotNullWhenAttributeDefinition }, options: WithNullableEnable());
+
+            c.VerifyDiagnostics(
+                // (13,7): warning CS8602: Possible dereference of a null reference.
+                //       c.ToString(); // 1
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "c").WithLocation(13, 7),
+                // (22,7): warning CS8602: Possible dereference of a null reference.
+                //       c.ToString(); // 2 (not tracked through assignment)
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "c").WithLocation(22, 7)
+                );
+
+            VerifyAnnotationsAndMetadata(c, "C.op_Implicit", NotNullWhenTrue);
+        }
+
+        [Fact, WorkItem(32671, "https://github.com/dotnet/roslyn/issues/32671")]
+        public void NotNullWhenTrue_UserDefinedOperator_Explicit()
+        {
+            CSharpCompilation c = CreateCompilation(new[] { @"
+using System.Diagnostics.CodeAnalysis;
+class C
+{
+  void M(C? c)
+  {
+    if ((bool)c)
+    {
+      c.ToString(); // ok
+    }
+    else
+    {
+      c.ToString(); // 1
+    }
+  }
+
+  void M2(C? c)
+  {
+    bool b = (bool)c;
+    if (b)
+    {
+      c.ToString(); // 2 (not tracked through assignment)
+    }
+  }
+
+  public static explicit operator bool([NotNullWhen(true)] C? c) { return true; }
+}
+", NotNullWhenAttributeDefinition }, options: WithNullableEnable());
+
+            c.VerifyDiagnostics(
+                // (13,7): warning CS8602: Possible dereference of a null reference.
+                //       c.ToString(); // 1
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "c").WithLocation(13, 7),
+                // (22,7): warning CS8602: Possible dereference of a null reference.
+                //       c.ToString(); // 2 (not tracked through assignment)
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "c").WithLocation(22, 7)
+                );
+
+            VerifyAnnotationsAndMetadata(c, "C.op_Explicit", NotNullWhenTrue);
+        }
+
+        [Fact, WorkItem(32671, "https://github.com/dotnet/roslyn/issues/32671")]
+        public void NotNullWhenTrue_UserDefinedOperator_Derived()
+        {
+            CSharpCompilation c = CreateCompilation(new[] { @"
+using System.Diagnostics.CodeAnalysis;
+class C : B
+{
+  void M(C? c)
+  {
+    if (c)
+    {
+      c.ToString(); // ok
+    }
+    else
+    {
+      c.ToString(); // 1
+    }
+  }
+}
+
+public class B
+{
+  public static implicit operator bool([NotNullWhen(true)] B? b) { return true; }
+}
+", NotNullWhenAttributeDefinition }, options: WithNullableEnable());
+
+            c.VerifyDiagnostics(
+                // (13,7): warning CS8602: Possible dereference of a null reference.
+                //       c.ToString(); // 1
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "c").WithLocation(13, 7)
+                );
+
+            VerifyAnnotationsAndMetadata(c, "B.op_Implicit", NotNullWhenTrue);
+        }
+
+        [Fact, WorkItem(32671, "https://github.com/dotnet/roslyn/issues/32671")]
+        public void NotNull_UserDefinedOperator1()
+        {
+            CSharpCompilation c = CreateCompilation(new[] { @"
+#pragma warning disable CS0660, CS0661 // no equals, hashcode 
+using System.Diagnostics.CodeAnalysis;
+public class C
+{
+    public void Main(C? c, C? c2)
+    {
+        if(c == c2)
+        {
+         	c.ToString();
+            c2.ToString(); // 1
+        }
+        else
+        {
+            c.ToString();
+            c2.ToString(); // 2
+        }
+    }
+
+    public static bool operator ==([NotNull] C? c1, C? c2)
+    {
+        throw null!;
+    }
+
+    public static bool operator !=(C? c1, C? c2)
+    {
+        return true;
+    }
+}
+", NotNullAttributeDefinition }, options: WithNullableEnable());
+
+            c.VerifyDiagnostics(
+                // (11,13): warning CS8602: Dereference of a possibly null reference.
+                //             c2.ToString(); // 1
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "c2").WithLocation(11, 13),
+                // (16,13): warning CS8602: Dereference of a possibly null reference.
+                //             c2.ToString(); // 2
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "c2").WithLocation(16, 13)
+                );
+
+            VerifyAnnotationsAndMetadata(c, "C.op_Equality", NotNull, None);
+        }
+
+        [Fact, WorkItem(32671, "https://github.com/dotnet/roslyn/issues/32671")]
+        public void NotNull_UserDefinedOperator2()
+        {
+            CSharpCompilation c = CreateCompilation(new[] { @"
+#pragma warning disable CS0660, CS0661 // no equals, hashcode 
+using System.Diagnostics.CodeAnalysis;
+public class C
+{
+    public void Main(C? c, C? c2)
+    {
+        if(c == c2)
+        {
+         	c.ToString();  // 1
+            c2.ToString();
+        }
+        else
+        {
+            c.ToString(); // 2
+            c2.ToString();
+        }
+    }
+
+    public static bool operator ==(C? c1, [NotNull]C? c2)
+    {
+        throw null!;
+    }
+
+    public static bool operator !=(C? c1, C? c2)
+    {
+        return true;
+    }
+}
+", NotNullAttributeDefinition }, options: WithNullableEnable());
+
+            c.VerifyDiagnostics(
+                // (10,11): warning CS8602: Dereference of a possibly null reference.
+                //          	c.ToString();  // 1 
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "c").WithLocation(10, 11),
+                // (15,13): warning CS8602: Dereference of a possibly null reference.
+                //             c.ToString(); // 2
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "c").WithLocation(15, 13)
+                );
+
+            VerifyAnnotationsAndMetadata(c, "C.op_Equality", None, NotNull);
+        }
+
+        [Fact, WorkItem(32671, "https://github.com/dotnet/roslyn/issues/32671")]
+        public void NotNullWhen_UserDefinedConversion_Completeness()
+        {
+            CSharpCompilation c = CreateCompilation(new[] { @"
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+
+public class C
+{
+    public bool Field;
+
+    public static bool M0(bool b = new C()) // 1
+    {
+        _ = new C() { Field = new C() };
+        _ = new bool[] { new C(), true };
+        _ = new [] { new C(), true };
+
+        return new C();
+        return true; // 2
+    }
+
+    public static IEnumerable<bool> Iterator()
+    {
+        yield return new C();
+        yield return true;
+    }
+
+    public static implicit operator bool([NotNullWhen(true)] C? c) => c != null;
+}
+", NotNullWhenAttributeDefinition }, options: WithNullableEnable());
+
+            c.VerifyDiagnostics(
+                // (9,36): error CS1736: Default parameter value for 'b' must be a compile-time constant
+                //     public static bool M0(bool b = new C()) // 1
+                Diagnostic(ErrorCode.ERR_DefaultValueMustBeConstant, "new C()").WithArguments("b").WithLocation(9, 36),
+                // (16,9): warning CS0162: Unreachable code detected
+                //         return true; // 2
+                Diagnostic(ErrorCode.WRN_UnreachableCode, "return").WithLocation(16, 9)
+                );
+        }
+
+        [Fact, WorkItem(32671, "https://github.com/dotnet/roslyn/issues/32671")]
+        public void DisallowNull_UserDefinedOperator_01()
+        {
+            CSharpCompilation c = CreateCompilation(new[] { @"
+#pragma warning disable CS0660, CS0661 // no equals, hashcode 
+using System.Diagnostics.CodeAnalysis;
+
+public class C
+{
+    public static void M0(C? c)
+    {
+        bool b = c; // 1
+        b = new C();
+    }
+
+    public static void M0(C? c1, C? c2)
+    {
+        bool b = c1 == c2; // 2
+        b = c2 != c1; // 3
+        b = new C() == new C();
+    }
+
+    public static implicit operator bool([DisallowNull] C? c) => c != null;
+
+    public static bool operator ==([DisallowNull] C? c1, C? c2) => (object?)c1 == c2;
+    public static bool operator !=([DisallowNull] C? c1, C? c2) => (object?)c1 != c2;
+}
+", DisallowNullAttributeDefinition }, options: WithNullableEnable());
+
+            c.VerifyDiagnostics(
+                // (9,18): warning CS8604: Possible null reference argument for parameter 'c' in 'C.implicit operator bool(C? c)'.
+                //         bool b = c; // 1
+                Diagnostic(ErrorCode.WRN_NullReferenceArgument, "c").WithArguments("c", "C.implicit operator bool(C? c)").WithLocation(9, 18),
+                // (15,18): warning CS8604: Possible null reference argument for parameter 'c1' in 'bool C.operator ==(C? c1, C? c2)'.
+                //         bool b = c1 == c2; // 2
+                Diagnostic(ErrorCode.WRN_NullReferenceArgument, "c1").WithArguments("c1", "bool C.operator ==(C? c1, C? c2)").WithLocation(15, 18),
+                // (16,13): warning CS8604: Possible null reference argument for parameter 'c1' in 'bool C.operator !=(C? c1, C? c2)'.
+                //         b = c2 != c1; // 3
+                Diagnostic(ErrorCode.WRN_NullReferenceArgument, "c2").WithArguments("c1", "bool C.operator !=(C? c1, C? c2)").WithLocation(16, 13)
+                );
+        }
+
+        [Fact, WorkItem(32671, "https://github.com/dotnet/roslyn/issues/32671")]
+        public void DisallowNull_UserDefinedOperator_02()
+        {
+            CSharpCompilation c = CreateCompilation(new[] { @"
+#pragma warning disable CS0660, CS0661 // no equals, hashcode 
+using System.Diagnostics.CodeAnalysis;
+
+public struct S
+{
+    public static void M0(S? s)
+    {
+        bool? b = s; // 1
+        b = new S();
+    }
+
+    public static void M0(S? s1, S? s2)
+    {
+        bool b = s1 == s2; // 2
+        b = s2 != s1; // 3
+        b = new S() == new S();
+    }
+
+    public static implicit operator bool([DisallowNull] S? s) => s != null;
+
+    public static bool operator ==([DisallowNull] S? s1, S? s2) => throw null!;
+    public static bool operator !=([DisallowNull] S? s1, S? s2) => throw null!;
+}
+", DisallowNullAttributeDefinition }, options: WithNullableEnable());
+
+            c.VerifyDiagnostics(
+                // (9,19): warning CS8607: A possible null value may not be used for a type marked with [NotNull] or [DisallowNull]
+                //         bool? b = s; // 1
+                Diagnostic(ErrorCode.WRN_DisallowNullAttributeForbidsMaybeNullAssignment, "s").WithLocation(9, 19),
+                // (15,18): warning CS8607: A possible null value may not be used for a type marked with [NotNull] or [DisallowNull]
+                //         bool b = s1 == s2; // 2
+                Diagnostic(ErrorCode.WRN_DisallowNullAttributeForbidsMaybeNullAssignment, "s1").WithLocation(15, 18),
+                // (16,13): warning CS8607: A possible null value may not be used for a type marked with [NotNull] or [DisallowNull]
+                //         b = s2 != s1; // 3
+                Diagnostic(ErrorCode.WRN_DisallowNullAttributeForbidsMaybeNullAssignment, "s2").WithLocation(16, 13)
+                );
+        }
+
         [Fact, WorkItem(58598, "https://github.com/dotnet/roslyn/issues/58598")]
         public void MemberNotNull_NullConstant()
         {
@@ -39289,6 +39629,7 @@ public class C
         [WorkItem(48605, "https://github.com/dotnet/roslyn/issues/48605")]
         [WorkItem(48134, "https://github.com/dotnet/roslyn/issues/48134")]
         [WorkItem(49136, "https://github.com/dotnet/roslyn/issues/49136")]
+        [WorkItem(49575, "https://github.com/dotnet/roslyn/issues/49575")]
         public void AllowNullNotNullInputParam_UpdatesArgumentState()
         {
             var source = @"
@@ -39311,7 +39652,7 @@ public static void M2(string? s)
     public static void M3(string? s)
     {
         C c = s;
-        s.ToString(); // 1
+        s.ToString();
     }
 
     public static void MExt([AllowNull, NotNull] this string s) { throw null!; }
@@ -39322,13 +39663,8 @@ public class C
     }
 }
 ";
-            // we should respect postconditions on a conversion parameter
-            // https://github.com/dotnet/roslyn/issues/49575
             var comp = CreateNullableCompilation(new[] { source, AllowNullAttributeDefinition, NotNullAttributeDefinition });
-            comp.VerifyDiagnostics(
-                // (21,9): warning CS8602: Dereference of a possibly null reference.
-                //         s.ToString(); // 1
-                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "s").WithLocation(21, 9));
+            comp.VerifyDiagnostics();
         }
 
         [Fact]
@@ -68209,7 +68545,7 @@ class CL2
                 );
         }
 
-        [Fact]
+        [Fact, WorkItem(32671, "https://github.com/dotnet/roslyn/issues/32671")]
         public void BinaryOperator_03_WithDisallowAndAllowNull()
         {
             CSharpCompilation c = CreateNullableCompilation(new[] { @"
@@ -68253,23 +68589,13 @@ void Test4(string x4, CL1 y4, CL2 z4)
 }
 ", AllowNullAttributeDefinition, DisallowNullAttributeDefinition });
 
-            // Analyze operator call properly (honoring [Disallow|Allow|Maybe|NotNull] attribute annotations) https://github.com/dotnet/roslyn/issues/32671
             c.VerifyDiagnostics(
-                // (8,24): warning CS8604: Possible null reference argument for parameter 'y' in 'CL0 CL0.operator +(string? x, CL0 y)'.
-                //         CL0? z1 = x1 + y1;
-                Diagnostic(ErrorCode.WRN_NullReferenceArgument, "y1").WithArguments("y", "CL0 CL0.operator +(string? x, CL0 y)").WithLocation(8, 24),
-                // (19,18): warning CS8604: Possible null reference argument for parameter 'x' in 'CL1? CL1.operator +(string x, CL1? y)'.
-                //         CL1 z2 = x2 + y2; // 1, 2
-                Diagnostic(ErrorCode.WRN_NullReferenceArgument, "x2").WithArguments("x", "CL1? CL1.operator +(string x, CL1? y)").WithLocation(19, 18),
                 // (19,18): warning CS8600: Converting null literal or possible null value to non-nullable type.
                 //         CL1 z2 = x2 + y2; // 1, 2
                 Diagnostic(ErrorCode.WRN_ConvertingNullableToNonNullable, "x2 + y2").WithLocation(19, 18),
-                // (29,23): warning CS8604: Possible null reference argument for parameter 'y' in 'CL0 CL0.operator +(string? x, CL0 y)'.
-                //         CL2 u3 = x3 + y3 + z3;
-                Diagnostic(ErrorCode.WRN_NullReferenceArgument, "y3").WithArguments("y", "CL0 CL0.operator +(string? x, CL0 y)").WithLocation(29, 23),
-                // (34,18): warning CS8604: Possible null reference argument for parameter 'x' in 'CL2 CL2.operator +(CL1 x, CL2 y)'.
-                //         CL2 u4 = x4 + y4 + z4;
-                Diagnostic(ErrorCode.WRN_NullReferenceArgument, "x4 + y4").WithArguments("x", "CL2 CL2.operator +(CL1 x, CL2 y)").WithLocation(34, 18)
+                // (19,23): warning CS8604: Possible null reference argument for parameter 'y' in 'CL1? CL1.operator +(string x, CL1? y)'.
+                //         CL1 z2 = x2 + y2; // 1, 2
+                Diagnostic(ErrorCode.WRN_NullReferenceArgument, "y2").WithArguments("y", "CL1? CL1.operator +(string x, CL1? y)").WithLocation(19, 23)
                 );
         }
 
@@ -68850,7 +69176,7 @@ static void F(S x, S? y)
             comp.VerifyDiagnostics();
         }
 
-        [Fact]
+        [Fact, WorkItem(32671, "https://github.com/dotnet/roslyn/issues/32671")]
         public void BinaryOperator_15_WithDisallowNull()
         {
             var source = @"
@@ -68868,9 +69194,14 @@ static void F(S? x, S? y)
         s = y + y; // 2
     }
 }";
-            // Analyze operator call properly (honoring [Disallow|Allow|Maybe|NotNull] attribute annotations) https://github.com/dotnet/roslyn/issues/32671
             var comp = CreateCompilation(new[] { source, DisallowNullAttributeDefinition }, options: WithNullableEnable());
-            comp.VerifyDiagnostics();
+            comp.VerifyDiagnostics(
+                // (11,17): warning CS8607: A possible null value may not be used for a type marked with [NotNull] or [DisallowNull]
+                //         s = x + y; // 1
+                Diagnostic(ErrorCode.WRN_DisallowNullAttributeForbidsMaybeNullAssignment, "y").WithLocation(11, 17),
+                // (13,17): warning CS8607: A possible null value may not be used for a type marked with [NotNull] or [DisallowNull]
+                //         s = y + y; // 2
+                Diagnostic(ErrorCode.WRN_DisallowNullAttributeForbidsMaybeNullAssignment, "y").WithLocation(13, 17));
         }
 
         [Fact]