Merge main to main-vs-deps

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

@@ -2995,7 +2995,6 @@ private void CoerceArguments<TMember>(
             ArrayBuilder<BoundExpression> arguments,
             BindingDiagnosticBag diagnostics,
             TypeSymbol? receiverType,
-            RefKind? receiverRefKind,
             uint receiverEscapeScope)
             where TMember : Symbol
         {
@@ -3014,7 +3013,7 @@ private void CoerceArguments<TMember>(
                     Debug.Assert(argument is BoundUnconvertedInterpolatedString or BoundBinaryOperator { IsUnconvertedInterpolatedStringAddition: true });
                     TypeWithAnnotations parameterTypeWithAnnotations = GetCorrespondingParameterTypeWithAnnotations(ref result, parameters, arg);
                     reportUnsafeIfNeeded(methodResult, diagnostics, argument, parameterTypeWithAnnotations);
-                    arguments[arg] = BindInterpolatedStringHandlerInMemberCall(argument, arguments, parameters, ref result, arg, receiverType, receiverRefKind, receiverEscapeScope, diagnostics);
+                    arguments[arg] = BindInterpolatedStringHandlerInMemberCall(argument, arguments, parameters, ref result, arg, receiverType, receiverEscapeScope, diagnostics);
                 }
                 // https://github.com/dotnet/roslyn/issues/37119 : should we create an (Identity) conversion when the kind is Identity but the types differ?
                 else if (!kind.IsIdentity)
@@ -5723,7 +5722,7 @@ internal bool TryPerformConstructorOverloadResolution(
 
             if (succeededIgnoringAccessibility)
             {
-                this.CoerceArguments<MethodSymbol>(result.ValidResult, analyzedArguments.Arguments, diagnostics, receiverType: null, receiverRefKind: null, receiverEscapeScope: Binder.ExternalScope);
+                this.CoerceArguments<MethodSymbol>(result.ValidResult, analyzedArguments.Arguments, diagnostics, receiverType: null, receiverEscapeScope: Binder.ExternalScope);
             }
 
             // Fill in the out parameter with the result, if there was one; it might be inaccessible.
@@ -7967,7 +7966,7 @@ private BoundExpression BindIndexerOrIndexedPropertyAccess(
                 uint receiverEscapeScope = property.RequiresInstanceReceiver && receiverOpt != null
                     ? receiverRefKind?.IsWritableReference() == true ? GetRefEscape(receiverOpt, LocalScopeDepth) : GetValEscape(receiverOpt, LocalScopeDepth)
                     : Binder.ExternalScope;
-                this.CoerceArguments<PropertySymbol>(resolutionResult, analyzedArguments.Arguments, diagnostics, receiverOpt?.Type, receiverRefKind, receiverEscapeScope);
+                this.CoerceArguments<PropertySymbol>(resolutionResult, analyzedArguments.Arguments, diagnostics, receiverOpt?.Type, receiverEscapeScope);
 
                 var isExpanded = resolutionResult.Result.Kind == MemberResolutionKind.ApplicableInExpandedForm;
                 var argsToParams = resolutionResult.Result.ArgsToParamsOpt;

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

@@ -766,7 +766,6 @@ private BoundExpression BindInterpolatedStringHandlerInMemberCall(
             ref MemberAnalysisResult memberAnalysisResult,
             int interpolatedStringArgNum,
             TypeSymbol? receiverType,
-            RefKind? receiverRefKind,
             uint receiverEscapeScope,
             BindingDiagnosticBag diagnostics)
         {
@@ -874,8 +873,8 @@ private BoundExpression BindInterpolatedStringHandlerInMemberCall(
                 switch (argumentIndex)
                 {
                     case BoundInterpolatedStringArgumentPlaceholder.InstanceParameter:
-                        Debug.Assert(receiverRefKind != null && receiverType is not null);
-                        refKind = receiverRefKind.GetValueOrDefault();
+                        Debug.Assert(receiverType is not null);
+                        refKind = RefKind.None;
                         placeholderType = receiverType;
                         break;
                     case BoundInterpolatedStringArgumentPlaceholder.UnspecifiedParameter:

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

@@ -1026,7 +1026,7 @@ private BoundCall BindInvocationExpressionContinued(
             uint receiverValEscapeScope = method.RequiresInstanceReceiver && receiver != null
                 ? receiverRefKind?.IsWritableReference() == true ? GetRefEscape(receiver, LocalScopeDepth) : GetValEscape(receiver, LocalScopeDepth)
                 : Binder.ExternalScope;
-            this.CoerceArguments(methodResult, analyzedArguments.Arguments, diagnostics, receiver?.Type, receiverRefKind, receiverValEscapeScope);
+            this.CoerceArguments(methodResult, analyzedArguments.Arguments, diagnostics, receiver?.Type, receiverValEscapeScope);
 
             var expanded = methodResult.Result.Kind == MemberResolutionKind.ApplicableInExpandedForm;
             var argsToParams = methodResult.Result.ArgsToParamsOpt;
@@ -2033,7 +2033,6 @@ private BoundFunctionPointerInvocation BindFunctionPointerInvocation(SyntaxNode
                 analyzedArguments.Arguments,
                 diagnostics,
                 receiverType: null,
-                receiverRefKind: null,
                 receiverEscapeScope: Binder.ExternalScope);
 
             var args = analyzedArguments.Arguments.ToImmutable();

src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests.cs

@@ -10291,7 +10291,7 @@ class Program2 { }
                 Diagnostic(ErrorCode.ERR_BadAttributeArgument, "default(T2)").WithLocation(10, 22));
         }
 
-        [ConditionalFact(typeof(CoreClrOnly), AlwaysSkip = "https://github.com/dotnet/roslyn/issues/56664"), WorkItem(55190, "https://github.com/dotnet/roslyn/issues/55190")]
+        [ConditionalFact(typeof(CoreClrOnly)), WorkItem(55190, "https://github.com/dotnet/roslyn/issues/55190")]
         public void GenericAttributeParameter_01()
         {
             var source = @"
@@ -10325,9 +10325,7 @@ static void Main()
     }
 }
 ";
-            // The expected output here will change once we consume a runtime
-            // which has a fix for https://github.com/dotnet/runtime/issues/56492
-            var verifier = CompileAndVerify(source, sourceSymbolValidator: verify, symbolValidator: verifyMetadata, expectedOutput: "CustomAttributeFormatException");
+            var verifier = CompileAndVerify(source, sourceSymbolValidator: verify, symbolValidator: verifyMetadata, expectedOutput: "a");
 
             verifier.VerifyTypeIL("Holder", @"
 .class private auto ansi beforefieldinit Holder

src/Compilers/CSharp/Test/Semantic/Semantics/DelegateTypeTests.cs

@@ -3267,6 +3267,7 @@ static void Main()
             CompileAndVerify(source, expectedOutput: expectedOutput);
         }
 
+        [WorkItem(56623, "https://github.com/dotnet/roslyn/issues/56623")]
         [Fact]
         public void OverloadResolution_16()
         {
@@ -3277,21 +3278,47 @@ class Program
     static void F(Func<Func<object>> f, int i) => Report(f);
     static void F(Func<Func<int>> f, object o) => Report(f);
     static void Main()
+    {
+        M(false);
+    }
+    static void M(bool b)
     {
         F(() => () => 1, 2);
+        F(() => () => { if (b) return 0; return 1; }, 2);
+        F(() => { if (b) return () => 0; return () => 1; }, 2);
     }
     static void Report(Delegate d) => Console.WriteLine(d.GetType());
 }";
 
             CompileAndVerify(source, parseOptions: TestOptions.Regular9, expectedOutput:
-@"System.Func`1[System.Func`1[System.Object]]");
+@"System.Func`1[System.Func`1[System.Object]]
+System.Func`1[System.Func`1[System.Object]]
+System.Func`1[System.Func`1[System.Object]]
+");
 
             // Breaking change from C#9 which binds calls to F(Func<Func<object>>, int).
+            //
+            // The calls such as F(() => () => 1, 2) should be considered ambiguous in C#9 as per the C# spec.
+            // But for compatibility with the legacy compiler, the implementation of "better conversion
+            // from expression" ignores delegate types for certain cases when the corresponding
+            // argument is a lambda expression, such as when the inferred return type of the lambda
+            // expression is null (see OverloadResolution.CanDowngradeConversionFromLambdaToNeither()).
+            // With the code example above, in C#10, the inferred return type of lambdas such as () => () => 1
+            // is Func<int> rather than null so the compatibility exception no longer applies for this example.
+            //
+            // We've decided to take the breaking change and match the C# spec rather than the
+            // legacy compiler in this particular case.
             var expectedDiagnostics = new[]
             {
-                // (8,9): error CS0121: The call is ambiguous between the following methods or properties: 'Program.F(Func<Func<object>>, int)' and 'Program.F(Func<Func<int>>, object)'
+                // (12,9): error CS0121: The call is ambiguous between the following methods or properties: 'Program.F(Func<Func<object>>, int)' and 'Program.F(Func<Func<int>>, object)'
                 //         F(() => () => 1, 2);
-                Diagnostic(ErrorCode.ERR_AmbigCall, "F").WithArguments("Program.F(System.Func<System.Func<object>>, int)", "Program.F(System.Func<System.Func<int>>, object)").WithLocation(8, 9)
+                Diagnostic(ErrorCode.ERR_AmbigCall, "F").WithArguments("Program.F(System.Func<System.Func<object>>, int)", "Program.F(System.Func<System.Func<int>>, object)").WithLocation(12, 9),
+                // (13,9): error CS0121: The call is ambiguous between the following methods or properties: 'Program.F(Func<Func<object>>, int)' and 'Program.F(Func<Func<int>>, object)'
+                //         F(() => () => { if (b) return 0; return 1; }, 2);
+                Diagnostic(ErrorCode.ERR_AmbigCall, "F").WithArguments("Program.F(System.Func<System.Func<object>>, int)", "Program.F(System.Func<System.Func<int>>, object)").WithLocation(13, 9),
+                // (14,9): error CS0121: The call is ambiguous between the following methods or properties: 'Program.F(Func<Func<object>>, int)' and 'Program.F(Func<Func<int>>, object)'
+                //         F(() => { if (b) return () => 0; return () => 1; }, 2);
+                Diagnostic(ErrorCode.ERR_AmbigCall, "F").WithArguments("Program.F(System.Func<System.Func<object>>, int)", "Program.F(System.Func<System.Func<int>>, object)").WithLocation(14, 9)
             };
             var comp = CreateCompilation(source, parseOptions: TestOptions.Regular10);
             comp.VerifyDiagnostics(expectedDiagnostics);
@@ -4218,6 +4245,67 @@ static void Main()
             CompileAndVerify(source, expectedOutput: expectedOutput);
         }
 
+        [Fact]
+        public void OverloadResolution_46()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void F(Func<Func<object>> f, int i) => Report(f);
+    static void F(Func<Func<int>> f, object o) => Report(f);
+    static void Main()
+    {
+        M(false);
+    }
+    static void M(bool b)
+    {
+        F(() => b ? () => 0 : () => 1, 2);
+    }
+    static void Report(Delegate d) => Console.WriteLine(d.GetType());
+}";
+
+            var expectedDiagnostics = new[]
+            {
+                // (12,9): error CS0121: The call is ambiguous between the following methods or properties: 'Program.F(Func<Func<object>>, int)' and 'Program.F(Func<Func<int>>, object)'
+                //         F(() => b ? () => 0 : () => 1, 2);
+                Diagnostic(ErrorCode.ERR_AmbigCall, "F").WithArguments("Program.F(System.Func<System.Func<object>>, int)", "Program.F(System.Func<System.Func<int>>, object)").WithLocation(12, 9)
+            };
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(expectedDiagnostics);
+            comp = CreateCompilation(source, parseOptions: TestOptions.Regular10);
+            comp.VerifyDiagnostics(expectedDiagnostics);
+            comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(expectedDiagnostics);
+        }
+
+        [Fact]
+        public void OverloadResolution_47()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void F(int i, Func<Func<object>> f) => Report(f);
+    static void F(object o, Func<Func<int>> f) => Report(f);
+    static void Main()
+    {
+        F(2, () => new[] { () => 0, () => 1 }[0]);
+    }
+    static void Report(Delegate d) => Console.WriteLine(d.GetType());
+}";
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(
+                // (8,20): error CS0826: No best type found for implicitly-typed array
+                //         F(2, () => new[] { () => 0, () => 1 }[0]);
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { () => 0, () => 1 }").WithLocation(8, 20));
+
+            var expectedOutput = @"System.Func`1[System.Func`1[System.Int32]]";
+            CompileAndVerify(source, parseOptions: TestOptions.Regular10, expectedOutput: expectedOutput);
+            CompileAndVerify(source, expectedOutput: expectedOutput);
+        }
+
         [Fact]
         public void BestCommonType_01()
         {