Synthesize record properties and ctor

src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs

@@ -1592,7 +1592,7 @@ private static bool AccessingAutoPropertyFromConstructor(BoundExpression receive
                 propertySymbol = propertySymbol.OriginalDefinition;
             }
 
-            var sourceProperty = propertySymbol as SourcePropertySymbol;
+            var sourceProperty = propertySymbol as SourceOrRecordPropertySymbol;
             var propertyIsStatic = propertySymbol.IsStatic;
 
             return (object)sourceProperty != null &&

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -5933,4 +5933,7 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_BadRecordDeclaration" xml:space="preserve">
     <value>Records must have both a 'data' modifier and parameter list</value>
   </data>
+  <data name="ERR_DuplicateRecordConstructor" xml:space="preserve">
+    <value>There cannot be a primary constructor and a member constructor with the same parameter types.</value>
+  </data>
 </root>

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

@@ -1741,6 +1741,16 @@ private static BoundBlock BindMethodBody(MethodSymbol method, TypeCompilationSta
                     return null;
                 }
             }
+            else if (method is SynthesizedInstanceConstructor ctor)
+            {
+                // Synthesized instance constructors may partially synthesize
+                // their body
+                var node = ctor.GetNonNullSyntaxNode();
+                var factory = new SyntheticBoundNodeFactory(ctor, node, compilationState, diagnostics);
+                var stmts = ArrayBuilder<BoundStatement>.GetInstance();
+                ctor.GenerateMethodBodyStatements(factory, stmts, diagnostics);
+                body = BoundBlock.SynthesizedNoLocals(node, stmts.ToImmutableAndFree());
+            }
             else
             {
                 // synthesized methods should return their bound bodies

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

@@ -1739,6 +1739,7 @@ internal enum ErrorCode
 
         ERR_ExternEventInitializer = 8760,
         ERR_BadRecordDeclaration = 8761,
+        ERR_DuplicateRecordConstructor = 8762,
 
         // Note: you will need to re-generate compiler code after adding warnings (eng\generate-compiler-code.cmd)
     }

src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/LambdaRewriter.cs

@@ -346,7 +346,7 @@ private void SynthesizeClosureEnvironments(ArrayBuilder<ClosureDebugInfo> closur
                         AddSynthesizedMethod(
                             frame.Constructor,
                             FlowAnalysisPass.AppendImplicitReturn(
-                                MethodCompiler.BindMethodBody(frame.Constructor, CompilationState, null),
+                                MethodCompiler.BindMethodBody(frame.Constructor, CompilationState, Diagnostics),
                                 frame.Constructor));
                     }
 
@@ -540,7 +540,7 @@ private SynthesizedClosureEnvironment GetStaticFrame(DiagnosticBag diagnostics,
                     AddSynthesizedMethod(
                         frame.Constructor,
                         FlowAnalysisPass.AppendImplicitReturn(
-                            MethodCompiler.BindMethodBody(frame.Constructor, CompilationState, null),
+                            MethodCompiler.BindMethodBody(frame.Constructor, CompilationState, diagnostics),
                             frame.Constructor));
 
                     // add cctor

src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_AssignmentOperator.cs

@@ -277,6 +277,8 @@ private BoundExpression MakeStaticAssignmentOperator(
             }
         }
 
+#nullable enable
+
         private BoundExpression MakePropertyAssignment(
             SyntaxNode syntax,
             BoundExpression rewrittenReceiver,
@@ -292,12 +294,13 @@ private BoundExpression MakePropertyAssignment(
             // Rewrite property assignment into call to setter.
             var setMethod = property.GetOwnOrInheritedSetMethod();
 
-            if ((object)setMethod == null)
+            if (setMethod is null)
             {
-                Debug.Assert((property as SourcePropertySymbol)?.IsAutoProperty == true,
+                var autoProp = (SourceOrRecordPropertySymbol)property;
+                Debug.Assert(autoProp.IsAutoProperty,
                     "only autoproperties can be assignable without having setters");
 
-                var backingField = (property as SourcePropertySymbol).BackingField;
+                var backingField = autoProp.BackingField;
                 return _factory.AssignmentExpression(
                     _factory.Field(rewrittenReceiver, backingField),
                     rewrittenRight);
@@ -323,7 +326,7 @@ private BoundExpression MakePropertyAssignment(
                 // Save expression value to a temporary before calling the
                 // setter, and restore the temporary after the setter, so the
                 // assignment can be used as an embedded expression.
-                TypeSymbol exprType = rewrittenRight.Type;
+                TypeSymbol? exprType = rewrittenRight.Type;
 
                 LocalSymbol rhsTemp = _factory.SynthesizedLocal(exprType);
 

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

@@ -446,8 +446,11 @@ public int GetHashCode(Symbol member)
 
                 // CONSIDER: modify hash for constraints?
 
-                hash = Hash.Combine(member.GetMemberArity(), hash);
-                hash = Hash.Combine(member.GetParameterCount(), hash);
+                if (member.Kind != SymbolKind.Field)
+                {
+                    hash = Hash.Combine(member.GetMemberArity(), hash);
+                    hash = Hash.Combine(member.GetParameterCount(), hash);
+                }
             }
             return hash;
         }

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

@@ -2323,6 +2323,7 @@ internal void AddOrWrapTupleMembers(SourceMemberContainerTypeSymbol type)
                 case TypeKind.Struct:
                     CheckForStructBadInitializers(builder, diagnostics);
                     CheckForStructDefaultConstructors(builder.NonTypeNonIndexerMembers, isEnum: false, diagnostics: diagnostics);
+                    AddSynthesizedRecordMembersIfNecessary(builder, diagnostics);
                     AddSynthesizedConstructorsIfNecessary(builder.NonTypeNonIndexerMembers, builder.StaticInitializers, diagnostics);
                     break;
 
@@ -2334,6 +2335,7 @@ internal void AddOrWrapTupleMembers(SourceMemberContainerTypeSymbol type)
                 case TypeKind.Class:
                 case TypeKind.Interface:
                 case TypeKind.Submission:
+                    AddSynthesizedRecordMembersIfNecessary(builder, diagnostics);
                     // No additional checking required.
                     AddSynthesizedConstructorsIfNecessary(builder.NonTypeNonIndexerMembers, builder.StaticInitializers, diagnostics);
                     break;
@@ -2846,9 +2848,19 @@ private void CheckForStructBadInitializers(MembersAndInitializersBuilder builder
             }
         }
 
-        private void AddSynthesizedRecordMembersIfNecessary(ArrayBuilder<Symbol> members, DiagnosticBag diagnostics)
+        private void AddSynthesizedRecordMembersIfNecessary(MembersAndInitializersBuilder builder, DiagnosticBag diagnostics)
         {
-            Debug.Assert(declaration.Kind == DeclarationKind.Class || declaration.Kind == DeclarationKind.Struct);
+            switch (declaration.Kind)
+            {
+                case DeclarationKind.Class:
+                case DeclarationKind.Struct:
+                    break;
+
+                default:
+                    return;
+            }
+
+            var members = builder.NonTypeNonIndexerMembers;
 
             ParameterListSyntax? paramList = null;
             foreach (SingleTypeDeclaration decl in declaration.Declarations)
@@ -2901,6 +2913,21 @@ private void AddSynthesizedRecordMembersIfNecessary(ArrayBuilder<Symbol> members
             {
                 members.Add(ctor);
             }
+            else
+            {
+                diagnostics.Add(ErrorCode.ERR_DuplicateRecordConstructor, paramList.Location);
+            }
+
+            foreach (ParameterSymbol param in ctor.Parameters)
+            {
+                var property = new SynthesizedRecordPropertySymbol(this, param);
+                if (!memberSignatures.Contains(property))
+                {
+                    members.Add(property);
+                    members.Add(property.GetMethod);
+                    members.Add(property.BackingField);
+                }
+            }
         }
 
         private void AddSynthesizedConstructorsIfNecessary(ArrayBuilder<Symbol> members, ArrayBuilder<ImmutableArray<FieldOrPropertyInitializer>> staticInitializers, DiagnosticBag diagnostics)
@@ -2909,7 +2936,6 @@ private void AddSynthesizedConstructorsIfNecessary(ArrayBuilder<Symbol> members,
             {
                 case DeclarationKind.Class:
                 case DeclarationKind.Struct:
-                    AddSynthesizedRecordMembersIfNecessary(members, diagnostics);
                     break;
             }
 

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

@@ -555,9 +555,9 @@ private void CheckMembersAgainstBaseType(
                                 }
                             }
                         }
-                        else
+                        else if (property is SourcePropertySymbol sourceProperty)
                         {
-                            var isNewProperty = ((SourcePropertySymbol)property).IsNew;
+                            var isNewProperty = sourceProperty.IsNew;
                             CheckNonOverrideMember(property, isNewProperty, property.OverriddenOrHiddenMembers, diagnostics, out suppressAccessors);
 
                             if (!suppressAccessors)

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

@@ -0,0 +1,36 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace Microsoft.CodeAnalysis.CSharp.Symbols
+{
+    internal abstract class SourceOrRecordPropertySymbol : PropertySymbol, IAttributeTargetSymbol
+    {
+        public Location Location { get; }
+
+        public SourceOrRecordPropertySymbol(Location location)
+        {
+            Location = location;
+        }
+
+        internal abstract SynthesizedBackingFieldSymbol BackingField { get; }
+
+        internal abstract bool IsAutoProperty { get; }
+
+        internal abstract bool HasPointerType { get; }
+
+        public abstract SyntaxList<AttributeListSyntax> AttributeDeclarationSyntaxList { get; }
+
+        protected abstract IAttributeTargetSymbol AttributesOwner { get; }
+
+        protected abstract AttributeLocation AllowedAttributeLocations { get; }
+
+        protected abstract AttributeLocation DefaultAttributeLocation { get; }
+
+        IAttributeTargetSymbol IAttributeTargetSymbol.AttributesOwner => AttributesOwner;
+
+        AttributeLocation IAttributeTargetSymbol.AllowedAttributeLocations => AllowedAttributeLocations;
+
+        AttributeLocation IAttributeTargetSymbol.DefaultAttributeLocation => DefaultAttributeLocation;
+    }
+}