Error for using positional member that is hidden

docs/compilers/CSharp/Compiler Breaking Changes - post DotNet 5.md

@@ -34,3 +34,17 @@
         return a ?? (b ? 1 : 2);
     }
     ```
+
+3. https://github.com/dotnet/roslyn/issues/52630 In C# 9 (.NET 5, Visual Studio 16.9), it is possible that a record uses a hidden member from a base type as a positional member. In Visual Studio 16.10, this is now an error:
+```csharp
+record Base
+{
+    public int I { get; init; }
+}
+record Derived(int I) // error: The positional member `Base.I` found corresponding to parameter `I` is hidden.
+    : Base
+{
+    public int I() { return 0; }
+}
+```
+

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -6606,4 +6606,7 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_InheritingFromRecordWithSealedToString" xml:space="preserve">
     <value>Inheriting from a record with a sealed 'Object.ToString' is not supported in C# {0}. Please use language version '{1}' or greater.</value>
   </data>
+  <data name="ERR_HiddenPositionalMember" xml:space="preserve">
+    <value>The positional member '{0}' found corresponding to this parameter is hidden.</value>
+  </data>
 </root>

src/Compilers/CSharp/Portable/Errors/ErrorCode.cs

@@ -1934,7 +1934,8 @@ internal enum ErrorCode
 
         #region diagnostics introduced for C# 10.0
 
-        ERR_InheritingFromRecordWithSealedToString = 8912
+        ERR_InheritingFromRecordWithSealedToString = 8912,
+        ERR_HiddenPositionalMember = 8913,
 
         #endregion
 

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

@@ -3497,7 +3497,7 @@ void addDeconstruct(SynthesizedRecordConstructor ctor, ImmutableArray<PropertySy
 
                 if (!memberSignatures.TryGetValue(targetMethod, out Symbol? existingDeconstructMethod))
                 {
-                    members.Add(new SynthesizedRecordDeconstruct(this, ctor, properties, memberOffset: members.Count, diagnostics));
+                    members.Add(new SynthesizedRecordDeconstruct(this, ctor, properties, paramList, memberOffset: members.Count, diagnostics));
                 }
                 else
                 {
@@ -3721,15 +3721,15 @@ ImmutableArray<PropertySymbol> addProperties(ImmutableArray<ParameterSymbol> rec
                     }
                     if (existingMember is null)
                     {
-                        addProperty(new SynthesizedRecordPropertySymbol(this, syntax, param, isOverride: false, diagnostics));
+                        addProperty(new SynthesizedRecordPropertySymbol(this, syntax, param, isOverride: false, diagnostics), param);
                     }
                     else if (existingMember is PropertySymbol { IsStatic: false, GetMethod: { } } prop
                         && prop.TypeWithAnnotations.Equals(param.TypeWithAnnotations, TypeCompareKind.AllIgnoreOptions))
                     {
                         // There already exists a member corresponding to the candidate synthesized property.
                         if (isInherited && prop.IsAbstract)
                         {
-                            addProperty(new SynthesizedRecordPropertySymbol(this, syntax, param, isOverride: true, diagnostics));
+                            addProperty(new SynthesizedRecordPropertySymbol(this, syntax, param, isOverride: true, diagnostics), param);
                         }
                         else
                         {
@@ -3745,23 +3745,23 @@ ImmutableArray<PropertySymbol> addProperties(ImmutableArray<ParameterSymbol> rec
                             param.TypeWithAnnotations,
                             param.Name);
                     }
-
-                    void addProperty(SynthesizedRecordPropertySymbol property)
-                    {
-                        existingOrAddedMembers.Add(property);
-                        members.Add(property);
-                        Debug.Assert(property.GetMethod is object);
-                        Debug.Assert(property.SetMethod is object);
-                        members.Add(property.GetMethod);
-                        members.Add(property.SetMethod);
-                        members.Add(property.BackingField);
-
-                        builder.AddInstanceInitializerForPositionalMembers(new FieldOrPropertyInitializer(property.BackingField, paramList.Parameters[param.Ordinal]));
-                        addedCount++;
-                    }
                 }
 
                 return existingOrAddedMembers.ToImmutableAndFree();
+
+                void addProperty(SynthesizedRecordPropertySymbol property, ParameterSymbol param)
+                {
+                    existingOrAddedMembers.Add(property);
+                    members.Add(property);
+                    Debug.Assert(property.GetMethod is object);
+                    Debug.Assert(property.SetMethod is object);
+                    members.Add(property.GetMethod);
+                    members.Add(property.SetMethod);
+                    members.Add(property.BackingField);
+
+                    builder.AddInstanceInitializerForPositionalMembers(new FieldOrPropertyInitializer(property.BackingField, paramList.Parameters[param.Ordinal]));
+                    addedCount++;
+                }
             }
 
             void addObjectEquals(MethodSymbol thisEquals)

src/Compilers/CSharp/Portable/Symbols/Synthesized/Records/SynthesizedRecordDeconstruct.cs

@@ -2,12 +2,10 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Linq;
-using System.Reflection;
-using Microsoft.Cci;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Roslyn.Utilities;
 
@@ -17,18 +15,22 @@ internal sealed class SynthesizedRecordDeconstruct : SynthesizedRecordOrdinaryMe
     {
         private readonly SynthesizedRecordConstructor _ctor;
         private readonly ImmutableArray<PropertySymbol> _properties;
+        private readonly ParameterListSyntax _parameters;
 
         public SynthesizedRecordDeconstruct(
             SourceMemberContainerTypeSymbol containingType,
             SynthesizedRecordConstructor ctor,
             ImmutableArray<PropertySymbol> properties,
+            ParameterListSyntax parameters,
             int memberOffset,
             BindingDiagnosticBag diagnostics)
             : base(containingType, WellKnownMemberNames.DeconstructMethodName, hasBody: true, memberOffset, diagnostics)
         {
             Debug.Assert(properties.All(prop => prop.GetMethod is object));
+            Debug.Assert(ctor.ParameterCount == parameters.ParameterCount);
             _ctor = ctor;
             _properties = properties;
+            _parameters = parameters;
         }
 
         protected override DeclarationModifiers MakeDeclarationModifiers(DeclarationModifiers allowedModifiers, BindingDiagnosticBag diagnostics)
@@ -59,6 +61,27 @@ protected override (TypeWithAnnotations ReturnType, ImmutableArray<ParameterSymb
 
         protected override int GetParameterCountFromSyntax() => _ctor.ParameterCount;
 
+        protected override void MethodChecks(BindingDiagnosticBag diagnostics)
+        {
+            base.MethodChecks(diagnostics);
+
+            if (ParameterCount == _properties.Length)
+            {
+                for (int i = 0; i < _properties.Length; i++)
+                {
+                    var property = _properties[i];
+                    NamedTypeSymbol containingType = this.ContainingType;
+
+                    if (property.ContainingType != (object)containingType &&
+                        !containingType.GetMembers(property.Name).IsEmpty)
+                    {
+                        // The positional member was inherited but is hidden by a member of the current record type
+                        diagnostics.Add(ErrorCode.ERR_HiddenPositionalMember, _parameters.Parameters[i].Identifier.GetLocation(), property);
+                    }
+                }
+            }
+        }
+
         internal override void GenerateMethodBody(TypeCompilationState compilationState, BindingDiagnosticBag diagnostics)
         {
             var F = new SyntheticBoundNodeFactory(this, ContainingType.GetNonNullSyntaxNode(), compilationState, diagnostics);