Introduce local adds redundant globally qualified namespace on local's type

[drewnoakes]

Version Used:

Steps to Reproduce:

namespace MyNamespace;

record struct ID<T>(T Key);

class C
{
    void M(int id)
    {
        N(id, new Dictionary<ID<int>, string>());

        // The generic type is required for the repro
        // The inner function is required for the repro
        // The record struct is required for the repro

        void N<T>(T id, Dictionary<ID<T>, string> d)
        {
            if (d.TryGetValue(new(id), out string? s))
            //                ^^^^^^^ Introduce local for this range
            {
            }
        }
    }
}

Expected Behavior:

void N<T>(T id, Dictionary<ID<T>, string> dic)
{
    ID<T> key = new(id);
    if (dic.TryGetValue(key, out string? s))
    {
    }
}

Actual Behavior:

void N<T>(T id, Dictionary<ID<T>, string> dic)
{
    global::MyNamespace.ID<T> key = new(id);
//  ^^^^^^^^^^^^^^^^^^^ Redundant qualifier
    if (dic.TryGetValue(key, out string? s))
    {
    }
}

[Youssef1313]

This is probably ExpressionSimplifier's fault, which should be affecting CSharpSimplifyTypeNamesDiagnosticAnalyzer as well.

After investigating this, I think I found the cause of the problem, but it's not clear what needs to be done to address it.

Essentially, it's an edgecase of SymbolEquivalenceComparer: when comparing 2 type parameters symbols, it wants that both containing symbols (the local function in this case) are equal for the type param to be considered equal. This is needed by the speculation analyser to conclude if the attempted simplification of the namespace changes the semantics or not.

The problem is local functions has to be compared by their locations and we are dealing with 2 different semantic models: the original with all sources and the speculative one whose root is the local function. So location comparisons always report false because they can't be compared like this and it causes the speculative analyser to think the T type parameter has changed semantics and denies the simplification.

This is the only problem comparing the 2 types parameter has. My question is how do we address this? Even if both symbols are local functions, that doesn't mean they are the same ones and the analyser relies on their location being the same, but that doesn't seem possible.

What's the best way to approach this?

[CyrusNajmabadi]

Fixed with #76218