Use inherited properties for records

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

@@ -102,6 +102,7 @@ internal static int GetParameterCount(this Symbol member)
                 case SymbolKind.Property:
                     return ((PropertySymbol)member).ParameterCount;
                 case SymbolKind.Event:
+                case SymbolKind.Field:
                     return 0;
                 default:
                     throw ExceptionUtilities.UnexpectedValue(member.Kind);

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

@@ -2946,11 +2946,13 @@ private void AddSynthesizedRecordMembersIfNecessary(MembersAndInitializersBuilde
             BinderFactory binderFactory = this.DeclaringCompilation.GetBinderFactory(paramList.SyntaxTree);
             var binder = binderFactory.GetBinder(paramList);
 
-            // PROTOTYPE: need to check base members as well
             var memberSignatures = s_duplicateMemberSignatureDictionary.Allocate();
             foreach (var member in members)
             {
-                memberSignatures.Add(member, member);
+                if (!memberSignatures.ContainsKey(member))
+                {
+                    memberSignatures.Add(member, member);
+                }
             }
 
             var ctor = addCtor(paramList);
@@ -3000,25 +3002,58 @@ void addCloneMethod()
 
             void addProperties(ImmutableArray<ParameterSymbol> recordParameters)
             {
-                foreach (ParameterSymbol param in ctor.Parameters)
+                var inheritedProperties = PooledDictionary<string, PropertySymbol>.GetInstance();
+                HashSet<DiagnosticInfo>? useSiteDiagnostics = null;
+                addInheritedProperties(inheritedProperties, this, this, ref useSiteDiagnostics);
+                foreach (ParameterSymbol param in recordParameters)
                 {
                     var property = new SynthesizedRecordPropertySymbol(this, param, diagnostics);
-                    if (!memberSignatures.ContainsKey(property))
+                    if (!memberSignatures.ContainsKey(property) &&
+                        !(inheritedProperties.TryGetValue(property.Name, out var inheritedProperty) && matchesRecordProperty(inheritedProperty, param.TypeWithAnnotations)))
                     {
                         members.Add(property);
                         members.Add(property.GetMethod);
                         members.Add(property.SetMethod);
                         members.Add(property.BackingField);
                     }
                 }
+                inheritedProperties.Free();
+            }
+
+            static bool matchesRecordProperty(PropertySymbol property, TypeWithAnnotations requiredType)
+            {
+                Debug.Assert(property.ParameterCount == 0);
+
+                return !property.IsStatic &&
+                    property.RefKind == RefKind.None &&
+                    requiredType.Equals(property.TypeWithAnnotations, TypeCompareKind.AllIgnoreOptions);
+            }
+
+            static void addInheritedProperties(Dictionary<string, PropertySymbol> properties, NamedTypeSymbol within, NamedTypeSymbol type, ref HashSet<DiagnosticInfo>? useSiteDiagnostics)
+            {
+                type = type.BaseTypeNoUseSiteDiagnostics;
+                if (type is null)
+                {
+                    return;
+                }
+                addInheritedProperties(properties, within, type, ref useSiteDiagnostics);
+                foreach (var member in type.GetMembers())
+                {
+                    if (member is PropertySymbol property &&
+                        property.ParameterCount == 0 &&
+                        AccessCheck.IsSymbolAccessible(property, within, ref useSiteDiagnostics))
+                    {
+                        properties[property.Name] = property;
+                    }
+                }
             }
 
             void addObjectEquals(MethodSymbol thisEquals)
             {
                 var objEquals = new SynthesizedRecordObjEquals(this, thisEquals);
                 if (!memberSignatures.ContainsKey(objEquals))
                 {
-                    // PROTOTYPE: Don't add if the overridden method is sealed
+                    // https://github.com/dotnet/roslyn/issues/44617: Don't add if the overridden method is sealed
                     members.Add(objEquals);
                 }
             }
@@ -3028,7 +3063,7 @@ void addHashCode()
                 var hashCode = new SynthesizedRecordGetHashCode(this);
                 if (!memberSignatures.ContainsKey(hashCode))
                 {
-                    // PROTOTYPE: Don't add if the overridden method is sealed
+                    // https://github.com/dotnet/roslyn/issues/44617: Don't add if the overridden method is sealed
                     members.Add(hashCode);
                 }
             }

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

@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols

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

@@ -1,16 +1,14 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-
 #nullable enable
 
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Reflection;
 using Microsoft.Cci;
-using Microsoft.CodeAnalysis.PooledObjects;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
@@ -118,4 +116,4 @@ internal override void GenerateMethodBody(TypeCompilationState compilationState,
             F.CloseMethod(F.Return(F.Literal(0)));
         }
     }
-}
+}

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

@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
@@ -20,7 +20,6 @@ internal sealed class SynthesizedRecordObjEquals : SynthesizedInstanceMethodSymb
 
         public override ImmutableArray<ParameterSymbol> Parameters { get; }
 
-
         public SynthesizedRecordObjEquals(NamedTypeSymbol containingType, MethodSymbol typedRecordEquals)
         {
             _typedRecordEquals = typedRecordEquals;
@@ -152,4 +151,4 @@ internal override void GenerateMethodBody(TypeCompilationState compilationState,
             F.CloseMethod(F.Block(ImmutableArray.Create<BoundStatement>(F.Return(expression))));
         }
     }
-}
+}

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

@@ -2,17 +2,14 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-
 #nullable enable
 
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Reflection;
-using System.Text;
 using Microsoft.Cci;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {