Report an error for dynamic evaluation of &&/|| when left operand is statically typed as an interface (#80962)

Fixes #80954

Author: Copilot

docs/compilers/CSharp/Compiler Breaking Changes - DotNet 11.md

@@ -103,3 +103,54 @@ void Method()
 If your code is impacted by this breaking change, consider adding a reference to an assembly defining `System.Runtime.InteropServices.InAttribute` 
 to your project.
 
+
+## Dynamic evaluation of `&&`/`||` operators is not allowed with the left operand statically typed as an interface.
+
+***Introduced in Visual Studio 2026 version 18.3***
+
+The C# compiler now reports an error when an interface type is used as the left operand of
+a logical `&&` or `||` operator with a `dynamic` right operand.
+Previously, code would compile for an interface type with `true`/`false` operators,
+but fail at runtime with a `RuntimeBinderException` because the runtime binder cannot
+invoke operators defined on interfaces.
+
+This change prevents a runtime error by reporting it at compile time instead. The error message is:
+
+> error CS7083: Expression must be implicitly convertible to Boolean or its type 'I1' must not be an interface and must define operator 'false'.
+
+```cs
+interface I1
+{
+    static bool operator true(I1 x) => false;
+    static bool operator false(I1 x) => false;
+}
+
+class C1 : I1
+{
+    public static C1 operator &(C1 x, C1 y) => x;
+    public static bool operator true(C1 x) => false;
+    public static bool operator false(C1 x) => false;
+}
+
+void M()
+{
+    I1 x = new C1();
+    dynamic y = new C1();
+    _ = x && y; // error CS7083: Expression must be implicitly convertible to Boolean or its type 'I1' must not be an interface and must define operator 'false'.
+}
+```
+
+If your code is impacted by this breaking change, consider changing the static type of the left operand from an interface type to a concrete class type,
+or to `dynamic` type:
+
+```cs
+void M()
+{
+    I1 x = new C1();
+    dynamic y = new C1();
+    _ = (C1)x && y; // Valid - uses operators defined on C1
+    _ = (dynamic)x && y; // Valid - uses operators defined on C1
+}
+```
+
+See also https://github.com/dotnet/roslyn/issues/80954.

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

@@ -1630,7 +1630,7 @@ private bool IsValidDynamicCondition(BoundExpression left, bool isNegative, Bind
                 return true;
             }
 
-            if (type.Kind != SymbolKind.NamedType || type.IsNullableType())
+            if (type is not NamedTypeSymbol { IsInterface: false } namedType || namedType.IsNullableType())
             {
                 diagnostics.Add(left.Syntax, useSiteInfo);
                 return false;
@@ -1649,7 +1649,6 @@ private bool IsValidDynamicCondition(BoundExpression left, bool isNegative, Bind
             // Stack Trace:
             //     at CallSite.Target(Closure, CallSite, Object, Nullable`1)
             //     at System.Dynamic.UpdateDelegates.UpdateAndExecute2[T0,T1,TRet](CallSite site, T0 arg0, T1 arg1)
-            var namedType = type as NamedTypeSymbol;
             var operandPlaceholder = new BoundValuePlaceholder(left.Syntax, namedType).MakeCompilerGenerated();
             UnaryOperatorAnalysisResult result = operatorOverloadResolution(left.Syntax, operandPlaceholder, isNegative ? UnaryOperatorKind.False : UnaryOperatorKind.True, diagnostics);
 

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -4251,7 +4251,7 @@ You should consider suppressing the warning only if you're sure that you don't w
     <value>The CallerFilePathAttribute will have no effect; it is overridden by the CallerLineNumberAttribute</value>
   </data>
   <data name="ERR_InvalidDynamicCondition" xml:space="preserve">
-    <value>Expression must be implicitly convertible to Boolean or its type '{0}' must define operator '{1}'.</value>
+    <value>Expression must be implicitly convertible to Boolean or its type '{0}' must not be an interface and must define operator '{1}'.</value>
   </data>
   <data name="ERR_MixingWinRTEventWithRegular" xml:space="preserve">
     <value>'{0}' cannot implement '{1}' because '{2}' is a Windows Runtime event and '{3}' is a regular .NET event.</value>