Don't wrap fields in ValueTuple definitions

src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs

@@ -538,24 +538,25 @@ private void CompileNamedType(NamedTypeSymbol containingType)
 
                     case SymbolKind.Field:
                         {
-                            var field = (FieldSymbol)member;
-                            var fieldSymbol = (field.TupleUnderlyingField ?? field) as SourceMemberFieldSymbol;
-                            if ((object)fieldSymbol != null)
+                            var fieldSymbol = (FieldSymbol)member;
+                            if (member is TupleErrorFieldSymbol)
                             {
-                                if (fieldSymbol.IsConst)
-                                {
-                                    // We check specifically for constant fields with bad values because they never result
-                                    // in bound nodes being inserted into method bodies (in which case, they would be covered
-                                    // by the method-level check).
-                                    ConstantValue constantValue = fieldSymbol.GetConstantValue(ConstantFieldsInProgress.Empty, earlyDecodingWellKnownAttributes: false);
-                                    SetGlobalErrorIfTrue(constantValue == null || constantValue.IsBad);
-                                }
+                                break;
+                            }
 
-                                if (fieldSymbol.IsFixedSizeBuffer && compilationState.Emitting)
-                                {
-                                    // force the generation of implementation types for fixed-size buffers
-                                    TypeSymbol discarded = fieldSymbol.FixedImplementationType(compilationState.ModuleBuilderOpt);
-                                }
+                            if (fieldSymbol.IsConst)
+                            {
+                                // We check specifically for constant fields with bad values because they never result
+                                // in bound nodes being inserted into method bodies (in which case, they would be covered
+                                // by the method-level check).
+                                ConstantValue constantValue = fieldSymbol.GetConstantValue(ConstantFieldsInProgress.Empty, earlyDecodingWellKnownAttributes: false);
+                                SetGlobalErrorIfTrue(constantValue == null || constantValue.IsBad);
+                            }
+
+                            if (fieldSymbol.IsFixedSizeBuffer && compilationState.Emitting)
+                            {
+                                // force the generation of implementation types for fixed-size buffers
+                                TypeSymbol discarded = fieldSymbol.FixedImplementationType(compilationState.ModuleBuilderOpt);
                             }
                             break;
                         }

src/Compilers/CSharp/Portable/Emitter/Model/NamedTypeSymbolAdapter.cs

@@ -409,6 +409,7 @@ Cci.ITypeReference Cci.ITypeDefinition.GetBaseClass(EmitContext context)
             foreach (var f in AdaptedNamedTypeSymbol.GetFieldsToEmit())
             {
                 Debug.Assert((object)(f.TupleUnderlyingField ?? f) == f);
+                Debug.Assert(!(f is TupleErrorFieldSymbol));
                 if (isStruct || f.GetCciAdapter().ShouldInclude(context))
                 {
                     yield return f.GetCciAdapter();

src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs

@@ -275,12 +275,14 @@ private void ValidateReferencedAssembly(AssemblySymbol assembly, AssemblyReferen
                                         AddSymbolLocation(result, member);
                                         break;
                                     case SymbolKind.Field:
-                                        // NOTE: Dev11 does not add synthesized backing fields for properties,
-                                        //       but adds backing fields for events, Roslyn adds both
+                                        if (member is TupleErrorFieldSymbol)
                                         {
-                                            var field = (FieldSymbol)member;
-                                            AddSymbolLocation(result, field.TupleUnderlyingField ?? field);
+                                            break;
                                         }
+
+                                        // NOTE: Dev11 does not add synthesized backing fields for properties,
+                                        //       but adds backing fields for events, Roslyn adds both
+                                        AddSymbolLocation(result, member);
                                         break;
 
                                     case SymbolKind.Event:
@@ -290,7 +292,7 @@ private void ValidateReferencedAssembly(AssemblySymbol assembly, AssemblyReferen
                                             FieldSymbol field = ((EventSymbol)member).AssociatedField;
                                             if ((object)field != null)
                                             {
-                                                AddSymbolLocation(result, field.TupleUnderlyingField ?? field);
+                                                AddSymbolLocation(result, field);
                                             }
                                         }
                                         break;
@@ -1042,7 +1044,9 @@ internal Cci.IFieldReference Translate(
             bool needDeclaration = false)
         {
             Debug.Assert(fieldSymbol.IsDefinitionOrDistinct());
-            Debug.Assert(!fieldSymbol.IsVirtualTupleField && (object)(fieldSymbol.TupleUnderlyingField ?? fieldSymbol) == fieldSymbol, "tuple fields should be rewritten to underlying by now");
+            Debug.Assert(!fieldSymbol.IsVirtualTupleField &&
+                (object)(fieldSymbol.TupleUnderlyingField ?? fieldSymbol) == fieldSymbol &&
+                !(fieldSymbol is TupleErrorFieldSymbol), "tuple fields should be rewritten to underlying by now");
 
             if (!fieldSymbol.IsDefinition)
             {

src/Compilers/CSharp/Portable/FlowAnalysis/LocalDataFlowPass.cs

@@ -204,7 +204,7 @@ private int GetSlotDepth(int slot)
         /// </summary>
         private int DescendThroughTupleRestFields(ref Symbol symbol, int containingSlot, bool forceContainingSlotsToExist)
         {
-            if (symbol is TupleFieldSymbol fieldSymbol)
+            if (symbol is TupleElementFieldSymbol fieldSymbol)
             {
                 TypeSymbol containingType = symbol.ContainingType;
 

src/Compilers/CSharp/Portable/SymbolDisplay/SymbolDisplayVisitor.Types.cs

@@ -527,7 +527,7 @@ private void AddTupleTypeName(INamedTypeSymbol symbol)
                 }
 
                 VisitFieldType(element);
-                if (!element.IsImplicitlyDeclared)
+                if (element.IsExplicitlyNamedTupleElement)
                 {
                     AddSpace();
                     builder.Add(CreatePart(SymbolDisplayPartKind.FieldName, symbol, element.Name));

src/Compilers/CSharp/Portable/Symbols/Compilation_WellKnownMembers.cs

@@ -239,7 +239,7 @@ internal override ITypeSymbolInternal CommonGetWellKnownType(WellKnownType wellk
             return GetWellKnownType(wellknownType);
         }
 
-        internal static Symbol? GetRuntimeMember(NamedTypeSymbol declaringType, in MemberDescriptor descriptor, SignatureComparer<MethodSymbol, FieldSymbol, PropertySymbol, TypeSymbol, ParameterSymbol> comparer, AssemblySymbol accessWithinOpt)
+        internal static Symbol? GetRuntimeMember(NamedTypeSymbol declaringType, in MemberDescriptor descriptor, SignatureComparer<MethodSymbol, FieldSymbol, PropertySymbol, TypeSymbol, ParameterSymbol> comparer, AssemblySymbol? accessWithinOpt)
         {
             var members = declaringType.GetMembers(descriptor.Name);
             return GetRuntimeMember(members, descriptor, comparer, accessWithinOpt);

src/Compilers/CSharp/Portable/Symbols/FieldSymbol.cs

@@ -401,6 +401,16 @@ public virtual bool IsDefaultTupleElement
         {
             get
             {
+                Debug.Assert(!(this is TupleElementFieldSymbol) && !(this is TupleErrorFieldSymbol));
+                return TupleElementIndex >= 0;
+            }
+        }
+
+        public virtual bool IsExplicitlyNamedTupleElement
+        {
+            get
+            {
+                Debug.Assert(!(this is TupleElementFieldSymbol) && !(this is TupleErrorFieldSymbol));
                 return false;
             }
         }
@@ -414,6 +424,7 @@ public virtual FieldSymbol TupleUnderlyingField
         {
             get
             {
+                Debug.Assert(!(this is TupleElementFieldSymbol));
                 return ContainingType.IsTupleType ? this : null;
             }
         }
@@ -426,7 +437,8 @@ public virtual FieldSymbol CorrespondingTupleField
         {
             get
             {
-                return null;
+                Debug.Assert(!(this is TupleElementFieldSymbol));
+                return TupleElementIndex >= 0 ? this : null;
             }
         }
 
@@ -447,6 +459,18 @@ public virtual int TupleElementIndex
         {
             get
             {
+                // wrapped tuple fields already have this information and override this property
+                Debug.Assert(!(this is TupleElementFieldSymbol) && !(this is TupleErrorFieldSymbol));
+
+                if (ContainingType.IsTupleType)
+                {
+                    var map = ContainingType.TupleFieldDefinitionsToIndexMap;
+                    if (map is object && map.TryGetValue(this.OriginalDefinition, out int index))
+                    {
+                        return index;
+                    }
+                }
+
                 return -1;
             }
         }

src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.cs

@@ -889,7 +889,7 @@ internal override IEnumerable<FieldSymbol> GetFieldsToEmit()
             else
             {
                 // If there are any non-event fields, they are at the very beginning.
-                IEnumerable<FieldSymbol> nonEventFields = GetMembers<FieldSymbol>(this.GetMembers(), SymbolKind.Field, offset: 0).Select(f => f.TupleUnderlyingField ?? f);
+                IEnumerable<FieldSymbol> nonEventFields = GetMembers<FieldSymbol>(this.GetMembers().WhereAsArray(m => !(m is TupleErrorFieldSymbol)), SymbolKind.Field, offset: 0);
 
                 // Event backing fields are not part of the set returned by GetMembers. Let's add them manually.
                 ArrayBuilder<FieldSymbol> eventFields = null;
@@ -900,9 +900,6 @@ internal override IEnumerable<FieldSymbol> GetFieldsToEmit()
                     if ((object)associatedField != null)
                     {
                         Debug.Assert((object)associatedField.AssociatedSymbol != null);
-
-                        associatedField = associatedField.TupleUnderlyingField ?? associatedField;
-
                         Debug.Assert(!nonEventFields.Contains(associatedField));
 
                         if (eventFields == null)
@@ -1320,7 +1317,9 @@ private void LoadMembers()
 
                 if (IsTupleType)
                 {
+                    int originalCount = members.Count;
                     members = AddOrWrapTupleMembers(members.ToImmutableAndFree());
+                    membersCount += (members.Count - originalCount); // account for added tuple error fields
                     Debug.Assert(members is object);
                 }
 

src/Compilers/CSharp/Portable/Symbols/PublicModel/FieldSymbol.cs

@@ -67,6 +67,14 @@ IFieldSymbol IFieldSymbol.CorrespondingTupleField
             }
         }
 
+        bool IFieldSymbol.IsExplicitlyNamedTupleElement
+        {
+            get
+            {
+                return _underlying.IsExplicitlyNamedTupleElement;
+            }
+        }
+
         bool IFieldSymbol.IsConst => _underlying.IsConst;
 
         bool IFieldSymbol.IsReadOnly => _underlying.IsReadOnly;

src/Compilers/CSharp/Portable/Symbols/Retargeting/RetargetingNamedTypeSymbol.cs

@@ -122,17 +122,37 @@ public override IEnumerable<string> MemberNames
 
         public override ImmutableArray<Symbol> GetMembers()
         {
-            return this.RetargetingTranslator.Retarget(_underlyingType.GetMembers());
+            var result = this.RetargetingTranslator.Retarget(_underlyingType.GetMembers());
+            if (!this.IsTupleType)
+            {
+                return result;
+            }
+
+            // For ValueTuple definitions, we may have to re-insert tuple error fields
+            return this.AddOrWrapTupleMembers(result).ToImmutableAndFree();
         }
 
         internal override ImmutableArray<Symbol> GetMembersUnordered()
         {
-            return this.RetargetingTranslator.Retarget(_underlyingType.GetMembersUnordered());
+            var result = this.RetargetingTranslator.Retarget(_underlyingType.GetMembersUnordered());
+            if (!this.IsTupleType)
+            {
+                return result;
+            }
+
+            // For ValueTuple definitions, we may have to re-insert tuple error fields
+            return this.AddOrWrapTupleMembers(result).ToImmutableAndFree();
         }
 
         public override ImmutableArray<Symbol> GetMembers(string name)
         {
-            return this.RetargetingTranslator.Retarget(_underlyingType.GetMembers(name));
+            if (!this.IsTupleType)
+            {
+                return this.RetargetingTranslator.Retarget(_underlyingType.GetMembers(name));
+            }
+
+            // For ValueTuple definitions, we may have to re-insert tuple error fields
+            return GetMembers().WhereAsArray(m => m.Name == name);
         }
 
         internal override IEnumerable<FieldSymbol> GetFieldsToEmit()

src/Compilers/CSharp/Portable/Symbols/Retargeting/RetargetingSymbolTranslator.cs

@@ -805,7 +805,10 @@ public ImmutableArray<Symbol> Retarget(ImmutableArray<Symbol> arr)
 
                 foreach (var s in arr)
                 {
-                    symbols.Add(Retarget(s));
+                    if (!(s is TupleErrorFieldSymbol))
+                    {
+                        symbols.Add(Retarget(s));
+                    }
                 }
 
                 return symbols.ToImmutableAndFree();

src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs

@@ -1282,14 +1282,18 @@ internal override IEnumerable<FieldSymbol> GetFieldsToEmit()
                 switch (m.Kind)
                 {
                     case SymbolKind.Field:
-                        var field = (FieldSymbol)m;
-                        yield return field.TupleUnderlyingField ?? field;
+                        if (m is TupleErrorFieldSymbol)
+                        {
+                            break;
+                        }
+
+                        yield return (FieldSymbol)m;
                         break;
                     case SymbolKind.Event:
                         FieldSymbol? associatedField = ((EventSymbol)m).AssociatedField;
                         if ((object?)associatedField != null)
                         {
-                            yield return associatedField.TupleUnderlyingField ?? associatedField;
+                            yield return associatedField;
                         }
                         break;
                 }

src/Compilers/CSharp/Portable/Symbols/Source/SourceNamedTypeSymbol.cs

@@ -1292,24 +1292,12 @@ public sealed override bool AreLocalsZeroed
 
         private bool HasInstanceFields()
         {
-            var members = this.GetMembersUnordered();
-            for (var i = 0; i < members.Length; i++)
+            var fields = this.GetFieldsToEmit();
+            foreach (var field in fields)
             {
-                var m = members[i];
-                if (!m.IsStatic)
+                if (!field.IsStatic)
                 {
-                    switch (m.Kind)
-                    {
-                        case SymbolKind.Field:
-                            return true;
-
-                        case SymbolKind.Event:
-                            if (((EventSymbol)m).AssociatedField != null)
-                            {
-                                return true;
-                            }
-                            break;
-                    }
+                    return true;
                 }
             }
 

src/Compilers/CSharp/Portable/Symbols/Tuples/TupleErrorFieldSymbol.cs

@@ -87,6 +87,14 @@ public override bool IsDefaultTupleElement
             }
         }
 
+        public override bool IsExplicitlyNamedTupleElement
+        {
+            get
+            {
+                return _tupleElementIndex >= 0 && !_isImplicitlyDeclared;
+            }
+        }
+
         public override FieldSymbol TupleUnderlyingField
         {
             get