From 0012ac7d09e31dc6e33f00e520c11f3346310d08 Mon Sep 17 00:00:00 2001 From: Fredric Silberberg Date: Wed, 17 Jul 2024 15:14:36 -0700 Subject: [PATCH] Adjust overload resolution priority from LDM LDM today decided that on older language versions, we shouldn't influence overload resolution from OverloadResolutionPriority. It also decided that we should disallow the attribute on local functions. --- .../OverloadResolution/OverloadResolution.cs | 7 ++++- .../CSharp/Portable/Symbols/MethodSymbol.cs | 1 - .../Emit3/OverloadResolutionPriorityTests.cs | 29 +++++++++++++------ 3 files changed, 26 insertions(+), 11 deletions(-) diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/OverloadResolution.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/OverloadResolution.cs index 81a03f32b7847..22c4f20db4d5c 100644 --- a/src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/OverloadResolution.cs +++ b/src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/OverloadResolution.cs @@ -1712,10 +1712,15 @@ private int GetTheBestCandidateIndex(ArrayBuilder(ArrayBuilder results) + private void RemoveLowerPriorityMembers(ArrayBuilder results) where TMemberResolution : IMemberResolutionResultWithPriority where TMember : Symbol { + if (!Compilation.IsFeatureEnabled(MessageID.IDS_OverloadResolutionPriority)) + { + return; + } + // - 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. diff --git a/src/Compilers/CSharp/Portable/Symbols/MethodSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/MethodSymbol.cs index f75a1d8d2729d..e1fcf1786b6cc 100644 --- a/src/Compilers/CSharp/Portable/Symbols/MethodSymbol.cs +++ b/src/Compilers/CSharp/Portable/Symbols/MethodSymbol.cs @@ -1201,7 +1201,6 @@ MethodKind is MethodKind.Ordinary or MethodKind.Constructor or MethodKind.UserDefinedOperator or MethodKind.ReducedExtension - or MethodKind.LocalFunction && !IsOverride; #region IMethodSymbolInternal diff --git a/src/Compilers/CSharp/Test/Emit3/OverloadResolutionPriorityTests.cs b/src/Compilers/CSharp/Test/Emit3/OverloadResolutionPriorityTests.cs index 600ef85738564..c348332455e08 100644 --- a/src/Compilers/CSharp/Test/Emit3/OverloadResolutionPriorityTests.cs +++ b/src/Compilers/CSharp/Test/Emit3/OverloadResolutionPriorityTests.cs @@ -818,7 +818,7 @@ public class C { [OverloadResolutionPriority(1)] public void M(object o) => System.Console.Write("1"); - public void M(string s) => throw null; + public void M(string s) => System.Console.Write("5"); [OverloadResolutionPriority(1)] public int this[object o] @@ -835,8 +835,15 @@ public int this[object o] } public int this[string s] { - get => throw null; - set => throw null; + get + { + System.Console.Write("6"); + return 1; + } + set + { + System.Console.Write("7"); + } } [OverloadResolutionPriority(1)] @@ -847,7 +854,7 @@ public C(object o) public C(string s) { - throw null; + System.Console.Write("8"); } } """; @@ -859,9 +866,9 @@ public C(string s) // (9,6): error CS9202: Feature 'overload resolution priority' is not available in C# 12.0. Please use language version 13.0 or greater. // [OverloadResolutionPriority(1)] Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion12, "OverloadResolutionPriority(1)").WithArguments("overload resolution priority", "13.0").WithLocation(9, 6), - // (28,6): error CS9202: Feature 'overload resolution priority' is not available in C# 12.0. Please use language version 13.0 or greater. + // (35,6): error CS9202: Feature 'overload resolution priority' is not available in C# 12.0. Please use language version 13.0 or greater. // [OverloadResolutionPriority(1)] - Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion12, "OverloadResolutionPriority(1)").WithArguments("overload resolution priority", "13.0").WithLocation(28, 6)); + Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion12, "OverloadResolutionPriority(1)").WithArguments("overload resolution priority", "13.0").WithLocation(35, 6)); var definingComp = CreateCompilation([source, OverloadResolutionPriorityAttributeDefinition], parseOptions: TestOptions.Regular13).VerifyDiagnostics(); @@ -872,8 +879,8 @@ public C(string s) c.M("test"); """; - // We don't error on consumption, only on definition, so this runs just fine. - CompileAndVerify(consumingSource, references: [definingComp.ToMetadataReference()], parseOptions: TestOptions.Regular12, expectedOutput: "4321").VerifyDiagnostics(); + CompileAndVerify(consumingSource, references: [definingComp.ToMetadataReference()], parseOptions: TestOptions.Regular12, expectedOutput: "8765").VerifyDiagnostics(); + CompileAndVerify(consumingSource, references: [definingComp.ToMetadataReference()], parseOptions: TestOptions.Regular13, expectedOutput: "4321").VerifyDiagnostics(); } [Fact] @@ -1822,7 +1829,11 @@ public static void Main() } """; - CompileAndVerify([source, OverloadResolutionPriorityAttributeDefinition], expectedOutput: "1").VerifyDiagnostics(); + CreateCompilation([source, OverloadResolutionPriorityAttributeDefinition]).VerifyDiagnostics( + // (9,10): error CS9262: Cannot use 'OverloadResolutionPriorityAttribute' on this member. + // [OverloadResolutionPriority(1)] + Diagnostic(ErrorCode.ERR_CannotApplyOverloadResolutionPriorityToMember, "OverloadResolutionPriority(1)").WithLocation(9, 10) + ); } [Fact]