Merge branch 'UserDefinedCompoundAssignment' into 'extensions'

src/Analyzers/CSharp/Tests/ImplementInterface/ImplementInterfaceTests.cs

@@ -26,6 +26,19 @@ public sealed class ImplementInterfaceTests
 {
     private readonly NamingStylesTestOptionSets _options = new(LanguageNames.CSharp);
 
+    private const string CompilerFeatureRequiredAttribute = """
+
+        namespace System.Runtime.CompilerServices
+        {
+            public sealed class CompilerFeatureRequiredAttribute : Attribute
+            {
+                public CompilerFeatureRequiredAttribute(string featureName)
+                {
+                }
+            }
+        }
+        """;
+
     private static OptionsCollection AllOptionsOff
         => new(LanguageNames.CSharp)
         {
@@ -11243,6 +11256,78 @@ class C : ITest
         }.RunAsync();
     }
 
+    [Theory(Skip = "Yes")] // PROTOTYPE: Something doesn't work
+    [CombinatorialData]
+    public async Task TestInstanceIncrementOperator_ImplementExplicitly([CombinatorialValues("++", "--")] string op)
+    {
+        await new VerifyCS.Test
+        {
+            ReferenceAssemblies = ReferenceAssemblies.Net.Net60,
+            LanguageVersion = LanguageVersion.Preview,
+            TestCode = $$$"""
+            interface ITest
+            {
+                abstract void operator {{{op}}}();
+            }
+            class C : {|CS0535:ITest|}
+            {
+            }
+            """ + CompilerFeatureRequiredAttribute,
+            FixedCode = $$$"""
+            interface ITest
+            {
+                abstract void operator {{{op}}}();
+            }
+            class C : ITest
+            {
+                void ITest.operator {{{op}}}()
+                {
+                    throw new System.NotImplementedException();
+                }
+            }
+            """ + CompilerFeatureRequiredAttribute,
+            CodeActionVerifier = (codeAction, verifier) => verifier.Equal(CodeFixesResources.Implement_all_members_explicitly, codeAction.Title),
+            CodeActionEquivalenceKey = "True;False;False:global::ITest;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+            CodeActionIndex = 0,
+        }.RunAsync();
+    }
+
+    [Theory(Skip = "Yes")] // PROTOTYPE: Something doesn't work
+    [CombinatorialData]
+    public async Task TestInstanceCompoundAssignmentOperator_ImplementExplicitly([CombinatorialValues("+=", "-=", "*=", "/=", "%=", "&=", "|=", "^=", "<<=", ">>=", ">>>=")] string op)
+    {
+        await new VerifyCS.Test
+        {
+            ReferenceAssemblies = ReferenceAssemblies.Net.Net60,
+            LanguageVersion = LanguageVersion.Preview,
+            TestCode = $$$"""
+            interface ITest
+            {
+                abstract void operator {{{op}}}(int y);
+            }
+            class C : {|CS0535:ITest|}
+            {
+            }
+            """ + CompilerFeatureRequiredAttribute,
+            FixedCode = $$$"""
+            interface ITest
+            {
+                abstract void operator {{{op}}}(int y);
+            }
+            class C : ITest
+            {
+                void ITest.operator {{{op}}}(int y)
+                {
+                    throw new System.NotImplementedException();
+                }
+            }
+            """ + CompilerFeatureRequiredAttribute,
+            CodeActionVerifier = (codeAction, verifier) => verifier.Equal(CodeFixesResources.Implement_all_members_explicitly, codeAction.Title),
+            CodeActionEquivalenceKey = "True;False;False:global::ITest;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+            CodeActionIndex = 0,
+        }.RunAsync();
+    }
+
     [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/53927")]
     public async Task TestStaticAbstractInterfaceOperator_ImplementImplicitly()
     {
@@ -11320,6 +11405,80 @@ class C : ITest<C>
         }.RunAsync();
     }
 
+    [Theory]
+    [CombinatorialData]
+    public async Task TestInstanceIncrementOperator_ImplementImplicitly([CombinatorialValues("++", "--")] string op)
+    {
+        await new VerifyCS.Test
+        {
+            ReferenceAssemblies = ReferenceAssemblies.Net.Net60,
+            LanguageVersion = LanguageVersion.Preview,
+            TestCode = $$$"""
+            interface ITest<T> where T : ITest<T>
+            {
+                void operator {{{op}}}();
+            }
+            class C : {|CS0535:ITest<C>|}
+            {
+            }
+            """ + CompilerFeatureRequiredAttribute,
+            // PROTOTYPE: The 'static' modifier shouldn't be added
+            FixedCode = $$$"""
+            interface ITest<T> where T : ITest<T>
+            {
+                void operator {{{op}}}();
+            }
+            class C : {|CS0736:ITest<C>|}
+            {
+                public static void operator {|CS1535:{{{op}}}|}()
+                {
+                    throw new System.NotImplementedException();
+                }
+            }
+            """ + CompilerFeatureRequiredAttribute,
+            CodeActionVerifier = (codeAction, verifier) => verifier.Equal(CodeFixesResources.Implement_interface, codeAction.Title),
+            CodeActionEquivalenceKey = "False;False;True:global::ITest<global::C>;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+            CodeActionIndex = 0,
+        }.RunAsync();
+    }
+
+    [Theory]
+    [CombinatorialData]
+    public async Task TestInstanceCompoundAssignmentOperator_ImplementImplicitly([CombinatorialValues("+=", "-=", "*=", "/=", "%=", "&=", "|=", "^=", "<<=", ">>=", ">>>=")] string op)
+    {
+        await new VerifyCS.Test
+        {
+            ReferenceAssemblies = ReferenceAssemblies.Net.Net60,
+            LanguageVersion = LanguageVersion.Preview,
+            TestCode = $$$"""
+            interface ITest<T> where T : ITest<T>
+            {
+                void operator {{{op}}}(int y);
+            }
+            class C : {|CS0535:ITest<C>|}
+            {
+            }
+            """ + CompilerFeatureRequiredAttribute,
+            // PROTOTYPE: The 'static' modifier shouldn't be added
+            FixedCode = $$$"""
+            interface ITest<T> where T : ITest<T>
+            {
+                void operator {{{op}}}(int y);
+            }
+            class C : ITest<C>
+            {
+                public static void operator {|CS0106:{{{op}}}|}(int y)
+                {
+                    throw new System.NotImplementedException();
+                }
+            }
+            """ + CompilerFeatureRequiredAttribute,
+            CodeActionVerifier = (codeAction, verifier) => verifier.Equal(CodeFixesResources.Implement_interface, codeAction.Title),
+            CodeActionEquivalenceKey = "False;False;True:global::ITest<global::C>;Microsoft.CodeAnalysis.ImplementInterface.AbstractImplementInterfaceService+ImplementInterfaceCodeAction;",
+            CodeActionIndex = 0,
+        }.RunAsync();
+    }
+
     [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/53927")]
     public async Task TestStaticAbstractInterfaceOperator_ImplementExplicitly()
     {

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

@@ -4489,18 +4489,27 @@ internal SafeContext GetValEscape(BoundExpression expr, SafeContext localScopeDe
                 case BoundKind.CompoundAssignmentOperator:
                     var compound = (BoundCompoundAssignmentOperator)expr;
 
+                    // https://github.com/dotnet/roslyn/issues/78198 It looks like we don't have a single test demonstrating significance of the code below.
+
                     if (compound.Operator.Method is { } compoundMethod)
                     {
-                        return GetInvocationEscapeScope(
-                            MethodInfo.Create(compoundMethod),
-                            receiver: null,
-                            receiverIsSubjectToCloning: ThreeState.Unknown,
-                            compoundMethod.Parameters,
-                            argsOpt: [compound.Left, compound.Right],
-                            argRefKindsOpt: default,
-                            argsToParamsOpt: default,
-                            localScopeDepth: localScopeDepth,
-                            isRefEscape: false);
+                        if (compoundMethod.IsStatic)
+                        {
+                            return GetInvocationEscapeScope(
+                                MethodInfo.Create(compoundMethod),
+                                receiver: null,
+                                receiverIsSubjectToCloning: ThreeState.Unknown,
+                                compoundMethod.Parameters,
+                                argsOpt: [compound.Left, compound.Right],
+                                argRefKindsOpt: default,
+                                argsToParamsOpt: default,
+                                localScopeDepth: localScopeDepth,
+                                isRefEscape: false);
+                        }
+                        else
+                        {
+                            return GetValEscape(compound.Left, localScopeDepth);
+                        }
                     }
 
                     return GetValEscape(compound.Left, localScopeDepth)
@@ -5278,20 +5287,27 @@ internal bool CheckValEscape(SyntaxNode node, BoundExpression expr, SafeContext
 
                     if (compound.Operator.Method is { } compoundMethod)
                     {
-                        return CheckInvocationEscape(
-                            compound.Syntax,
-                            MethodInfo.Create(compoundMethod),
-                            receiver: null,
-                            receiverIsSubjectToCloning: ThreeState.Unknown,
-                            compoundMethod.Parameters,
-                            argsOpt: [compound.Left, compound.Right],
-                            argRefKindsOpt: default,
-                            argsToParamsOpt: default,
-                            checkingReceiver: checkingReceiver,
-                            escapeFrom: escapeFrom,
-                            escapeTo: escapeTo,
-                            diagnostics,
-                            isRefEscape: false);
+                        if (compoundMethod.IsStatic)
+                        {
+                            return CheckInvocationEscape(
+                                compound.Syntax,
+                                MethodInfo.Create(compoundMethod),
+                                receiver: null,
+                                receiverIsSubjectToCloning: ThreeState.Unknown,
+                                compoundMethod.Parameters,
+                                argsOpt: [compound.Left, compound.Right],
+                                argRefKindsOpt: default,
+                                argsToParamsOpt: default,
+                                checkingReceiver: checkingReceiver,
+                                escapeFrom: escapeFrom,
+                                escapeTo: escapeTo,
+                                diagnostics,
+                                isRefEscape: false);
+                        }
+                        else
+                        {
+                            return CheckValEscape(compound.Left.Syntax, compound.Left, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics);
+                        }
                     }
 
                     return CheckValEscape(compound.Left.Syntax, compound.Left, escapeFrom, escapeTo, checkingReceiver: false, diagnostics: diagnostics) &&

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

@@ -225,15 +225,24 @@ private ImmutableArray<Symbol> BindOperatorMemberCref(OperatorMemberCrefSyntax s
             CrefParameterListSyntax? parameterListSyntax = syntax.Parameters;
             bool isChecked = syntax.CheckedKeyword.IsKind(SyntaxKind.CheckedKeyword);
 
-            // NOTE: Prefer binary to unary, unless there is exactly one parameter.
-            // CONSIDER: we're following dev11 by never using a binary operator name if there's
-            // exactly one parameter, but doing so would allow us to match single-parameter constructors.
             SyntaxKind operatorTokenKind = syntax.OperatorToken.Kind();
-            string? memberName = parameterListSyntax != null && parameterListSyntax.Parameters.Count == 1
-                ? null
-                : OperatorFacts.BinaryOperatorNameFromSyntaxKindIfAny(operatorTokenKind, isChecked);
+            string? memberName;
 
-            memberName = memberName ?? OperatorFacts.UnaryOperatorNameFromSyntaxKindIfAny(operatorTokenKind, isChecked: isChecked);
+            if (SyntaxFacts.IsOverloadableCompoundAssignmentOperator(operatorTokenKind))
+            {
+                memberName = OperatorFacts.CompoundAssignmentOperatorNameFromSyntaxKind(operatorTokenKind, isChecked);
+            }
+            else
+            {
+                // NOTE: Prefer binary to unary, unless there is exactly one parameter.
+                // CONSIDER: we're following dev11 by never using a binary operator name if there's
+                // exactly one parameter, but doing so would allow us to match single-parameter constructors.
+                memberName = parameterListSyntax != null && parameterListSyntax.Parameters.Count == 1
+                    ? null
+                    : OperatorFacts.BinaryOperatorNameFromSyntaxKindIfAny(operatorTokenKind, isChecked);
+
+                memberName = memberName ?? OperatorFacts.UnaryOperatorNameFromSyntaxKindIfAny(operatorTokenKind, isChecked: isChecked);
+            }
 
             if (memberName == null ||
                 (isChecked && !syntax.OperatorToken.IsMissing && !SyntaxFacts.IsCheckedOperator(memberName))) // the operator cannot be checked

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

@@ -11364,38 +11364,7 @@ private BoundConditionalAccess BindConditionalAccessExpression(ConditionalAccess
                 // For improved diagnostics we detect the cases where the value will be used and produce a
                 // more specific (though not technically correct) diagnostic here:
                 // "Error CS0023: Operator '?' cannot be applied to operand of type 'T'"
-                bool resultIsUsed = true;
-                CSharpSyntaxNode parent = node.Parent;
-
-                if (parent != null)
-                {
-                    switch (parent.Kind())
-                    {
-                        case SyntaxKind.ExpressionStatement:
-                            resultIsUsed = ((ExpressionStatementSyntax)parent).Expression != node;
-                            break;
-
-                        case SyntaxKind.SimpleLambdaExpression:
-                            resultIsUsed = (((SimpleLambdaExpressionSyntax)parent).Body != node) || MethodOrLambdaRequiresValue(ContainingMemberOrLambda, Compilation);
-                            break;
-
-                        case SyntaxKind.ParenthesizedLambdaExpression:
-                            resultIsUsed = (((ParenthesizedLambdaExpressionSyntax)parent).Body != node) || MethodOrLambdaRequiresValue(ContainingMemberOrLambda, Compilation);
-                            break;
-
-                        case SyntaxKind.ArrowExpressionClause:
-                            resultIsUsed = (((ArrowExpressionClauseSyntax)parent).Expression != node) || MethodOrLambdaRequiresValue(ContainingMemberOrLambda, Compilation);
-                            break;
-
-                        case SyntaxKind.ForStatement:
-                            // Incrementors and Initializers doesn't have to produce a value
-                            var loop = (ForStatementSyntax)parent;
-                            resultIsUsed = !loop.Incrementors.Contains(node) && !loop.Initializers.Contains(node);
-                            break;
-                    }
-                }
-
-                if (resultIsUsed)
+                if (ResultIsUsed(node))
                 {
                     return GenerateBadConditionalAccessNodeError(node, receiver, access, diagnostics);
                 }
@@ -11414,6 +11383,42 @@ private BoundConditionalAccess BindConditionalAccessExpression(ConditionalAccess
             return new BoundConditionalAccess(node, receiver, access, accessType);
         }
 
+        private bool ResultIsUsed(ExpressionSyntax node)
+        {
+            bool resultIsUsed = true;
+            CSharpSyntaxNode parent = node.Parent;
+
+            if (parent != null)
+            {
+                switch (parent.Kind())
+                {
+                    case SyntaxKind.ExpressionStatement:
+                        resultIsUsed = ((ExpressionStatementSyntax)parent).Expression != node;
+                        break;
+
+                    case SyntaxKind.SimpleLambdaExpression:
+                        resultIsUsed = (((SimpleLambdaExpressionSyntax)parent).Body != node) || MethodOrLambdaRequiresValue(ContainingMemberOrLambda, Compilation);
+                        break;
+
+                    case SyntaxKind.ParenthesizedLambdaExpression:
+                        resultIsUsed = (((ParenthesizedLambdaExpressionSyntax)parent).Body != node) || MethodOrLambdaRequiresValue(ContainingMemberOrLambda, Compilation);
+                        break;
+
+                    case SyntaxKind.ArrowExpressionClause:
+                        resultIsUsed = (((ArrowExpressionClauseSyntax)parent).Expression != node) || MethodOrLambdaRequiresValue(ContainingMemberOrLambda, Compilation);
+                        break;
+
+                    case SyntaxKind.ForStatement:
+                        // Incrementors and Initializers doesn't have to produce a value
+                        var loop = (ForStatementSyntax)parent;
+                        resultIsUsed = !loop.Incrementors.Contains(node) && !loop.Initializers.Contains(node);
+                        break;
+                }
+            }
+
+            return resultIsUsed;
+        }
+
         internal static bool MethodOrLambdaRequiresValue(Symbol symbol, CSharpCompilation compilation)
         {
             return symbol is MethodSymbol method &&

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

@@ -1485,6 +1485,10 @@ internal SingleLookupResult CheckViability(Symbol symbol, int arity, LookupOptio
             {
                 return LookupResult.Empty();
             }
+            else if ((options & LookupOptions.MustBeOperator) != 0 && unwrappedSymbol is not MethodSymbol { MethodKind: MethodKind.UserDefinedOperator })
+            {
+                return LookupResult.Empty();
+            }
             else if (!IsInScopeOfAssociatedSyntaxTree(unwrappedSymbol))
             {
                 return LookupResult.Empty();
@@ -1503,7 +1507,7 @@ internal SingleLookupResult CheckViability(Symbol symbol, int arity, LookupOptio
             {
                 return LookupResult.WrongArity(symbol, diagInfo);
             }
-            else if (!InCref && !unwrappedSymbol.CanBeReferencedByNameIgnoringIllegalCharacters)
+            else if (!InCref && !unwrappedSymbol.CanBeReferencedByNameIgnoringIllegalCharacters && (options & LookupOptions.MustBeOperator) == 0)
             {
                 // Strictly speaking, this test should actually check CanBeReferencedByName.
                 // However, we don't want to pay that cost in cases where the lookup is based