Address some known functionality gaps for extension operators (#79167)

Related to #78968.
Related to #76130.

Author: AlekseyTs

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

@@ -1092,33 +1092,49 @@ private bool BindSimpleBinaryOperatorParts(BinaryExpressionSyntax node, BindingD
             out LookupResultKind resultKind, out ImmutableArray<MethodSymbol> originalUserDefinedOperators,
             out BinaryOperatorSignature resultSignature, out BinaryOperatorAnalysisResult best)
         {
-            bool foundOperator;
-
             if (!IsTypelessExpressionAllowedInBinaryOperator(kind, left, right))
             {
                 resultKind = LookupResultKind.OverloadResolutionFailure;
                 originalUserDefinedOperators = default(ImmutableArray<MethodSymbol>);
                 best = default(BinaryOperatorAnalysisResult);
+                resultSignature = new BinaryOperatorSignature(kind, leftType: null, rightType: null, CreateErrorType());
+                return false;
             }
-            else
-            {
-                best = this.BinaryOperatorOverloadResolution(kind, isChecked: CheckOverflowAtRuntime, left, right, node, diagnostics, out resultKind, out originalUserDefinedOperators);
-            }
 
-            // However, as an implementation detail, we never "fail to find an applicable
-            // operator" during overload resolution if we have x == null, x == default, etc. We always
-            // find at least the reference conversion object == object; the overload resolution
-            // code does not reject that.  Therefore what we should do is only bind
-            // "x == null" as a nullable-to-null comparison if overload resolution chooses
-            // the reference conversion.
+            bool isChecked = CheckOverflowAtRuntime;
+            OverloadResolution.GetStaticUserDefinedBinaryOperatorMethodNames(kind, isChecked, out string name1, out string name2Opt);
+            best = this.BinaryOperatorOverloadResolution(kind, isChecked, name1, name2Opt, left, right, node, diagnostics, out resultKind, out originalUserDefinedOperators);
+
+            return bindSimpleBinaryOperatorPartsContinue(node, diagnostics, left, right, kind, ref resultKind, ref originalUserDefinedOperators, out resultSignature, ref best, isChecked, name1, name2Opt);
 
-            if (!best.HasValue)
-            {
-                resultSignature = new BinaryOperatorSignature(kind, leftType: null, rightType: null, CreateErrorType());
-                foundOperator = false;
-            }
-            else
+            bool bindSimpleBinaryOperatorPartsContinue(
+                BinaryExpressionSyntax node,
+                BindingDiagnosticBag diagnostics,
+                BoundExpression left,
+                BoundExpression right,
+                BinaryOperatorKind kind,
+                ref LookupResultKind resultKind,
+                ref ImmutableArray<MethodSymbol> originalUserDefinedOperators,
+                out BinaryOperatorSignature resultSignature,
+                ref BinaryOperatorAnalysisResult best,
+                bool isChecked,
+                string name1,
+                string name2Opt)
             {
+                // However, as an implementation detail, we never "fail to find an applicable
+                // operator" during overload resolution if we have x == null, x == default, etc. We always
+                // find at least the reference conversion object == object; the overload resolution
+                // code does not reject that.  Therefore what we should do is only bind
+                // "x == null" as a nullable-to-null comparison if overload resolution chooses
+                // the reference conversion.
+
+                if (!best.HasValue)
+                {
+                    resultSignature = new BinaryOperatorSignature(kind, leftType: null, rightType: null, CreateErrorType());
+                    return false;
+                }
+
+                bool foundOperator;
                 var signature = best.Signature;
 
                 if (signature.Method is { } bestMethod)
@@ -1155,9 +1171,27 @@ private bool BindSimpleBinaryOperatorParts(BinaryExpressionSyntax node, BindingD
                     bool rightDefault = right.IsLiteralDefault();
                     foundOperator = !isObjectEquality || BuiltInOperators.IsValidObjectEquality(Conversions, leftType, leftNull, leftDefault, rightType, rightNull, rightDefault, ref useSiteInfo);
                     diagnostics.Add(node, useSiteInfo);
+
+                    if (!foundOperator)
+                    {
+                        Debug.Assert(isObjectEquality);
+
+                        // Try extension operators since predefined object equality was not applicable
+                        LookupResultKind extensionResultKind;
+                        ImmutableArray<MethodSymbol> extensionOriginalUserDefinedOperators;
+                        BinaryOperatorAnalysisResult? extensionBest = BinaryOperatorExtensionOverloadResolution(kind, isChecked, name1, name2Opt, left, right, node, diagnostics, out extensionResultKind, out extensionOriginalUserDefinedOperators);
+
+                        if (extensionBest.HasValue)
+                        {
+                            best = extensionBest.GetValueOrDefault();
+                            resultKind = extensionResultKind;
+                            originalUserDefinedOperators = extensionOriginalUserDefinedOperators;
+                            foundOperator = bindSimpleBinaryOperatorPartsContinue(node, diagnostics, left, right, kind, ref resultKind, ref originalUserDefinedOperators, out resultSignature, ref best, isChecked, name1, name2Opt);
+                        }
+                    }
                 }
+                return foundOperator;
             }
-            return foundOperator;
         }
 
 #nullable enable
@@ -1914,13 +1948,28 @@ private BinaryOperatorAnalysisResult BinaryOperatorOverloadResolution(
         {
             OverloadResolution.GetStaticUserDefinedBinaryOperatorMethodNames(kind, isChecked, out string name1, out string name2Opt);
 
+            return BinaryOperatorOverloadResolution(kind, isChecked, name1, name2Opt, left, right, node, diagnostics, out resultKind, out originalUserDefinedOperators);
+        }
+
+        private BinaryOperatorAnalysisResult BinaryOperatorOverloadResolution(
+            BinaryOperatorKind kind,
+            bool isChecked,
+            string name1,
+            string name2Opt,
+            BoundExpression left,
+            BoundExpression right,
+            CSharpSyntaxNode node,
+            BindingDiagnosticBag diagnostics,
+            out LookupResultKind resultKind,
+            out ImmutableArray<MethodSymbol> originalUserDefinedOperators)
+        {
             BinaryOperatorAnalysisResult possiblyBest = BinaryOperatorNonExtensionOverloadResolution(kind, isChecked, name1, name2Opt, left, right, node, diagnostics, out resultKind, out originalUserDefinedOperators);
 
             if (!possiblyBest.HasValue && resultKind != LookupResultKind.Ambiguous)
             {
                 LookupResultKind extensionResultKind;
                 ImmutableArray<MethodSymbol> extensionOriginalUserDefinedOperators;
-                BinaryOperatorAnalysisResult? extensionBest = extensionOverloadResolution(kind, isChecked, name1, name2Opt, left, right, node, diagnostics, out extensionResultKind, out extensionOriginalUserDefinedOperators);
+                BinaryOperatorAnalysisResult? extensionBest = BinaryOperatorExtensionOverloadResolution(kind, isChecked, name1, name2Opt, left, right, node, diagnostics, out extensionResultKind, out extensionOriginalUserDefinedOperators);
 
                 if (extensionBest.HasValue && (extensionBest.GetValueOrDefault().HasValue || (originalUserDefinedOperators.IsEmpty && !extensionOriginalUserDefinedOperators.IsEmpty)))
                 {
@@ -1931,55 +1980,55 @@ private BinaryOperatorAnalysisResult BinaryOperatorOverloadResolution(
             }
 
             return possiblyBest;
+        }
 
-#nullable enable 
+#nullable enable
 
-            BinaryOperatorAnalysisResult? extensionOverloadResolution(
-                BinaryOperatorKind kind,
-                bool isChecked,
-                string name1,
-                string name2Opt,
-                BoundExpression left,
-                BoundExpression right,
-                CSharpSyntaxNode node,
-                BindingDiagnosticBag diagnostics,
-                out LookupResultKind resultKind,
-                out ImmutableArray<MethodSymbol> originalUserDefinedOperators)
+        private BinaryOperatorAnalysisResult? BinaryOperatorExtensionOverloadResolution(
+            BinaryOperatorKind kind,
+            bool isChecked,
+            string name1,
+            string name2Opt,
+            BoundExpression left,
+            BoundExpression right,
+            CSharpSyntaxNode node,
+            BindingDiagnosticBag diagnostics,
+            out LookupResultKind resultKind,
+            out ImmutableArray<MethodSymbol> originalUserDefinedOperators)
+        {
+            resultKind = LookupResultKind.Empty;
+            originalUserDefinedOperators = [];
+
+            if (left.Type is null && right.Type is null)
             {
-                resultKind = LookupResultKind.Empty;
-                originalUserDefinedOperators = [];
+                return null;
+            }
 
-                if (left.Type is null && right.Type is null)
-                {
-                    return null;
-                }
+            var result = BinaryOperatorOverloadResolutionResult.GetInstance();
+            CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics);
+            var extensionDeclarationsInSingleScope = ArrayBuilder<NamedTypeSymbol>.GetInstance();
+            BinaryOperatorAnalysisResult? possiblyBest = null;
 
-                var result = BinaryOperatorOverloadResolutionResult.GetInstance();
-                CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics);
-                var extensionDeclarationsInSingleScope = ArrayBuilder<NamedTypeSymbol>.GetInstance();
-                BinaryOperatorAnalysisResult? possiblyBest = null;
+            foreach (var scope in new ExtensionScopes(this))
+            {
+                extensionDeclarationsInSingleScope.Clear();
+                scope.Binder.GetExtensionDeclarations(extensionDeclarationsInSingleScope, this);
 
-                foreach (var scope in new ExtensionScopes(this))
+                if (this.OverloadResolution.BinaryOperatorExtensionOverloadResolutionInSingleScope(extensionDeclarationsInSingleScope, kind, isChecked, name1, name2Opt, left, right, result, ref useSiteInfo))
                 {
-                    extensionDeclarationsInSingleScope.Clear();
-                    scope.Binder.GetExtensionDeclarations(extensionDeclarationsInSingleScope, this);
-
-                    if (this.OverloadResolution.BinaryOperatorExtensionOverloadResolutionInSingleScope(extensionDeclarationsInSingleScope, kind, isChecked, name1, name2Opt, left, right, result, ref useSiteInfo))
-                    {
-                        possiblyBest = BinaryOperatorAnalyzeOverloadResolutionResult(result, out resultKind, out originalUserDefinedOperators);
-                        break;
-                    }
+                    possiblyBest = BinaryOperatorAnalyzeOverloadResolutionResult(result, out resultKind, out originalUserDefinedOperators);
+                    break;
                 }
+            }
 
-                diagnostics.Add(node, useSiteInfo);
+            diagnostics.Add(node, useSiteInfo);
 
-                extensionDeclarationsInSingleScope.Free();
-                result.Free();
-                return possiblyBest;
-            }
+            extensionDeclarationsInSingleScope.Free();
+            result.Free();
+            return possiblyBest;
+        }
 
 #nullable disable
-        }
 
         private BinaryOperatorAnalysisResult BinaryOperatorNonExtensionOverloadResolution(
             BinaryOperatorKind kind,
@@ -3758,18 +3807,18 @@ private bool CheckConstraintLanguageVersionAndRuntimeSupportForOperator(SyntaxNo
 
                 if (Compilation.SourceModule != methodOpt.ContainingModule)
                 {
-                    if (SyntaxFacts.IsCheckedOperator(methodOpt.Name))
+                    if (methodOpt.GetIsNewExtensionMember())
+                    {
+                        result &= CheckFeatureAvailability(node, MessageID.IDS_FeatureExtensions, diagnostics);
+                    }
+                    else if (SyntaxFacts.IsCheckedOperator(methodOpt.Name))
                     {
                         result &= CheckFeatureAvailability(node, MessageID.IDS_FeatureCheckedUserDefinedOperators, diagnostics);
                     }
                     else if (isUnsignedRightShift)
                     {
                         result &= CheckFeatureAvailability(node, MessageID.IDS_FeatureUnsignedRightShift, diagnostics);
                     }
-                    else if (methodOpt.GetIsNewExtensionMember())
-                    {
-                        result &= CheckFeatureAvailability(node, MessageID.IDS_FeatureExtensions, diagnostics);
-                    }
                 }
             }
 

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

@@ -95,8 +95,6 @@ private TupleBinaryOperatorInfo BindTupleBinaryOperatorInfo(BinaryExpressionSynt
                 return BindTupleBinaryOperatorNestedInfo(node, kind, left, right, diagnostics);
             }
 
-            // https://github.com/dotnet/roslyn/issues/76130: Add test coverage for this code path
-
             BoundExpression comparison = BindSimpleBinaryOperator(node, diagnostics, left, right, leaveUnconvertedIfInterpolatedString: false);
             switch (comparison)
             {

src/Compilers/CSharp/Portable/Symbols/Source/SourceUserDefinedOperatorSymbolBase.cs

@@ -179,18 +179,13 @@ protected static DeclarationModifiers MakeDeclarationModifiers(bool isCompoundAs
             bool isExplicitInterfaceImplementation = methodKind == MethodKind.ExplicitInterfaceImplementation;
             var defaultAccess = inInterface && !isExplicitInterfaceImplementation ? DeclarationModifiers.Public : DeclarationModifiers.Private;
             var allowedModifiers =
-                DeclarationModifiers.Unsafe;
+                DeclarationModifiers.Unsafe | DeclarationModifiers.Extern;
 
             if (!isCompoundAssignmentOrIncrementAssignment)
             {
                 allowedModifiers |= DeclarationModifiers.Static;
             }
 
-            if (!inExtension)
-            {
-                allowedModifiers |= DeclarationModifiers.Extern;
-            }
-
             if (!isExplicitInterfaceImplementation)
             {
                 allowedModifiers |= DeclarationModifiers.AccessibilityMask;