Cleanup usage of BoundBinaryOperator.Method API (#80942)

AlekseyTs · web-flow · commit f3aba8c2bc3c · 2025-10-29T15:57:13.000-07:00
`BoundBinaryOperator.Method` is replaced with two APIs: - BinaryOperatorMethod - LeftTruthOperatorMethod Closes #78628.
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder.ValueChecks.cs b/src/Compilers/CSharp/Portable/Binder/Binder.ValueChecks.cs
@@ -220,13 +220,14 @@ public static MethodInvocationInfo FromUnaryOperator(BoundUnaryOperator unaryOpe
 
             public static MethodInvocationInfo FromBinaryOperator(BoundBinaryOperator binaryOperator)
             {
-                Debug.Assert(binaryOperator.Method is not null);
+                var binaryOperatorMethod = binaryOperator.BinaryOperatorMethod;
+                Debug.Assert(binaryOperatorMethod is not null);
                 return new MethodInvocationInfo
                 {
-                    MethodInfo = MethodInfo.Create(binaryOperator.Method),
+                    MethodInfo = MethodInfo.Create(binaryOperatorMethod),
                     Receiver = null,
                     ReceiverIsSubjectToCloning = ThreeState.Unknown,
-                    Parameters = binaryOperator.Method.Parameters,
+                    Parameters = binaryOperatorMethod.Parameters,
                     ArgsOpt = [binaryOperator.Left, binaryOperator.Right],
                     ArgumentRefKindsOpt = default,
                     ArgsToParamsOpt = default,
@@ -3912,7 +3913,7 @@ internal SafeContext GetRefEscape(BoundExpression expr, SafeContext localScopeDe
 
                 case BoundKind.BinaryOperator:
                     Debug.Assert(expr is BoundBinaryOperator binaryOperator &&
-                        (binaryOperator.Method is not { } binaryMethod ||
+                        (binaryOperator.BinaryOperatorMethod is not { } binaryMethod ||
                         binaryMethod.HasUnsupportedMetadata ||
                         binaryMethod.RefKind == RefKind.None));
                     break;
@@ -4257,7 +4258,7 @@ internal bool CheckRefEscape(SyntaxNode node, BoundExpression expr, SafeContext
 
                 case BoundKind.BinaryOperator:
                     Debug.Assert(expr is BoundBinaryOperator binaryOperator &&
-                        (binaryOperator.Method is not { } binaryMethod ||
+                        (binaryOperator.BinaryOperatorMethod is not { } binaryMethod ||
                         binaryMethod.HasUnsupportedMetadata ||
                         binaryMethod.RefKind == RefKind.None));
                     break;
@@ -4672,7 +4673,7 @@ internal SafeContext GetValEscape(BoundExpression expr, SafeContext localScopeDe
                 case BoundKind.BinaryOperator:
                     var binary = (BoundBinaryOperator)expr;
 
-                    if (binary.Method is { } binaryMethod)
+                    if (binary.BinaryOperatorMethod is { } binaryMethod)
                     {
                         return GetInvocationEscapeScope(
                             MethodInvocationInfo.FromBinaryOperator(binary),
@@ -5441,7 +5442,7 @@ internal bool CheckValEscape(SyntaxNode node, BoundExpression expr, SafeContext
                         return true;
                     }
 
-                    if (binary.Method is { } binaryMethod)
+                    if (binary.BinaryOperatorMethod is { } binaryMethod)
                     {
                         return CheckInvocationEscape(
                             binary.Syntax,
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_TupleOperators.cs b/src/Compilers/CSharp/Portable/Binder/Binder_TupleOperators.cs
@@ -108,7 +108,8 @@ private TupleBinaryOperatorInfo BindTupleBinaryOperatorInfo(BinaryExpressionSynt
                         out UnaryOperatorSignature boolOperator);
                     CheckConstraintLanguageVersionAndRuntimeSupportForOperator(node, boolOperator.Method, isUnsignedRightShift: false, boolOperator.ConstrainedToTypeOpt, diagnostics);
 
-                    return new TupleBinaryOperatorInfo.Single(binary.Left.Type, binary.Right.Type, binary.OperatorKind, binary.Method, binary.ConstrainedToType,
+                    Debug.Assert(!binary.OperatorKind.IsDynamic());
+                    return new TupleBinaryOperatorInfo.Single(binary.Left.Type, binary.Right.Type, binary.OperatorKind, binary.BinaryOperatorMethod, binary.ConstrainedToType,
                         conversionIntoBoolOperatorPlaceholder, conversionIntoBoolOperator, boolOperator);
 
                 default:
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundBinaryOperator.UncommonData.cs b/src/Compilers/CSharp/Portable/BoundTree/BoundBinaryOperator.UncommonData.cs
@@ -10,6 +10,23 @@ namespace Microsoft.CodeAnalysis.CSharp
 {
     internal partial class BoundBinaryOperator
     {
+        private partial void Validate()
+        {
+            if (Data is { Method: { } method })
+            {
+                if (OperatorKind.IsDynamic())
+                {
+                    Debug.Assert(OperatorKind.IsLogical());
+                    Debug.Assert(method.Name is WellKnownMemberNames.TrueOperatorName or WellKnownMemberNames.FalseOperatorName);
+                    Debug.Assert(method.ParameterCount == 1);
+                }
+                else
+                {
+                    Debug.Assert(method is ErrorMethodSymbol or { ParameterCount: 2 });
+                }
+            }
+        }
+
         internal class UncommonData
         {
             public static UncommonData UnconvertedInterpolatedStringAddition(ConstantValue? constantValue) =>
@@ -54,6 +71,8 @@ public static UncommonData InterpolatedStringHandlerAddition(InterpolatedStringH
             private UncommonData(ConstantValue? constantValue, MethodSymbol? method, TypeSymbol? constrainedToType, ImmutableArray<MethodSymbol> originalUserDefinedOperatorsOpt, bool isUnconvertedInterpolatedStringAddition, InterpolatedStringHandlerData? interpolatedStringHandlerData)
             {
                 Debug.Assert(interpolatedStringHandlerData is null || !isUnconvertedInterpolatedStringAddition);
+                Debug.Assert(method is null or ErrorMethodSymbol { ParameterCount: 0 } or { MethodKind: MethodKind.UserDefinedOperator } or { ParameterCount: 2 });
+
                 ConstantValue = constantValue;
                 Method = method;
                 ConstrainedToType = constrainedToType;
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundExpression.cs b/src/Compilers/CSharp/Portable/BoundTree/BoundExpression.cs
@@ -403,9 +403,10 @@ internal partial class BoundBinaryOperator
     {
         public override ConstantValue? ConstantValueOpt => Data?.ConstantValue;
 
-        public override Symbol? ExpressionSymbol => this.Method;
+        public override Symbol? ExpressionSymbol => this.BinaryOperatorMethod;
 
-        internal MethodSymbol? Method => Data?.Method;
+        public MethodSymbol? BinaryOperatorMethod => OperatorKind.IsDynamic() ? null : Data?.Method;
+        public MethodSymbol? LeftTruthOperatorMethod => OperatorKind.IsDynamic() && OperatorKind.IsLogical() ? Data?.Method : null;
 
         internal TypeSymbol? ConstrainedToType => Data?.ConstrainedToType;
 
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml b/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
@@ -481,7 +481,7 @@
     <Field Name="Right" Type="BoundExpression"/>
   </AbstractNode>
 
-  <Node Name="BoundBinaryOperator" Base="BoundBinaryOperatorBase" SkipInNullabilityRewriter="true">
+  <Node Name="BoundBinaryOperator" Base="BoundBinaryOperatorBase" SkipInNullabilityRewriter="true" HasValidate="true">
     <Field Name="OperatorKind" Type="BinaryOperatorKind"/>
     <Field Name="Data" Type="BoundBinaryOperator.UncommonData?" />
     <Field Name="ResultKind" PropertyOverrides="true" Type="LookupResultKind"/>
diff --git a/src/Compilers/CSharp/Portable/BoundTree/NullabilityRewriter.cs b/src/Compilers/CSharp/Portable/BoundTree/NullabilityRewriter.cs
@@ -99,7 +99,7 @@ private BoundNode VisitBinaryOperatorBase(BoundBinaryOperatorBase binaryOperator
                 {
                     BoundBinaryOperator binary => binary.Update(
                         binary.OperatorKind,
-                        binary.Data?.WithUpdatedMethod(GetUpdatedSymbol(binary, binary.Method)),
+                        binary.BinaryOperatorMethod is { } binaryOperatorMethod ? binary.Data?.WithUpdatedMethod(GetUpdatedSymbol(binary, binaryOperatorMethod)) : binary.Data,
                         binary.ResultKind,
                         leftChild,
                         right,
diff --git a/src/Compilers/CSharp/Portable/CodeGen/Optimizer.cs b/src/Compilers/CSharp/Portable/CodeGen/Optimizer.cs
@@ -1533,7 +1533,8 @@ public override BoundNode VisitBinaryOperator(BoundBinaryOperator node)
                 }
 
                 var type = this.VisitType(binary.Type);
-                left = binary.Update(binary.OperatorKind, binary.ConstantValueOpt, binary.Method, binary.ConstrainedToType, binary.ResultKind, left, right, type);
+                Debug.Assert(!binary.OperatorKind.IsDynamic());
+                left = binary.Update(binary.OperatorKind, binary.ConstantValueOpt, binary.BinaryOperatorMethod, binary.ConstrainedToType, binary.ResultKind, left, right, type);
 
                 if (stack.Count == 0)
                 {
@@ -1567,7 +1568,8 @@ private BoundNode VisitBinaryOperatorSimple(BoundBinaryOperator node)
 
                 EnsureStackState(cookie);   // implicit label here
 
-                return node.Update(node.OperatorKind, node.ConstantValueOpt, node.Method, node.ConstrainedToType, node.ResultKind, left, right, node.Type);
+                Debug.Assert(!node.OperatorKind.IsDynamic());
+                return node.Update(node.OperatorKind, node.ConstantValueOpt, node.BinaryOperatorMethod, node.ConstrainedToType, node.ResultKind, left, right, node.Type);
             }
 
             return base.VisitBinaryOperator(node);
@@ -2108,7 +2110,8 @@ public override BoundNode VisitBinaryOperator(BoundBinaryOperator node)
                 binary = stack.Pop();
                 var right = (BoundExpression)this.Visit(binary.Right);
                 var type = this.VisitType(binary.Type);
-                left = binary.Update(binary.OperatorKind, binary.ConstantValueOpt, binary.Method, binary.ConstrainedToType, binary.ResultKind, left, right, type);
+                Debug.Assert(!binary.OperatorKind.IsDynamic());
+                left = binary.Update(binary.OperatorKind, binary.ConstantValueOpt, binary.BinaryOperatorMethod, binary.ConstrainedToType, binary.ResultKind, left, right, type);
 
                 if (stack.Count == 0)
                 {
diff --git a/src/Compilers/CSharp/Portable/Compilation/CSharpSemanticModel.cs b/src/Compilers/CSharp/Portable/Compilation/CSharpSemanticModel.cs
@@ -3854,12 +3854,12 @@ private static void GetSymbolsAndResultKind(BoundBinaryOperator binaryOperator,
             {
                 if (!isDynamic)
                 {
-                    GetSymbolsAndResultKind(binaryOperator, binaryOperator.Method, binaryOperator.OriginalUserDefinedOperatorsOpt, out symbols, out resultKind);
+                    GetSymbolsAndResultKind(binaryOperator, binaryOperator.BinaryOperatorMethod, binaryOperator.OriginalUserDefinedOperatorsOpt, out symbols, out resultKind);
                 }
             }
             else
             {
-                Debug.Assert((object)binaryOperator.Method == null && binaryOperator.OriginalUserDefinedOperatorsOpt.IsDefaultOrEmpty);
+                Debug.Assert((object)binaryOperator.BinaryOperatorMethod == null && binaryOperator.OriginalUserDefinedOperatorsOpt.IsDefaultOrEmpty);
 
                 if (!isDynamic &&
                     (op == BinaryOperatorKind.Equal || op == BinaryOperatorKind.NotEqual) &&
diff --git a/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs b/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs
@@ -5339,7 +5339,7 @@ private void ReinferBinaryOperatorAndSetResult(
             TypeWithState rightType,
             BoundBinaryOperator binary)
         {
-            var inferredResult = ReinferAndVisitBinaryOperator(binary, binary.OperatorKind, binary.Method, binary.Type, binary.Left, leftOperand, leftConversion, leftType, binary.Right, rightOperand, rightConversion, rightType);
+            var inferredResult = ReinferAndVisitBinaryOperator(binary, binary.OperatorKind, binary.BinaryOperatorMethod, binary.Type, binary.Left, leftOperand, leftConversion, leftType, binary.Right, rightOperand, rightConversion, rightType);
             SetResult(binary, inferredResult, inferredResult.ToTypeWithAnnotations(compilation));
         }
 
@@ -12293,7 +12293,7 @@ void afterLeftChildOfBoundBinaryOperatorHasBeenVisited(BoundBinaryOperator node)
 
                 Visit(node.Right);
                 TypeWithState rightType = ResultType;
-                SetResultType(node, InferResultNullability(node.OperatorKind, node.Method, node.Type, leftType, rightType));
+                SetResultType(node, InferResultNullability(node.OperatorKind, node.BinaryOperatorMethod, node.Type, leftType, rightType));
                 AfterRightChildOfBinaryLogicalOperatorHasBeenVisited(node.Right, isAnd, isBool, ref leftTrue, ref leftFalse);
             }
 
diff --git a/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs b/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
diff --git a/src/Compilers/CSharp/Portable/Lowering/BoundTreeToDifferentEnclosingContextRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/BoundTreeToDifferentEnclosingContextRewriter.cs
@@ -161,8 +161,9 @@ public override BoundNode VisitAwaitableValuePlaceholder(BoundAwaitableValuePlac
         {
             // Local rewriter should have already rewritten interpolated strings into their final form of calls and gotos
             Debug.Assert(node.InterpolatedStringHandlerData is null);
+            Debug.Assert(!node.OperatorKind.IsDynamic());
 
-            return BoundBinaryOperator.UncommonData.CreateIfNeeded(node.ConstantValueOpt, VisitMethodSymbol(node.Method), VisitType(node.ConstrainedToType), node.OriginalUserDefinedOperatorsOpt);
+            return BoundBinaryOperator.UncommonData.CreateIfNeeded(node.ConstantValueOpt, VisitMethodSymbol(node.BinaryOperatorMethod), VisitType(node.ConstrainedToType), node.OriginalUserDefinedOperatorsOpt);
         }
 
         public override BoundNode? VisitConversion(BoundConversion node)
diff --git a/src/Compilers/CSharp/Portable/Lowering/ClosureConversion/ExpressionLambdaRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/ClosureConversion/ExpressionLambdaRewriter.cs
@@ -192,7 +192,8 @@ private BoundExpression VisitExpressionWithoutStackGuard(BoundExpression node)
                     return VisitBaseReference((BoundBaseReference)node);
                 case BoundKind.BinaryOperator:
                     var binOp = (BoundBinaryOperator)node;
-                    return VisitBinaryOperator(binOp.OperatorKind, binOp.Method, binOp.Type, binOp.Left, binOp.Right);
+                    Debug.Assert(!binOp.OperatorKind.IsDynamic());
+                    return VisitBinaryOperator(binOp.OperatorKind, binOp.BinaryOperatorMethod, binOp.Type, binOp.Left, binOp.Right);
                 case BoundKind.UserDefinedConditionalLogicalOperator:
                     var userDefCondLogOp = (BoundUserDefinedConditionalLogicalOperator)node;
                     return VisitBinaryOperator(userDefCondLogOp.OperatorKind, userDefCondLogOp.LogicalOperator, userDefCondLogOp.Type, userDefCondLogOp.Left, userDefCondLogOp.Right);
diff --git a/src/Compilers/CSharp/Portable/Lowering/DiagnosticsPass_Warnings.cs b/src/Compilers/CSharp/Portable/Lowering/DiagnosticsPass_Warnings.cs
@@ -249,7 +249,7 @@ private static bool IsComCallWithRefOmitted(MethodSymbol method, ImmutableArray<
 
         private void CheckBinaryOperator(BoundBinaryOperator node)
         {
-            if (node.Method is MethodSymbol method)
+            if (node.BinaryOperatorMethod is MethodSymbol method)
             {
                 if (_inExpressionLambda)
                 {
diff --git a/src/Compilers/CSharp/Portable/Lowering/ExtensionMethodReferenceRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/ExtensionMethodReferenceRewriter.cs
@@ -247,11 +247,13 @@ public static BoundNode VisitFunctionPointerLoad(BoundTreeRewriter rewriter, Bou
         {
             // Local rewriter should have already rewritten interpolated strings into their final form of calls and gotos
             Debug.Assert(node.InterpolatedStringHandlerData is null);
+            Debug.Assert(!node.OperatorKind.IsDynamic());
 
-            MethodSymbol? method = VisitMethodSymbolWithExtensionRewrite(rewriter, node.Method);
+            var binaryOperatorMethod = node.BinaryOperatorMethod;
+            MethodSymbol? method = VisitMethodSymbolWithExtensionRewrite(rewriter, binaryOperatorMethod);
             TypeSymbol? constrainedToType = rewriter.VisitType(node.ConstrainedToType);
 
-            if (Symbol.Equals(method, node.Method, TypeCompareKind.AllIgnoreOptions) && TypeSymbol.Equals(constrainedToType, node.ConstrainedToType, TypeCompareKind.AllIgnoreOptions))
+            if (Symbol.Equals(method, binaryOperatorMethod, TypeCompareKind.AllIgnoreOptions) && TypeSymbol.Equals(constrainedToType, node.ConstrainedToType, TypeCompareKind.AllIgnoreOptions))
             {
                 return node.Data;
             }
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_BinaryOperator.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_BinaryOperator.cs
@@ -156,7 +156,7 @@ public BoundExpression VisitBinaryOperator(BoundBinaryOperator node, BoundUnaryO
             {
                 BoundBinaryOperator original = stack.Pop();
                 BoundExpression loweredRight = VisitExpression(original.Right);
-                loweredLeft = MakeBinaryOperator(original, original.Syntax, original.OperatorKind, loweredLeft, loweredRight, original.Type, original.Method, original.ConstrainedToType,
+                loweredLeft = MakeBinaryOperator(original, original.Syntax, original.OperatorKind, loweredLeft, loweredRight, original.Type, original.LeftTruthOperatorMethod ?? original.BinaryOperatorMethod, original.ConstrainedToType,
                     applyParentUnaryOperator: (stack.Count == 0) ? applyParentUnaryOperator : null);
             }
 
@@ -536,8 +536,9 @@ private BoundExpression MakeBinaryOperator(
                 }
             }
 
+            Debug.Assert(!operatorKind.IsDynamic());
             return (oldNode != null) ?
-                oldNode.Update(operatorKind, oldNode.ConstantValueOpt, oldNode.Method, oldNode.ConstrainedToType, oldNode.ResultKind, loweredLeft, loweredRight, type) :
+                oldNode.Update(operatorKind, oldNode.ConstantValueOpt, oldNode.BinaryOperatorMethod, oldNode.ConstrainedToType, oldNode.ResultKind, loweredLeft, loweredRight, type) :
                 new BoundBinaryOperator(syntax, operatorKind, constantValueOpt: null, methodOpt: null, constrainedToTypeOpt: null, LookupResultKind.Viable, loweredLeft, loweredRight, type);
         }
 
@@ -2014,7 +2015,7 @@ private BoundExpression RewriteStringEquality(BoundBinaryOperator? oldNode, Synt
         {
             if (oldNode != null && (loweredLeft.ConstantValueOpt == ConstantValue.Null || loweredRight.ConstantValueOpt == ConstantValue.Null))
             {
-                return oldNode.Update(operatorKind, oldNode.ConstantValueOpt, oldNode.Method, oldNode.ConstrainedToType, oldNode.ResultKind, loweredLeft, loweredRight, type);
+                return oldNode.Update(operatorKind, oldNode.ConstantValueOpt, oldNode.BinaryOperatorMethod, oldNode.ConstrainedToType, oldNode.ResultKind, loweredLeft, loweredRight, type);
             }
 
             var method = UnsafeGetSpecialTypeMethod(syntax, member);
diff --git a/src/Compilers/CSharp/Portable/Lowering/SpillSequenceSpiller.cs b/src/Compilers/CSharp/Portable/Lowering/SpillSequenceSpiller.cs
@@ -990,6 +990,8 @@ public override BoundNode VisitUserDefinedConditionalLogicalOperator(BoundUserDe
 
         public override BoundNode VisitBinaryOperator(BoundBinaryOperator node)
         {
+            Debug.Assert(!node.OperatorKind.IsDynamic());
+
             BoundSpillSequenceBuilder builder = null;
             var right = VisitExpression(ref builder, node.Right);
             BoundExpression left;
@@ -1021,7 +1023,7 @@ public override BoundNode VisitBinaryOperator(BoundBinaryOperator node)
                 }
             }
 
-            return UpdateExpression(builder, node.Update(node.OperatorKind, node.ConstantValueOpt, node.Method, node.ConstrainedToType, node.ResultKind, left, right, node.Type));
+            return UpdateExpression(builder, node.Update(node.OperatorKind, node.ConstantValueOpt, node.BinaryOperatorMethod, node.ConstrainedToType, node.ResultKind, left, right, node.Type));
         }
 
         public override BoundNode VisitCall(BoundCall node)
diff --git a/src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory.cs b/src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory.cs

Original file line number	Diff line number	Diff line change
`@@ -403,9 +403,10 @@ internal partial class BoundBinaryOperator`
`403`	`403`	`{`
`404`	`404`	`public override ConstantValue? ConstantValueOpt => Data?.ConstantValue;`
`405`	`405`
`406`		`- public override Symbol? ExpressionSymbol => this.Method;`
	`406`	`+ public override Symbol? ExpressionSymbol => this.BinaryOperatorMethod;`
`407`	`407`
`408`		`- internal MethodSymbol? Method => Data?.Method;`
	`408`	`+ public MethodSymbol? BinaryOperatorMethod => OperatorKind.IsDynamic() ? null : Data?.Method;`
	`409`	`+ public MethodSymbol? LeftTruthOperatorMethod => OperatorKind.IsDynamic() && OperatorKind.IsLogical() ? Data?.Method : null;`
`409`	`410`
`410`	`411`	`internal TypeSymbol? ConstrainedToType => Data?.ConstrainedToType;`
`411`	`412`
Original file line number	Diff line number	Diff line change
`@@ -99,7 +99,7 @@ private BoundNode VisitBinaryOperatorBase(BoundBinaryOperatorBase binaryOperator`
`99`	`99`	`{`
`100`	`100`	`BoundBinaryOperator binary => binary.Update(`
`101`	`101`	`binary.OperatorKind,`
`102`		`- binary.Data?.WithUpdatedMethod(GetUpdatedSymbol(binary, binary.Method)),`
	`102`	`+ binary.BinaryOperatorMethod is { } binaryOperatorMethod ? binary.Data?.WithUpdatedMethod(GetUpdatedSymbol(binary, binaryOperatorMethod)) : binary.Data,`
`103`	`103`	`binary.ResultKind,`
`104`	`104`	`leftChild,`
`105`	`105`	`right,`
Original file line number	Diff line number	Diff line change
`@@ -1533,7 +1533,8 @@ public override BoundNode VisitBinaryOperator(BoundBinaryOperator node)`
`1533`	`1533`	`}`
`1534`	`1534`
`1535`	`1535`	`var type = this.VisitType(binary.Type);`
`1536`		`- left = binary.Update(binary.OperatorKind, binary.ConstantValueOpt, binary.Method, binary.ConstrainedToType, binary.ResultKind, left, right, type);`
	`1536`	`+ Debug.Assert(!binary.OperatorKind.IsDynamic());`
	`1537`	`+ left = binary.Update(binary.OperatorKind, binary.ConstantValueOpt, binary.BinaryOperatorMethod, binary.ConstrainedToType, binary.ResultKind, left, right, type);`
`1537`	`1538`
`1538`	`1539`	`if (stack.Count == 0)`
`1539`	`1540`	`{`
`@@ -1567,7 +1568,8 @@ private BoundNode VisitBinaryOperatorSimple(BoundBinaryOperator node)`
`1567`	`1568`
`1568`	`1569`	`EnsureStackState(cookie); // implicit label here`
`1569`	`1570`
`1570`		`- return node.Update(node.OperatorKind, node.ConstantValueOpt, node.Method, node.ConstrainedToType, node.ResultKind, left, right, node.Type);`
	`1571`	`+ Debug.Assert(!node.OperatorKind.IsDynamic());`
	`1572`	`+ return node.Update(node.OperatorKind, node.ConstantValueOpt, node.BinaryOperatorMethod, node.ConstrainedToType, node.ResultKind, left, right, node.Type);`
`1571`	`1573`	`}`
`1572`	`1574`
`1573`	`1575`	`return base.VisitBinaryOperator(node);`
`@@ -2108,7 +2110,8 @@ public override BoundNode VisitBinaryOperator(BoundBinaryOperator node)`
`2108`	`2110`	`binary = stack.Pop();`
`2109`	`2111`	`var right = (BoundExpression)this.Visit(binary.Right);`
`2110`	`2112`	`var type = this.VisitType(binary.Type);`
`2111`		`- left = binary.Update(binary.OperatorKind, binary.ConstantValueOpt, binary.Method, binary.ConstrainedToType, binary.ResultKind, left, right, type);`
	`2113`	`+ Debug.Assert(!binary.OperatorKind.IsDynamic());`
	`2114`	`+ left = binary.Update(binary.OperatorKind, binary.ConstantValueOpt, binary.BinaryOperatorMethod, binary.ConstrainedToType, binary.ResultKind, left, right, type);`
`2112`	`2115`
`2113`	`2116`	`if (stack.Count == 0)`
`2114`	`2117`	`{`
Original file line number	Diff line number	Diff line change
`@@ -3854,12 +3854,12 @@ private static void GetSymbolsAndResultKind(BoundBinaryOperator binaryOperator,`
`3854`	`3854`	`{`
`3855`	`3855`	`if (!isDynamic)`
`3856`	`3856`	`{`
`3857`		`- GetSymbolsAndResultKind(binaryOperator, binaryOperator.Method, binaryOperator.OriginalUserDefinedOperatorsOpt, out symbols, out resultKind);`
	`3857`	`+ GetSymbolsAndResultKind(binaryOperator, binaryOperator.BinaryOperatorMethod, binaryOperator.OriginalUserDefinedOperatorsOpt, out symbols, out resultKind);`
`3858`	`3858`	`}`
`3859`	`3859`	`}`
`3860`	`3860`	`else`
`3861`	`3861`	`{`
`3862`		`- Debug.Assert((object)binaryOperator.Method == null && binaryOperator.OriginalUserDefinedOperatorsOpt.IsDefaultOrEmpty);`
	`3862`	`+ Debug.Assert((object)binaryOperator.BinaryOperatorMethod == null && binaryOperator.OriginalUserDefinedOperatorsOpt.IsDefaultOrEmpty);`
`3863`	`3863`
`3864`	`3864`	`if (!isDynamic &&`
`3865`	`3865`	`(op == BinaryOperatorKind.Equal \|\| op == BinaryOperatorKind.NotEqual) &&`
Original file line number	Diff line number	Diff line change
`@@ -5339,7 +5339,7 @@ private void ReinferBinaryOperatorAndSetResult(`
`5339`	`5339`	`TypeWithState rightType,`
`5340`	`5340`	`BoundBinaryOperator binary)`
`5341`	`5341`	`{`
`5342`		`- var inferredResult = ReinferAndVisitBinaryOperator(binary, binary.OperatorKind, binary.Method, binary.Type, binary.Left, leftOperand, leftConversion, leftType, binary.Right, rightOperand, rightConversion, rightType);`
	`5342`	`+ var inferredResult = ReinferAndVisitBinaryOperator(binary, binary.OperatorKind, binary.BinaryOperatorMethod, binary.Type, binary.Left, leftOperand, leftConversion, leftType, binary.Right, rightOperand, rightConversion, rightType);`
`5343`	`5343`	`SetResult(binary, inferredResult, inferredResult.ToTypeWithAnnotations(compilation));`
`5344`	`5344`	`}`
`5345`	`5345`
`@@ -12293,7 +12293,7 @@ void afterLeftChildOfBoundBinaryOperatorHasBeenVisited(BoundBinaryOperator node)`
`12293`	`12293`
`12294`	`12294`	`Visit(node.Right);`
`12295`	`12295`	`TypeWithState rightType = ResultType;`
`12296`		`- SetResultType(node, InferResultNullability(node.OperatorKind, node.Method, node.Type, leftType, rightType));`
	`12296`	`+ SetResultType(node, InferResultNullability(node.OperatorKind, node.BinaryOperatorMethod, node.Type, leftType, rightType));`
`12297`	`12297`	`AfterRightChildOfBinaryLogicalOperatorHasBeenVisited(node.Right, isAnd, isBool, ref leftTrue, ref leftFalse);`
`12298`	`12298`	`}`
`12299`	`12299`