CallerArgumentExpression attributes on partial method parameters look at the implemention rather than definition parameter names

[RikkiGibson]

Version Used: fca6e1f

Steps to Reproduce: SharpLab

using System.Runtime.CompilerServices;

public partial class C
{
    public partial void M1(string a, [CallerArgumentExpression("a")] string? b = null); // warning CS8963: The CallerArgumentExpressionAttribute applied to parameter 'y' will have no effect. It is applied with an invalid parameter name.
    public partial void M1(string x, string? y) { }
    
    public partial void M2(string a, [CallerArgumentExpression("a")] string? b = null); // ok
    public partial void M2(string a, string? b) { }
    
    void M()
    {
        // Call sites use the definition part parameter names
        M1(a: "1"); // ok
        M1(x: "1"); // error
    }
}

Expected Behavior: The definition part parameter name is used to decide what parameter to include a caller argument expression for

Actual Behavior: The implementation part parameter name is used

caller-argument-expression.md does not appear to specify what should happen here.

Note that using the attribute on the implementation part results in the attribute being ignored in source. So, it feels like the attribute's parameter name references should be oriented around the declaration where usage of the attribute is supported.

[Youssef1313]

That's an interesting scenario 🤓

I think the current behavior is indeed not the correct one.

[Youssef1313]

This may need to be adjusted for VB as well.

(Guessing): The relevant code is:

roslyn/src/Compilers/CSharp/Portable/Symbols/Source/SourceComplexParameterSymbol.cs

Line 684 in 6f815fb

var parameters = ContainingSymbol.GetParameters();

roslyn/src/Compilers/VisualBasic/Portable/Symbols/Source/SourceParameterSymbol.vb

Line 185 in 6f815fb

Dim containingSymbol = Me.ContainingSymbol

Instead of using ContainingSymbol, This probably should be (ContainingSymbol as MethodSymbol)?.PartialDefinitionPart ?? ContainingSymbol.

Edit: Reading the code and thinking again, I think ContainingSymbol should actually have been the definition part. Needs a bit of debugging to see what ContainingSymbol is in this code path.

[jaredpar]

Agree the declaration name makes more sense but this is now 15 year old behavior. Changing it is very risky. Think this should be documented but not changed.

[Youssef1313]

@jaredpar That is 3 or 4 years only I think?

[jaredpar]

Partial members go back to C# 2.0. I cannot recall definitively if we allowed call info in partial but believe we did.

[Youssef1313]

This seems very specific to caller argument expression and not caller info attributes in general. Am I missing some scenario where a similar issue could be noticed with other caller infos?