dotnet · 333fred · Jul 10, 2024 · May 4, 2024 · Jun 21, 2024 · Jun 21, 2024
diff --git a/docs/Language Feature Status.md b/docs/Language Feature Status.md
@@ -28,6 +28,7 @@ efforts behind them.
 | [Params-collections](https://github.com/dotnet/csharplang/issues/7700) | main | [Merged to 17.10p3](https://github.com/dotnet/roslyn/issues/71137) | [AlekseyTs](https://github.com/AlekseyTs) | [RikkiGibson](https://github.com/RikkiGibson), [333fred](https://github.com/333fred) | [akhera99](https://github.com/akhera99) (needs IDE fixer) |  [MadsTorgersen](https://github.com/MadsTorgersen), [AlekseyTs](https://github.com/AlekseyTs) |
 | [Ref/unsafe in iterators/async](https://github.com/dotnet/csharplang/blob/main/proposals/ref-unsafe-in-iterators-async.md) | [RefInAsync](https://github.com/dotnet/roslyn/tree/features/RefInAsync) | [Merged into 17.11p2](https://github.com/dotnet/roslyn/issues/72662) | [jjonescz](https://github.com/jjonescz) | [AlekseyTs](https://github.com/AlekseyTs), [cston](https://github.com/cston) | (no IDE impact) | |
 | [`allows ref struct` constraint](https://github.com/dotnet/csharplang/issues/7608) | [RefStructInterfaces](https://github.com/dotnet/roslyn/tree/features/RefStructInterfaces) | [Merged into 17.11p2](https://github.com/dotnet/roslyn/issues/72124) | [AlekseyTs](https://github.com/AlekseyTs) | [cston](https://github.com/cston), [jjonescz](https://github.com/jjonescz) | [ToddGrun](https://github.com/ToddGrun) |  [agocke](https://github.com/agocke), [jaredpar](https://github.com/jaredpar) |
+| [Overload Resolution Priority](https://github.com/dotnet/csharplang/issues/7706) | main | [Merged to 17.12p1](https://github.com/dotnet/roslyn/issues/74131) | [333fred](https://github.com/333fred) | [jcouv](https://github.com/jcouv), [cston](https://github.com/cston) | Not yet assigned | [333fred](https://github.com/333fred) |
 | [Partial properties](https://github.com/dotnet/csharplang/issues/6420) | [partial-properties](https://github.com/dotnet/roslyn/tree/features/partial-properties) | [Merged into 17.11p3](https://github.com/dotnet/roslyn/issues/73090) | [RikkiGibson](https://github.com/RikkiGibson) | [jcouv](https://github.com/jcouv), [333fred](https://github.com/333fred) | [Cosifne](https://github.com/Cosifne) | [333fred](https://github.com/333fred), [RikkiGibson](https://github.com/RikkiGibson) |
 
 # C# 12.0

diff --git a/docs/contributing/Compiler Test Plan.md b/docs/contributing/Compiler Test Plan.md
@@ -85,6 +85,7 @@ This document provides guidance for thinking about language interactions and tes
 - Conversions (boxing/unboxing)
 - Nullable (wrapping, unwrapping)
 - Overload resolution, override/hide/implement (OHI)
+  - OverloadResolutionPriorityAttribute
 - Inheritance (virtual, override, abstract, new)
 - Anonymous types
 - Tuple types and literals (elements with explicit or inferred names, long tuples), tuple equality

@@ -246,7 +246,6 @@ private BoundAttribute BindAttributeCore(AttributeSyntax node, NamedTypeSymbol a
                         diagnostics,
                         attributedMember: attributedMember);
                     boundConstructorArguments = analyzedArguments.ConstructorArguments.Arguments.ToImmutable();
-                    attributeArgumentBinder.ReportDiagnosticsIfObsolete(diagnostics, attributeConstructor, node, hasBaseReceiver: false);
 
                     if (attributeConstructor.Parameters.Any(static p => p.RefKind is RefKind.In or RefKind.RefReadOnlyParameter))
                     {

@@ -6543,7 +6543,7 @@ protected BoundExpression BindClassCreationExpression(
                 CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics);
                 OverloadResolutionResult<MethodSymbol> overloadResolutionResult = OverloadResolutionResult<MethodSymbol>.GetInstance();
                 ImmutableArray<MethodSymbol> accessibleConstructors = GetAccessibleConstructorsForOverloadResolution(type, ref useSiteInfo);
-                this.OverloadResolution.ObjectCreationOverloadResolution(accessibleConstructors, analyzedArguments, overloadResolutionResult, dynamicResolution: true, ref useSiteInfo);
+                this.OverloadResolution.ObjectCreationOverloadResolution(accessibleConstructors, analyzedArguments, overloadResolutionResult, dynamicResolution: true, isEarlyAttributeBinding: IsEarlyAttributeBinder, ref useSiteInfo);
 
                 if (overloadResolutionResult.HasAnyApplicableMember)
                 {
@@ -7014,7 +7014,7 @@ internal bool TryPerformConstructorOverloadResolution(
             if (candidateConstructors.Any())
             {
                 // We have at least one accessible candidate constructor, perform overload resolution with accessible candidateConstructors.
-                this.OverloadResolution.ObjectCreationOverloadResolution(candidateConstructors, analyzedArguments, result, dynamicResolution: false, ref useSiteInfo);
+                this.OverloadResolution.ObjectCreationOverloadResolution(candidateConstructors, analyzedArguments, result, dynamicResolution: false, isEarlyAttributeBinding: IsEarlyAttributeBinder, ref useSiteInfo);
 
                 if (result.Succeeded)
                 {
@@ -7028,7 +7028,7 @@ internal bool TryPerformConstructorOverloadResolution(
                 // We might have a best match constructor which is inaccessible.
                 // Try overload resolution with all instance constructors to generate correct diagnostics and semantic info for this case.
                 OverloadResolutionResult<MethodSymbol> inaccessibleResult = OverloadResolutionResult<MethodSymbol>.GetInstance();
-                this.OverloadResolution.ObjectCreationOverloadResolution(allInstanceConstructors, analyzedArguments, inaccessibleResult, dynamicResolution: false, ref useSiteInfo);
+                this.OverloadResolution.ObjectCreationOverloadResolution(allInstanceConstructors, analyzedArguments, inaccessibleResult, dynamicResolution: false, isEarlyAttributeBinding: IsEarlyAttributeBinder, ref useSiteInfo);
 
                 if (inaccessibleResult.Succeeded)
                 {

@@ -5,12 +5,13 @@
 #nullable disable
 
 using System.Diagnostics.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp
 {
     [SuppressMessage("Performance", "CA1067", Justification = "Equality not actually implemented")]
-    internal readonly struct BinaryOperatorAnalysisResult
+    internal readonly struct BinaryOperatorAnalysisResult : IMemberResolutionResultWithPriority<MethodSymbol>
     {
         public readonly Conversion LeftConversion;
         public readonly Conversion RightConversion;
@@ -35,6 +36,8 @@ public bool HasValue
             get { return this.Kind != OperatorAnalysisResultKind.Undefined; }
         }
 
+        MethodSymbol IMemberResolutionResultWithPriority<MethodSymbol>.MemberWithPriority => Signature.Method;
+
         public override bool Equals(object obj)
         {
             // implement if needed

@@ -1069,13 +1069,15 @@ private void BinaryOperatorOverloadResolution(
                 return;
             }
 
+            var candidates = result.Results;
+            RemoveLowerPriorityMembers<BinaryOperatorAnalysisResult, MethodSymbol>(candidates);
+
             // SPEC: Otherwise, the best function member is the one function member that is better than all other function 
             // SPEC: members with respect to the given argument list, provided that each function member is compared to all 
             // SPEC: other function members using the rules in 7.5.3.2. If there is not exactly one function member that is 
             // SPEC: better than all other function members, then the function member invocation is ambiguous and a binding-time 
             // SPEC: error occurs.
 
-            var candidates = result.Results;
             // Try to find a single best candidate
             int bestIndex = GetTheBestCandidateIndex(left, right, candidates, ref useSiteInfo);
             if (bestIndex != -1)

@@ -5,12 +5,10 @@
 #nullable disable
 
 using Microsoft.CodeAnalysis.CSharp.Symbols;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Text;
 
 namespace Microsoft.CodeAnalysis.CSharp
 {
-    internal readonly struct UnaryOperatorAnalysisResult
+    internal readonly struct UnaryOperatorAnalysisResult : IMemberResolutionResultWithPriority<MethodSymbol>
     {
         public readonly UnaryOperatorSignature Signature;
         public readonly Conversion Conversion;
@@ -33,6 +31,8 @@ public bool HasValue
             get { return this.Kind != OperatorAnalysisResultKind.Undefined; }
         }
 
+        MethodSymbol IMemberResolutionResultWithPriority<MethodSymbol>.MemberWithPriority => Signature.Method;
+
         public static UnaryOperatorAnalysisResult Applicable(UnaryOperatorSignature signature, Conversion conversion)
         {
             return new UnaryOperatorAnalysisResult(OperatorAnalysisResultKind.Applicable, signature, conversion);

@@ -74,13 +74,15 @@ private void UnaryOperatorOverloadResolution(
                 return;
             }
 
+            var candidates = result.Results;
+            RemoveLowerPriorityMembers<UnaryOperatorAnalysisResult, MethodSymbol>(candidates);
+
             // SPEC: Otherwise, the best function member is the one function member that is better than all other function 
             // SPEC: members with respect to the given argument list, provided that each function member is compared to all 
             // SPEC: other function members using the rules in 7.5.3.2. If there is not exactly one function member that is 
             // SPEC: better than all other function members, then the function member invocation is ambiguous and a binding-time 
             // SPEC: error occurs.
 
-            var candidates = result.Results;
             // Try to find a single best candidate
             int bestIndex = GetTheBestCandidateIndex(operand, candidates, ref useSiteInfo);
             if (bestIndex != -1)

@@ -0,0 +1,14 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CodeAnalysis.CSharp;
+
+/// <summary>
+/// Abstraction for use in <see cref="OverloadResolution.RemoveLowerPriorityMembers{TMemberResolution, TMember}(PooledObjects.ArrayBuilder{TMemberResolution})"/>,
+/// to allow it to work generically with all member resolution types (method, unary operator, binary operator).
+/// </summary>
+internal interface IMemberResolutionResultWithPriority<TMember> where TMember : Symbol
+{
+    TMember? MemberWithPriority { get; }
+}
@@ -4,14 +4,15 @@
 
 using System;
 using System.Diagnostics.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Symbols;
 
 namespace Microsoft.CodeAnalysis.CSharp
 {
     /// <summary>
     /// Represents the results of overload resolution for a single member.
     /// </summary>
     [SuppressMessage("Performance", "CA1067", Justification = "Equality not actually implemented")]
-    internal readonly struct MemberResolutionResult<TMember> where TMember : Symbol
+    internal readonly struct MemberResolutionResult<TMember> : IMemberResolutionResultWithPriority<TMember> where TMember : Symbol
     {
         private readonly TMember _member;
         private readonly TMember _leastOverriddenMember;
@@ -121,6 +122,8 @@ internal MemberAnalysisResult Result
             get { return _result; }
         }
 
+        TMember IMemberResolutionResultWithPriority<TMember>.MemberWithPriority => LeastOverriddenMember;
+
         public override bool Equals(object? obj)
         {
             throw new NotSupportedException();

@@ -98,20 +98,20 @@ private static bool SingleValidResult<TMember>(ArrayBuilder<MemberResolutionResu
 
         // Perform overload resolution on the given method group, with the given arguments and
         // names. The names can be null if no names were supplied to any arguments.
-        public void ObjectCreationOverloadResolution(ImmutableArray<MethodSymbol> constructors, AnalyzedArguments arguments, OverloadResolutionResult<MethodSymbol> result, bool dynamicResolution, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
+        public void ObjectCreationOverloadResolution(ImmutableArray<MethodSymbol> constructors, AnalyzedArguments arguments, OverloadResolutionResult<MethodSymbol> result, bool dynamicResolution, bool isEarlyAttributeBinding, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
         {
             Debug.Assert(!dynamicResolution || arguments.HasDynamicArgument);
 
             var results = result.ResultsBuilder;
 
             // First, attempt overload resolution not getting complete results.
-            PerformObjectCreationOverloadResolution(results, constructors, arguments, completeResults: false, dynamicResolution: dynamicResolution, ref useSiteInfo);
+            PerformObjectCreationOverloadResolution(results, constructors, arguments, completeResults: false, dynamicResolution: dynamicResolution, isEarlyAttributeBinding, ref useSiteInfo);
 
             if (!OverloadResolutionResultIsValid(results, arguments.HasDynamicArgument))
             {
                 // We didn't get a single good result. Get full results of overload resolution and return those.
                 result.Clear();
-                PerformObjectCreationOverloadResolution(results, constructors, arguments, completeResults: true, dynamicResolution: dynamicResolution, ref useSiteInfo);
+                PerformObjectCreationOverloadResolution(results, constructors, arguments, completeResults: true, dynamicResolution: dynamicResolution, isEarlyAttributeBinding, ref useSiteInfo);
             }
         }
 
@@ -362,6 +362,8 @@ private void PerformMemberOverloadResolution<TMember>(
 
             if ((options & Options.DynamicResolution) == 0)
             {
+                RemoveLowerPriorityMembers<MemberResolutionResult<TMember>, TMember>(results);
+
                 // SPEC: The best method of the set of candidate methods is identified. If a single best method cannot be identified,
                 // SPEC: the method invocation is ambiguous, and a binding-time error occurs.
 
@@ -1604,6 +1606,7 @@ private void PerformObjectCreationOverloadResolution(
             AnalyzedArguments arguments,
             bool completeResults,
             bool dynamicResolution,
+            bool isEarlyAttributeBinding,
             ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
         {
             // SPEC: The instance constructor to invoke is determined using the overload resolution 
@@ -1621,6 +1624,16 @@ private void PerformObjectCreationOverloadResolution(
 
             if (!dynamicResolution)
             {
+                if (!isEarlyAttributeBinding)
+                {
+                    // If we're still decoding early attributes, we can get into a cycle here where we attempt to decode early attributes,
+                    // which causes overload resolution, which causes us to attempt to decode early attributes, etc. Concretely, this means
+                    // that OverloadResolutionPriorityAttribute won't affect early bound attributes, so you can't use OverloadResolutionPriorityAttribute
+                    // to adjust what constructor of OverloadResolutionPriorityAttribute is chosen. See `CycleOnOverloadResolutionPriorityConstructor_02` for
+                    // an example.
+                    RemoveLowerPriorityMembers<MemberResolutionResult<MethodSymbol>, MethodSymbol>(results);
+                }
+
                 // The best method of the set of candidate methods is identified. If a single best
                 // method cannot be identified, the method invocation is ambiguous, and a binding-time
                 // error occurs. 
@@ -1699,6 +1712,81 @@ private int GetTheBestCandidateIndex<TMember>(ArrayBuilder<MemberResolutionResul
             return currentBestIndex;
         }
 
+        private static void RemoveLowerPriorityMembers<TMemberResolution, TMember>(ArrayBuilder<TMemberResolution> results)
+            where TMemberResolution : IMemberResolutionResultWithPriority<TMember>
+            where TMember : Symbol
+        {
+            // - Then, the reduced set of candidate members is grouped by declaring type. Within each group:
+            //     - Candidate function members are ordered by *overload_resolution_priority*.
+            //     - All members that have a lower *overload_resolution_priority* than the highest found within its declaring type group are removed.
+            // - The reduced groups are then recombined into the final set of applicable candidate function members.
+
+            if (results.Count < 2)
+            {
+                // Can't prune anything unless there's at least 2 candidates
+                return;
+            }
+
+            // Attempt to avoid any allocations by starting with a quick pass through all results and seeing if any have non-default priority. If so, we'll do the full sort and filter.
+            if (results.All(r => r.MemberWithPriority?.GetOverloadResolutionPriority() is null or 0))
+            {
+                // All default, nothing to do
+                return;
+            }
+
+            bool removedMembers = false;
+            var resultsByContainingType = PooledDictionary<NamedTypeSymbol, OneOrMany<TMemberResolution>>.GetInstance();
+
+            foreach (var result in results)
+            {
+                if (result.MemberWithPriority is null)
+                {
+                    // Can happen for things like built-in binary operators
+                    continue;
+                }
+
+                var containingType = result.MemberWithPriority.ContainingType;
+                if (resultsByContainingType.TryGetValue(containingType, out var previousResults))
+                {
+                    var previousPriority = previousResults.First().MemberWithPriority.GetOverloadResolutionPriority();
+                    var currentPriority = result.MemberWithPriority.GetOverloadResolutionPriority();
+
+                    if (currentPriority > previousPriority)
+                    {
+                        removedMembers = true;
+                        resultsByContainingType[containingType] = OneOrMany.Create(result);
+                    }
+                    else if (currentPriority == previousPriority)
+                    {
+                        resultsByContainingType[containingType] = previousResults.Add(result);
+                    }
+                    else
+                    {
+                        removedMembers = true;
+                        Debug.Assert(previousResults.All(r => r.MemberWithPriority.GetOverloadResolutionPriority() == previousPriority));
+                    }
+                }
+                else
+                {
+                    resultsByContainingType.Add(containingType, OneOrMany.Create(result));
+                }
+            }
+
+            if (!removedMembers)
+            {
+                // No changes, so we can just return
+                resultsByContainingType.Free();
+                return;
+            }
+
+            results.Clear();
+            foreach (var (_, resultsForType) in resultsByContainingType)
+            {
+                results.AddRange(resultsForType);
+            }
+            resultsByContainingType.Free();
+        }
+
         private void RemoveWorseMembers<TMember>(ArrayBuilder<MemberResolutionResult<TMember>> results, AnalyzedArguments arguments, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
             where TMember : Symbol
         {