ContainingSymbol for substituted local function seems incorrect

[jcouv]

Given the behavior in non-generic case, I expected that the ContainingSymbol should be the containing method in the generic scenario. But the containing type is returned instead.
It looks like SubstitutedMethodSymbol uses the same value for both ContainingType and ContainingSymbol.

        [Fact]
        public void ContainingSymbol_ConstructedLocalFunction()
        {
            var source = """
public class C
{
    public void M()
    {
        local(new C());
        void local<T>(T t) { }
    }
}
""";
            var comp = CreateCompilation([source]);
            comp.VerifyDiagnostics();

            var tree = comp.SyntaxTrees.Single();
            var model = comp.GetSemanticModel(tree);
            var invocation = GetSyntax<InvocationExpressionSyntax>(tree, "local(new C())");
            var symbol = model.GetSymbolInfo(invocation).Symbol;
            Assert.Equal("void local<C>(C t)", symbol.ToTestDisplayString());
            Assert.Equal("C", symbol.ContainingSymbol.ToTestDisplayString()); // We're returning the containing type here, instead of the containing symbol (ie. the containing method)
        }

        [Fact]
        public void ContainingSymbol_LocalFunction()
        {
            var source = """
public class C
{
    public void M()
    {
        local();
        void local() { }
    }
}
""";
            var comp = CreateCompilation([source]);
            comp.VerifyDiagnostics();

            var tree = comp.SyntaxTrees.Single();
            var model = comp.GetSemanticModel(tree);
            var invocation = GetSyntax<InvocationExpressionSyntax>(tree, "local()");
            var symbol = model.GetSymbolInfo(invocation).Symbol;
            Assert.Equal("void local()", symbol.ToTestDisplayString());
            Assert.Equal("void C.M()", symbol.ContainingSymbol.ToTestDisplayString());
        }