Suspicious symbol structure is created around tuple fields

[AlekseyTs]

The following unit-test succeeds today:

        [Fact]
        public void Test()
        {
            var source0 = @"
namespace System
{
    // struct with two values
    public struct ValueTuple<T1, T2>
    {
        public T1 Item1;
        public T2 Item2;

        public ValueTuple(T1 item1, T2 item2)
        {
            this.Item1 = item1;
            this.Item2 = item2;
        }

        public override string ToString()
        {
            return F1.ToString();
        }
    }
}
";


            var comp1 = CreateCompilation(source0, targetFramework: TargetFramework.Mscorlib46, options: TestOptions.DebugExe);

            var item1 = comp1.SourceModule.GlobalNamespace.GetMember<FieldSymbol>("System.ValueTuple.Item1");
            var underlying = item1.TupleUnderlyingField;

            Assert.Equal("T1 (T1, T2).Item1", item1.ToTestDisplayString());
            Assert.Equal("T1 (T1, T2).Item1", underlying.ToTestDisplayString());
            Assert.Same(underlying, underlying.TupleUnderlyingField);

            Assert.IsAssignableFrom<TupleFieldSymbol>(item1);
            Assert.IsAssignableFrom<SourceFieldSymbol>(underlying);
            Assert.False(item1.ContainingType.GetMembers().Any(m => m == (object)underlying));
        }

Observed:
For 'Item1' definition (and other fields declared within a tuple type) we have two field symbols. Both are reachable. The SourceFieldSymbol one is dangling, i.e. it is not in GetMembers for the type. TupleFieldSymbol is in GetMembers and points to the SourceFieldSymbol through TupleUnderlyingField. SourceFieldSymbol.TupleUnderlyingField returns itself.

This complicated shape is unexpected, it is not clear what is the motivation for it and what benefits we are getting from duplicating symbols like that. I think more sound design would be:

• to have all field symbols within a tuple type definition to return themselves from TupleFieldSymbol API.
• no dangling field symbols reachable, and preferably not even created.
• the reachable symbols for declarations in source are SourceFieldSymbol, this will lead to less bugs in the future because people naturally assume that symbols for field declarations in source derive from SourceFieldSymbol. We already had to fix bugs in SemanticModel because of that.

I assume PE symbols have similar issues.

I also believe that this issue is the root cause of #43524. If we didn't have this symbol shape, we wouldn't crash.

[AlekseyTs]

cc @jcouv

[AlekseyTs]

It is likely that #43621 is also related

[AlekseyTs]

I think #44000 is another manifestation of this issue