Overload resolution was ignoring HasTypeArgumentInferredFromFunctionType for calls in expanded form

cston · cston · commit 97be5100b7ea · 2021-11-08T22:42:32.000-08:00
diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/MemberResolutionResult.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/MemberResolutionResult.cs
@@ -22,14 +22,19 @@ namespace Microsoft.CodeAnalysis.CSharp
         /// </summary>
         internal readonly bool HasTypeArgumentInferredFromFunctionType;
 
-        internal MemberResolutionResult(TMember member, TMember leastOverriddenMember, MemberAnalysisResult result, bool hasTypeArgumentInferredFromFunctionType = false)
+        internal MemberResolutionResult(TMember member, TMember leastOverriddenMember, MemberAnalysisResult result, bool hasTypeArgumentInferredFromFunctionType)
         {
             _member = member;
             _leastOverriddenMember = leastOverriddenMember;
             _result = result;
             HasTypeArgumentInferredFromFunctionType = hasTypeArgumentInferredFromFunctionType;
         }
 
+        internal MemberResolutionResult<TMember> WithResult(MemberAnalysisResult result)
+        {
+            return new MemberResolutionResult<TMember>(Member, LeastOverriddenMember, result, HasTypeArgumentInferredFromFunctionType);
+        }
+
         internal bool IsNull
         {
             get { return (object)_member == null; }
@@ -92,12 +97,12 @@ public bool IsApplicable
 
         internal MemberResolutionResult<TMember> Worse()
         {
-            return new MemberResolutionResult<TMember>(Member, LeastOverriddenMember, MemberAnalysisResult.Worse());
+            return WithResult(MemberAnalysisResult.Worse());
         }
 
         internal MemberResolutionResult<TMember> Worst()
         {
-            return new MemberResolutionResult<TMember>(Member, LeastOverriddenMember, MemberAnalysisResult.Worst());
+            return WithResult(MemberAnalysisResult.Worst());
         }
 
         internal bool HasUseSiteDiagnosticToReport
diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/OverloadResolution.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/OverloadResolution.cs
@@ -385,7 +385,7 @@ private static void RemoveStaticInstanceMismatches<TMember>(ArrayBuilder<MemberR
                 TMember member = result.Member;
                 if (result.Result.IsValid && member.RequiresInstanceReceiver() == requireStatic)
                 {
-                    results[f] = new MemberResolutionResult<TMember>(member, result.LeastOverriddenMember, MemberAnalysisResult.StaticInstanceMismatch());
+                    results[f] = result.WithResult(MemberAnalysisResult.StaticInstanceMismatch());
                 }
             }
         }
@@ -401,7 +401,7 @@ private static void RemoveMethodsNotDeclaredStatic<TMember>(ArrayBuilder<MemberR
                 TMember member = result.Member;
                 if (result.Result.IsValid && !member.IsStatic)
                 {
-                    results[f] = new MemberResolutionResult<TMember>(member, result.LeastOverriddenMember, MemberAnalysisResult.StaticInstanceMismatch());
+                    results[f] = result.WithResult(MemberAnalysisResult.StaticInstanceMismatch());
                 }
             }
         }
@@ -426,8 +426,7 @@ private void RemoveConstraintViolations<TMember>(ArrayBuilder<MemberResolutionRe
                 if ((result.Result.IsValid || result.Result.Kind == MemberResolutionKind.ConstructedParameterFailedConstraintCheck) &&
                     FailsConstraintChecks(member, out ArrayBuilder<TypeParameterDiagnosticInfo> constraintFailureDiagnosticsOpt, template))
                 {
-                    results[f] = new MemberResolutionResult<TMember>(
-                        result.Member, result.LeastOverriddenMember,
+                    results[f] = result.WithResult(
                         MemberAnalysisResult.ConstraintFailure(constraintFailureDiagnosticsOpt.ToImmutableAndFree()));
                 }
             }
@@ -559,7 +558,7 @@ private void RemoveCallingConventionMismatches<TMember>(ArrayBuilder<MemberResol
             }
 
             static MemberResolutionResult<TMember> makeWrongCallingConvention(MemberResolutionResult<TMember> result)
-                => new MemberResolutionResult<TMember>(result.Member, result.LeastOverriddenMember, MemberAnalysisResult.WrongCallingConvention());
+                => result.WithResult(MemberAnalysisResult.WrongCallingConvention());
         }
 #nullable disable
 
@@ -649,13 +648,11 @@ private void RemoveDelegateConversionsWithWrongReturnType<TMember>(
 
                 if (!returnsMatch)
                 {
-                    results[f] = new MemberResolutionResult<TMember>(
-                        result.Member, result.LeastOverriddenMember, MemberAnalysisResult.WrongReturnType());
+                    results[f] = result.WithResult(MemberAnalysisResult.WrongReturnType());
                 }
                 else if (method.RefKind != returnRefKind)
                 {
-                    results[f] = new MemberResolutionResult<TMember>(
-                        result.Member, result.LeastOverriddenMember, MemberAnalysisResult.WrongRefKind());
+                    results[f] = result.WithResult(MemberAnalysisResult.WrongRefKind());
                 }
             }
         }
@@ -699,7 +696,7 @@ private void AddConstructorToCandidateSet(MethodSymbol constructor, ArrayBuilder
                 Debug.Assert(!MemberAnalysisResult.UnsupportedMetadata().HasUseSiteDiagnosticToReportFor(constructor));
                 if (completeResults)
                 {
-                    results.Add(new MemberResolutionResult<MethodSymbol>(constructor, constructor, MemberAnalysisResult.UnsupportedMetadata()));
+                    results.Add(new MemberResolutionResult<MethodSymbol>(constructor, constructor, MemberAnalysisResult.UnsupportedMetadata(), hasTypeArgumentInferredFromFunctionType: false));
                 }
                 return;
             }
@@ -721,7 +718,7 @@ private void AddConstructorToCandidateSet(MethodSymbol constructor, ArrayBuilder
             // If the constructor has a use site diagnostic, we don't want to discard it because we'll have to report the diagnostic later.
             if (result.IsValid || completeResults || result.HasUseSiteDiagnosticToReportFor(constructor))
             {
-                results.Add(new MemberResolutionResult<MethodSymbol>(constructor, constructor, result));
+                results.Add(new MemberResolutionResult<MethodSymbol>(constructor, constructor, result, hasTypeArgumentInferredFromFunctionType: false));
             }
         }
 
@@ -905,7 +902,7 @@ private void AddMemberToCandidateSet<TMember>(
                 Debug.Assert(!MemberAnalysisResult.UnsupportedMetadata().HasUseSiteDiagnosticToReportFor(member));
                 if (completeResults)
                 {
-                    results.Add(new MemberResolutionResult<TMember>(member, leastOverriddenMember, MemberAnalysisResult.UnsupportedMetadata()));
+                    results.Add(new MemberResolutionResult<TMember>(member, leastOverriddenMember, MemberAnalysisResult.UnsupportedMetadata(), hasTypeArgumentInferredFromFunctionType: false));
                 }
                 return;
             }
@@ -1141,7 +1138,7 @@ private void RemoveInaccessibleTypeArguments<TMember>(ArrayBuilder<MemberResolut
                 var result = results[f];
                 if (result.Result.IsValid && !TypeArgumentsAccessible(result.Member.GetMemberTypeArgumentsNoUseSiteDiagnostics(), ref useSiteInfo))
                 {
-                    results[f] = new MemberResolutionResult<TMember>(result.Member, result.LeastOverriddenMember, MemberAnalysisResult.InaccessibleTypeArgument());
+                    results[f] = result.WithResult(MemberAnalysisResult.InaccessibleTypeArgument());
                 }
             }
         }
@@ -1272,7 +1269,7 @@ private static void RemoveLessDerivedMembers<TMember>(ArrayBuilder<MemberResolut
 
                 if (IsLessDerivedThanAny(result.LeastOverriddenMember.ContainingType, results, ref useSiteInfo))
                 {
-                    results[f] = new MemberResolutionResult<TMember>(result.Member, result.LeastOverriddenMember, MemberAnalysisResult.LessDerived());
+                    results[f] = result.WithResult(MemberAnalysisResult.LessDerived());
                 }
             }
         }
@@ -1383,7 +1380,7 @@ private static void RemoveAllInterfaceMembers<TMember>(ArrayBuilder<MemberResolu
                 var member = result.Member;
                 if (member.ContainingType.IsInterfaceType())
                 {
-                    results[f] = new MemberResolutionResult<TMember>(member, result.LeastOverriddenMember, MemberAnalysisResult.LessDerived());
+                    results[f] = result.WithResult(MemberAnalysisResult.LessDerived());
                 }
             }
         }
@@ -3284,15 +3281,15 @@ private MemberResolutionResult<TMember> IsMemberApplicableInNormalForm<TMember>(
                         // thus improving the API and intellisense experience.
                         break;
                     default:
-                        return new MemberResolutionResult<TMember>(member, leastOverriddenMember, MemberAnalysisResult.ArgumentParameterMismatch(argumentAnalysis));
+                        return new MemberResolutionResult<TMember>(member, leastOverriddenMember, MemberAnalysisResult.ArgumentParameterMismatch(argumentAnalysis), hasTypeArgumentInferredFromFunctionType: false);
                 }
             }
 
             // Check after argument analysis, but before more complicated type inference and argument type validation.
             // NOTE: The diagnostic may not be reported (e.g. if the member is later removed as less-derived).
             if (member.HasUseSiteError)
             {
-                return new MemberResolutionResult<TMember>(member, leastOverriddenMember, MemberAnalysisResult.UseSiteError());
+                return new MemberResolutionResult<TMember>(member, leastOverriddenMember, MemberAnalysisResult.UseSiteError(), hasTypeArgumentInferredFromFunctionType: false);
             }
 
             bool hasAnyRefOmittedArgument;
@@ -3334,7 +3331,7 @@ private MemberResolutionResult<TMember> IsMemberApplicableInNormalForm<TMember>(
             // type inference and lambda binding. In that case we still need to return the argument mismatch failure here.
             if (completeResults && !argumentAnalysis.IsValid)
             {
-                return new MemberResolutionResult<TMember>(member, leastOverriddenMember, MemberAnalysisResult.ArgumentParameterMismatch(argumentAnalysis));
+                return new MemberResolutionResult<TMember>(member, leastOverriddenMember, MemberAnalysisResult.ArgumentParameterMismatch(argumentAnalysis), hasTypeArgumentInferredFromFunctionType: false);
             }
 
             return applicableResult;
@@ -3355,14 +3352,14 @@ private MemberResolutionResult<TMember> IsMemberApplicableInExpandedForm<TMember
             var argumentAnalysis = AnalyzeArguments(member, arguments, isMethodGroupConversion: false, expanded: true);
             if (!argumentAnalysis.IsValid)
             {
-                return new MemberResolutionResult<TMember>(member, leastOverriddenMember, MemberAnalysisResult.ArgumentParameterMismatch(argumentAnalysis));
+                return new MemberResolutionResult<TMember>(member, leastOverriddenMember, MemberAnalysisResult.ArgumentParameterMismatch(argumentAnalysis), hasTypeArgumentInferredFromFunctionType: false);
             }
 
             // Check after argument analysis, but before more complicated type inference and argument type validation.
             // NOTE: The diagnostic may not be reported (e.g. if the member is later removed as less-derived).
             if (member.HasUseSiteError)
             {
-                return new MemberResolutionResult<TMember>(member, leastOverriddenMember, MemberAnalysisResult.UseSiteError());
+                return new MemberResolutionResult<TMember>(member, leastOverriddenMember, MemberAnalysisResult.UseSiteError(), hasTypeArgumentInferredFromFunctionType: false);
             }
 
             bool hasAnyRefOmittedArgument;
@@ -3401,9 +3398,7 @@ private MemberResolutionResult<TMember> IsMemberApplicableInExpandedForm<TMember
                 useSiteInfo: ref useSiteInfo);
 
             return result.Result.IsValid ?
-                new MemberResolutionResult<TMember>(
-                    result.Member,
-                    result.LeastOverriddenMember,
+                result.WithResult(
                     MemberAnalysisResult.ExpandedForm(result.Result.ArgsToParamsOpt, result.Result.ConversionsOpt, hasAnyRefOmittedArgument)) :
                 result;
         }
@@ -3465,7 +3460,7 @@ private MemberResolutionResult<TMember> IsApplicable<TMember>(
                                             ref useSiteInfo);
                         if (typeArguments.IsDefault)
                         {
-                            return new MemberResolutionResult<TMember>(member, leastOverriddenMember, inferenceError);
+                            return new MemberResolutionResult<TMember>(member, leastOverriddenMember, inferenceError, hasTypeArgumentInferredFromFunctionType: false);
                         }
                     }
 
@@ -3505,7 +3500,7 @@ private MemberResolutionResult<TMember> IsApplicable<TMember>(
                     {
                         if (!parameterTypes[i].Type.CheckAllConstraints(Compilation, Conversions))
                         {
-                            return new MemberResolutionResult<TMember>(member, leastOverriddenMember, MemberAnalysisResult.ConstructedParameterFailedConstraintsCheck(i));
+                            return new MemberResolutionResult<TMember>(member, leastOverriddenMember, MemberAnalysisResult.ConstructedParameterFailedConstraintsCheck(i), hasTypeArgumentsInferredFromFunctionType);
                         }
                     }
 
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/DelegateTypeTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/DelegateTypeTests.cs
@@ -4371,6 +4371,58 @@ static void Main()
             CompileAndVerify(source, expectedOutput: expectedOutput);
         }
 
+        [WorkItem(57627, "https://github.com/dotnet/roslyn/issues/57627")]
+        [Fact]
+        public void OverloadResolution_48()
+        {
+            var source =
+@"using System;
+using System.Threading.Tasks;
+
+delegate void MyAction();
+delegate T MyFunc<T>();
+
+class A
+{
+    public static void F(object o) { Console.WriteLine(""F(object o)""); }
+    public static void F(object o, string format, params object[] args) { Console.WriteLine(""F(object o, string format, params object[] args)""); }
+    
+    public static void F<T>(T t) { Console.WriteLine(""F<T>(T t)""); }
+    public static void F<T>(T t, string format, params object[] args) { Console.WriteLine(""F<T>(T t, string format, params object[] args)""); }
+    
+    public static void F(MyAction a) { Console.WriteLine(""F(MyAction a)""); }
+    public static void F(MyAction a, string format, params object[] args) { Console.WriteLine(""F(MyAction a, string format, params object[] args)""); }
+    
+    public static void F<T>(MyFunc<T> f) { Console.WriteLine(""F<T>(MyFunc<T> f)""); }
+    public static void F<T>(MyFunc<T> f, string format, params object[] args) { Console.WriteLine(""F<T>(MyFunc<T> f, string format, params object[] args)""); }
+}
+
+class B
+{
+    static async Task Main()
+    {
+        A.F(() => { });
+        A.F(() => { }, """");
+        A.F(() => { }, ""{0}"", 1);
+        A.F(async () => await Task.FromResult<object>(null));
+        A.F(async () => await Task.FromResult<object>(null), """");
+        A.F(async () => await Task.FromResult<object>(null), ""{0}"", 1);
+    }
+}";
+
+            string expectedOutput =
+@"F(MyAction a)
+F(MyAction a, string format, params object[] args)
+F(MyAction a, string format, params object[] args)
+F<T>(MyFunc<T> f)
+F<T>(MyFunc<T> f, string format, params object[] args)
+F<T>(MyFunc<T> f, string format, params object[] args)
+";
+            CompileAndVerify(source, parseOptions: TestOptions.Regular9, expectedOutput: expectedOutput);
+            CompileAndVerify(source, parseOptions: TestOptions.Regular10, expectedOutput: expectedOutput);
+            CompileAndVerify(source, expectedOutput: expectedOutput);
+        }
+
         [Fact]
         public void BestCommonType_01()
         {

Original file line number	Diff line number	Diff line change
`@@ -22,14 +22,19 @@ namespace Microsoft.CodeAnalysis.CSharp`
`22`	`22`	`/// </summary>`
`23`	`23`	`internal readonly bool HasTypeArgumentInferredFromFunctionType;`
`24`	`24`
`25`		`- internal MemberResolutionResult(TMember member, TMember leastOverriddenMember, MemberAnalysisResult result, bool hasTypeArgumentInferredFromFunctionType = false)`
	`25`	`+ internal MemberResolutionResult(TMember member, TMember leastOverriddenMember, MemberAnalysisResult result, bool hasTypeArgumentInferredFromFunctionType)`
`26`	`26`	`{`
`27`	`27`	`_member = member;`
`28`	`28`	`_leastOverriddenMember = leastOverriddenMember;`
`29`	`29`	`_result = result;`
`30`	`30`	`HasTypeArgumentInferredFromFunctionType = hasTypeArgumentInferredFromFunctionType;`
`31`	`31`	`}`
`32`	`32`
	`33`	`+ internal MemberResolutionResult<TMember> WithResult(MemberAnalysisResult result)`
	`34`	`+ {`
	`35`	`+ return new MemberResolutionResult<TMember>(Member, LeastOverriddenMember, result, HasTypeArgumentInferredFromFunctionType);`
	`36`	`+ }`
	`37`	`+`
`33`	`38`	`internal bool IsNull`
`34`	`39`	`{`
`35`	`40`	`get { return (object)_member == null; }`
`@@ -92,12 +97,12 @@ public bool IsApplicable`
`92`	`97`
`93`	`98`	`internal MemberResolutionResult<TMember> Worse()`
`94`	`99`	`{`
`95`		`- return new MemberResolutionResult<TMember>(Member, LeastOverriddenMember, MemberAnalysisResult.Worse());`
	`100`	`+ return WithResult(MemberAnalysisResult.Worse());`
`96`	`101`	`}`
`97`	`102`
`98`	`103`	`internal MemberResolutionResult<TMember> Worst()`
`99`	`104`	`{`
`100`		`- return new MemberResolutionResult<TMember>(Member, LeastOverriddenMember, MemberAnalysisResult.Worst());`
	`105`	`+ return WithResult(MemberAnalysisResult.Worst());`
`101`	`106`	`}`
`102`	`107`
`103`	`108`	`internal bool HasUseSiteDiagnosticToReport`
Original file line number	Diff line number	Diff line change
`@@ -385,7 +385,7 @@ private static void RemoveStaticInstanceMismatches<TMember>(ArrayBuilder<MemberR`
`385`	`385`	`TMember member = result.Member;`
`386`	`386`	`if (result.Result.IsValid && member.RequiresInstanceReceiver() == requireStatic)`
`387`	`387`	`{`
`388`		`- results[f] = new MemberResolutionResult<TMember>(member, result.LeastOverriddenMember, MemberAnalysisResult.StaticInstanceMismatch());`
	`388`	`+ results[f] = result.WithResult(MemberAnalysisResult.StaticInstanceMismatch());`
`389`	`389`	`}`
`390`	`390`	`}`
`391`	`391`	`}`
`@@ -401,7 +401,7 @@ private static void RemoveMethodsNotDeclaredStatic<TMember>(ArrayBuilder<MemberR`
`401`	`401`	`TMember member = result.Member;`
`402`	`402`	`if (result.Result.IsValid && !member.IsStatic)`
`403`	`403`	`{`
`404`		`- results[f] = new MemberResolutionResult<TMember>(member, result.LeastOverriddenMember, MemberAnalysisResult.StaticInstanceMismatch());`
	`404`	`+ results[f] = result.WithResult(MemberAnalysisResult.StaticInstanceMismatch());`
`405`	`405`	`}`
`406`	`406`	`}`
`407`	`407`	`}`
`@@ -426,8 +426,7 @@ private void RemoveConstraintViolations<TMember>(ArrayBuilder<MemberResolutionRe`
`426`	`426`	`if ((result.Result.IsValid \|\| result.Result.Kind == MemberResolutionKind.ConstructedParameterFailedConstraintCheck) &&`
`427`	`427`	`FailsConstraintChecks(member, out ArrayBuilder<TypeParameterDiagnosticInfo> constraintFailureDiagnosticsOpt, template))`
`428`	`428`	`{`
`429`		`- results[f] = new MemberResolutionResult<TMember>(`
`430`		`- result.Member, result.LeastOverriddenMember,`
	`429`	`+ results[f] = result.WithResult(`
`431`	`430`	`MemberAnalysisResult.ConstraintFailure(constraintFailureDiagnosticsOpt.ToImmutableAndFree()));`
`432`	`431`	`}`
`433`	`432`	`}`
`@@ -559,7 +558,7 @@ private void RemoveCallingConventionMismatches<TMember>(ArrayBuilder<MemberResol`
`559`	`558`	`}`
`560`	`559`
`561`	`560`	`static MemberResolutionResult<TMember> makeWrongCallingConvention(MemberResolutionResult<TMember> result)`
`562`		`- => new MemberResolutionResult<TMember>(result.Member, result.LeastOverriddenMember, MemberAnalysisResult.WrongCallingConvention());`
	`561`	`+ => result.WithResult(MemberAnalysisResult.WrongCallingConvention());`
`563`	`562`	`}`
`564`	`563`	`#nullable disable`
`565`	`564`
`@@ -649,13 +648,11 @@ private void RemoveDelegateConversionsWithWrongReturnType<TMember>(`
`649`	`648`
`650`	`649`	`if (!returnsMatch)`
`651`	`650`	`{`
`652`		`- results[f] = new MemberResolutionResult<TMember>(`
`653`		`- result.Member, result.LeastOverriddenMember, MemberAnalysisResult.WrongReturnType());`
	`651`	`+ results[f] = result.WithResult(MemberAnalysisResult.WrongReturnType());`
`654`	`652`	`}`
`655`	`653`	`else if (method.RefKind != returnRefKind)`
`656`	`654`	`{`
`657`		`- results[f] = new MemberResolutionResult<TMember>(`
`658`		`- result.Member, result.LeastOverriddenMember, MemberAnalysisResult.WrongRefKind());`
	`655`	`+ results[f] = result.WithResult(MemberAnalysisResult.WrongRefKind());`
`659`	`656`	`}`
`660`	`657`	`}`
`661`	`658`	`}`
`@@ -699,7 +696,7 @@ private void AddConstructorToCandidateSet(MethodSymbol constructor, ArrayBuilder`
`699`	`696`	`Debug.Assert(!MemberAnalysisResult.UnsupportedMetadata().HasUseSiteDiagnosticToReportFor(constructor));`
`700`	`697`	`if (completeResults)`
`701`	`698`	`{`
`702`		`- results.Add(new MemberResolutionResult<MethodSymbol>(constructor, constructor, MemberAnalysisResult.UnsupportedMetadata()));`
	`699`	`+ results.Add(new MemberResolutionResult<MethodSymbol>(constructor, constructor, MemberAnalysisResult.UnsupportedMetadata(), hasTypeArgumentInferredFromFunctionType: false));`
`703`	`700`	`}`
`704`	`701`	`return;`
`705`	`702`	`}`
`@@ -721,7 +718,7 @@ private void AddConstructorToCandidateSet(MethodSymbol constructor, ArrayBuilder`
`721`	`718`	`// If the constructor has a use site diagnostic, we don't want to discard it because we'll have to report the diagnostic later.`
`722`	`719`	`if (result.IsValid \|\| completeResults \|\| result.HasUseSiteDiagnosticToReportFor(constructor))`
`723`	`720`	`{`
`724`		`- results.Add(new MemberResolutionResult<MethodSymbol>(constructor, constructor, result));`
	`721`	`+ results.Add(new MemberResolutionResult<MethodSymbol>(constructor, constructor, result, hasTypeArgumentInferredFromFunctionType: false));`
`725`	`722`	`}`
`726`	`723`	`}`
`727`	`724`
`@@ -905,7 +902,7 @@ private void AddMemberToCandidateSet<TMember>(`
`905`	`902`	`Debug.Assert(!MemberAnalysisResult.UnsupportedMetadata().HasUseSiteDiagnosticToReportFor(member));`
`906`	`903`	`if (completeResults)`
`907`	`904`	`{`
`908`		`- results.Add(new MemberResolutionResult<TMember>(member, leastOverriddenMember, MemberAnalysisResult.UnsupportedMetadata()));`
	`905`	`+ results.Add(new MemberResolutionResult<TMember>(member, leastOverriddenMember, MemberAnalysisResult.UnsupportedMetadata(), hasTypeArgumentInferredFromFunctionType: false));`
`909`	`906`	`}`
`910`	`907`	`return;`
`911`	`908`	`}`
`@@ -1141,7 +1138,7 @@ private void RemoveInaccessibleTypeArguments<TMember>(ArrayBuilder<MemberResolut`
`1141`	`1138`	`var result = results[f];`
`1142`	`1139`	`if (result.Result.IsValid && !TypeArgumentsAccessible(result.Member.GetMemberTypeArgumentsNoUseSiteDiagnostics(), ref useSiteInfo))`
`1143`	`1140`	`{`
`1144`		`- results[f] = new MemberResolutionResult<TMember>(result.Member, result.LeastOverriddenMember, MemberAnalysisResult.InaccessibleTypeArgument());`
	`1141`	`+ results[f] = result.WithResult(MemberAnalysisResult.InaccessibleTypeArgument());`
`1145`	`1142`	`}`
`1146`	`1143`	`}`
`1147`	`1144`	`}`
`@@ -1272,7 +1269,7 @@ private static void RemoveLessDerivedMembers<TMember>(ArrayBuilder<MemberResolut`
`1272`	`1269`
`1273`	`1270`	`if (IsLessDerivedThanAny(result.LeastOverriddenMember.ContainingType, results, ref useSiteInfo))`
`1274`	`1271`	`{`
`1275`		`- results[f] = new MemberResolutionResult<TMember>(result.Member, result.LeastOverriddenMember, MemberAnalysisResult.LessDerived());`
	`1272`	`+ results[f] = result.WithResult(MemberAnalysisResult.LessDerived());`
`1276`	`1273`	`}`
`1277`	`1274`	`}`
`1278`	`1275`	`}`
`@@ -1383,7 +1380,7 @@ private static void RemoveAllInterfaceMembers<TMember>(ArrayBuilder<MemberResolu`
`1383`	`1380`	`var member = result.Member;`
`1384`	`1381`	`if (member.ContainingType.IsInterfaceType())`
`1385`	`1382`	`{`
`1386`		`- results[f] = new MemberResolutionResult<TMember>(member, result.LeastOverriddenMember, MemberAnalysisResult.LessDerived());`
	`1383`	`+ results[f] = result.WithResult(MemberAnalysisResult.LessDerived());`
`1387`	`1384`	`}`
`1388`	`1385`	`}`
`1389`	`1386`	`}`
`@@ -3284,15 +3281,15 @@ private MemberResolutionResult<TMember> IsMemberApplicableInNormalForm<TMember>(`
`3284`	`3281`	`// thus improving the API and intellisense experience.`
`3285`	`3282`	`break;`
`3286`	`3283`	`default:`
`3287`		`- return new MemberResolutionResult<TMember>(member, leastOverriddenMember, MemberAnalysisResult.ArgumentParameterMismatch(argumentAnalysis));`
	`3284`	`+ return new MemberResolutionResult<TMember>(member, leastOverriddenMember, MemberAnalysisResult.ArgumentParameterMismatch(argumentAnalysis), hasTypeArgumentInferredFromFunctionType: false);`
`3288`	`3285`	`}`
`3289`	`3286`	`}`
`3290`	`3287`
`3291`	`3288`	`// Check after argument analysis, but before more complicated type inference and argument type validation.`
`3292`	`3289`	`// NOTE: The diagnostic may not be reported (e.g. if the member is later removed as less-derived).`
`3293`	`3290`	`if (member.HasUseSiteError)`
`3294`	`3291`	`{`
`3295`		`- return new MemberResolutionResult<TMember>(member, leastOverriddenMember, MemberAnalysisResult.UseSiteError());`
	`3292`	`+ return new MemberResolutionResult<TMember>(member, leastOverriddenMember, MemberAnalysisResult.UseSiteError(), hasTypeArgumentInferredFromFunctionType: false);`
`3296`	`3293`	`}`
`3297`	`3294`
`3298`	`3295`	`bool hasAnyRefOmittedArgument;`
`@@ -3334,7 +3331,7 @@ private MemberResolutionResult<TMember> IsMemberApplicableInNormalForm<TMember>(`
`3334`	`3331`	`// type inference and lambda binding. In that case we still need to return the argument mismatch failure here.`
`3335`	`3332`	`if (completeResults && !argumentAnalysis.IsValid)`
`3336`	`3333`	`{`
`3337`		`- return new MemberResolutionResult<TMember>(member, leastOverriddenMember, MemberAnalysisResult.ArgumentParameterMismatch(argumentAnalysis));`
	`3334`	`+ return new MemberResolutionResult<TMember>(member, leastOverriddenMember, MemberAnalysisResult.ArgumentParameterMismatch(argumentAnalysis), hasTypeArgumentInferredFromFunctionType: false);`
`3338`	`3335`	`}`
`3339`	`3336`
`3340`	`3337`	`return applicableResult;`
`@@ -3355,14 +3352,14 @@ private MemberResolutionResult<TMember> IsMemberApplicableInExpandedForm<TMember`
`3355`	`3352`	`var argumentAnalysis = AnalyzeArguments(member, arguments, isMethodGroupConversion: false, expanded: true);`
`3356`	`3353`	`if (!argumentAnalysis.IsValid)`
`3357`	`3354`	`{`
`3358`		`- return new MemberResolutionResult<TMember>(member, leastOverriddenMember, MemberAnalysisResult.ArgumentParameterMismatch(argumentAnalysis));`
	`3355`	`+ return new MemberResolutionResult<TMember>(member, leastOverriddenMember, MemberAnalysisResult.ArgumentParameterMismatch(argumentAnalysis), hasTypeArgumentInferredFromFunctionType: false);`
`3359`	`3356`	`}`
`3360`	`3357`
`3361`	`3358`	`// Check after argument analysis, but before more complicated type inference and argument type validation.`
`3362`	`3359`	`// NOTE: The diagnostic may not be reported (e.g. if the member is later removed as less-derived).`
`3363`	`3360`	`if (member.HasUseSiteError)`
`3364`	`3361`	`{`
`3365`		`- return new MemberResolutionResult<TMember>(member, leastOverriddenMember, MemberAnalysisResult.UseSiteError());`
	`3362`	`+ return new MemberResolutionResult<TMember>(member, leastOverriddenMember, MemberAnalysisResult.UseSiteError(), hasTypeArgumentInferredFromFunctionType: false);`
`3366`	`3363`	`}`
`3367`	`3364`
`3368`	`3365`	`bool hasAnyRefOmittedArgument;`
`@@ -3401,9 +3398,7 @@ private MemberResolutionResult<TMember> IsMemberApplicableInExpandedForm<TMember`
`3401`	`3398`	`useSiteInfo: ref useSiteInfo);`
`3402`	`3399`
`3403`	`3400`	`return result.Result.IsValid ?`
`3404`		`- new MemberResolutionResult<TMember>(`
`3405`		`- result.Member,`
`3406`		`- result.LeastOverriddenMember,`
	`3401`	`+ result.WithResult(`
`3407`	`3402`	`MemberAnalysisResult.ExpandedForm(result.Result.ArgsToParamsOpt, result.Result.ConversionsOpt, hasAnyRefOmittedArgument)) :`
`3408`	`3403`	`result;`
`3409`	`3404`	`}`
`@@ -3465,7 +3460,7 @@ private MemberResolutionResult<TMember> IsApplicable<TMember>(`
`3465`	`3460`	`ref useSiteInfo);`
`3466`	`3461`	`if (typeArguments.IsDefault)`
`3467`	`3462`	`{`
`3468`		`- return new MemberResolutionResult<TMember>(member, leastOverriddenMember, inferenceError);`
	`3463`	`+ return new MemberResolutionResult<TMember>(member, leastOverriddenMember, inferenceError, hasTypeArgumentInferredFromFunctionType: false);`
`3469`	`3464`	`}`
`3470`	`3465`	`}`
`3471`	`3466`
`@@ -3505,7 +3500,7 @@ private MemberResolutionResult<TMember> IsApplicable<TMember>(`
`3505`	`3500`	`{`
`3506`	`3501`	`if (!parameterTypes[i].Type.CheckAllConstraints(Compilation, Conversions))`
`3507`	`3502`	`{`
`3508`		`- return new MemberResolutionResult<TMember>(member, leastOverriddenMember, MemberAnalysisResult.ConstructedParameterFailedConstraintsCheck(i));`
	`3503`	`+ return new MemberResolutionResult<TMember>(member, leastOverriddenMember, MemberAnalysisResult.ConstructedParameterFailedConstraintsCheck(i), hasTypeArgumentsInferredFromFunctionType);`
`3509`	`3504`	`}`
`3510`	`3505`	`}`
`3511`	`3506`