Support struct records

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

@@ -1153,7 +1153,8 @@ private void CompileMethod(
                     // don't emit if the resulting method would contain initializers with errors
                     if (!hasErrors && (hasBody || includeInitializersInBody))
                     {
-                        Debug.Assert(!methodSymbol.IsImplicitInstanceConstructor || !methodSymbol.ContainingType.IsStructType());
+                        Debug.Assert(!(methodSymbol.IsImplicitInstanceConstructor && methodSymbol.ParameterCount == 0) ||
+                                     !methodSymbol.ContainingType.IsStructType());
 
                         // Fields must be initialized before constructor initializer (which is the first statement of the analyzed body, if specified),
                         // so that the initialization occurs before any method overridden by the declaring class can be invoked from the base constructor

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

@@ -44,14 +44,16 @@ public int Position
         public static readonly LexicalSortKey NotInitialized = new LexicalSortKey() { _treeOrdinal = -1, _position = -1 };
 
         // Put Record Equals right before synthesized constructors.
-        public static LexicalSortKey SynthesizedRecordEquals => new LexicalSortKey() { _treeOrdinal = int.MaxValue, _position = int.MaxValue - 3 };
-        public static LexicalSortKey SynthesizedRecordObjEquals => new LexicalSortKey() { _treeOrdinal = int.MaxValue, _position = int.MaxValue - 2 };
+        public static LexicalSortKey SynthesizedRecordEquals => new LexicalSortKey() { _treeOrdinal = int.MaxValue, _position = int.MaxValue - 4 };
+        public static LexicalSortKey SynthesizedRecordObjEquals => new LexicalSortKey() { _treeOrdinal = int.MaxValue, _position = int.MaxValue - 3 };
+
 
         // Dev12 compiler adds synthetic constructors to the child list after adding all other members.
         // Methods are emitted in the children order, but synthetic cctors would be deferred 
         // until later when it is known if they can be optimized or not.
         // As a result the last emitted method tokens are synthetic ctor and then synthetic cctor (if not optimized)
         // Since it is not too hard, we will try keeping the same order just to be easy on metadata diffing tools and such.
+        public static readonly LexicalSortKey SynthesizedRecordCtor = new LexicalSortKey() { _treeOrdinal = int.MaxValue, _position = int.MaxValue - 2 };
         public static readonly LexicalSortKey SynthesizedCtor = new LexicalSortKey() { _treeOrdinal = int.MaxValue, _position = int.MaxValue - 1 };
         public static readonly LexicalSortKey SynthesizedCCtor = new LexicalSortKey() { _treeOrdinal = int.MaxValue, _position = int.MaxValue };
 

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

@@ -143,6 +143,9 @@ public bool SetNullableContext(byte? value)
             }
         }
 
+        private static readonly ObjectPool<PooledDictionary<Symbol, Symbol>> s_duplicateMemberSignatureDictionary =
+            PooledDictionary<Symbol, Symbol>.CreatePool(MemberSignatureComparer.DuplicateSourceComparer);
+
         protected SymbolCompletionState state;
 
         private Flags _flags;
@@ -2922,20 +2925,26 @@ private void AddSynthesizedRecordMembersIfNecessary(MembersAndInitializersBuilde
             BinderFactory binderFactory = this.DeclaringCompilation.GetBinderFactory(paramList.SyntaxTree);
             var binder = binderFactory.GetBinder(paramList);
 
-            var memberSignatures = new HashSet<Symbol>(members, MemberSignatureComparer.DuplicateSourceComparer);
+            var memberSignatures = s_duplicateMemberSignatureDictionary.Allocate();
+            foreach (var member in members)
+            {
+                memberSignatures.Add(member, member);
+            }
 
             var ctor = addCtor(paramList);
             addProperties(ctor.Parameters);
-            addObjectEquals();
+            var thisEquals = addThisEquals();
+            addObjectEquals(thisEquals);
             addHashCode();
-            addThisEquals();
+
+            memberSignatures.Free();
 
             return;
 
             SynthesizedRecordConstructor addCtor(ParameterListSyntax paramList)
             {
                 var ctor = new SynthesizedRecordConstructor(this, binder, paramList, diagnostics);
-                if (!memberSignatures.Contains(ctor))
+                if (!memberSignatures.ContainsKey(ctor))
                 {
                     members.Add(ctor);
                 }
@@ -2952,7 +2961,7 @@ void addProperties(ImmutableArray<ParameterSymbol> recordParameters)
                 foreach (ParameterSymbol param in ctor.Parameters)
                 {
                     var property = new SynthesizedRecordPropertySymbol(this, param);
-                    if (!memberSignatures.Contains(property))
+                    if (!memberSignatures.ContainsKey(property))
                     {
                         members.Add(property);
                         members.Add(property.GetMethod);
@@ -2961,10 +2970,10 @@ void addProperties(ImmutableArray<ParameterSymbol> recordParameters)
                 }
             }
 
-            void addObjectEquals()
+            void addObjectEquals(MethodSymbol thisEquals)
             {
-                var objEquals = new SynthesizedRecordObjEquals(this);
-                if (!memberSignatures.Contains(objEquals))
+                var objEquals = new SynthesizedRecordObjEquals(this, thisEquals);
+                if (!memberSignatures.ContainsKey(objEquals))
                 {
                     // PROTOTYPE: Don't add if the overridden method is sealed
                     members.Add(objEquals);
@@ -2974,32 +2983,27 @@ void addObjectEquals()
             void addHashCode()
             {
                 var hashCode = new SynthesizedRecordGetHashCode(this);
-                if (!memberSignatures.Contains(hashCode))
+                if (!memberSignatures.ContainsKey(hashCode))
                 {
                     // PROTOTYPE: Don't add if the overridden method is sealed
                     members.Add(hashCode);
                 }
             }
 
-            void addThisEquals()
+            MethodSymbol addThisEquals()
             {
                 var thisEquals = new SynthesizedRecordEquals(this);
-                if (!memberSignatures.Contains(thisEquals))
+                if (!memberSignatures.TryGetValue(thisEquals, out var existing))
                 {
                     members.Add(thisEquals);
+                    return thisEquals;
                 }
+                return (MethodSymbol)existing;
             }
         }
 
         private void AddSynthesizedConstructorsIfNecessary(ArrayBuilder<Symbol> members, ArrayBuilder<ImmutableArray<FieldOrPropertyInitializer>> staticInitializers, DiagnosticBag diagnostics)
         {
-            switch (declaration.Kind)
-            {
-                case DeclarationKind.Class:
-                case DeclarationKind.Struct:
-                    break;
-            }
-
             //we're not calling the helpers on NamedTypeSymbol base, because those call
             //GetMembers and we're inside a GetMembers call ourselves (i.e. stack overflow)
             var hasInstanceConstructor = false;
@@ -3036,7 +3040,8 @@ private void AddSynthesizedConstructorsIfNecessary(ArrayBuilder<Symbol> members,
             // NOTE: Per section 11.3.8 of the spec, "every struct implicitly has a parameterless instance constructor".
             // We won't insert a parameterless constructor for a struct if there already is one.
             // We don't expect anything to be emitted, but it should be in the symbol table.
-            if ((!hasParameterlessInstanceConstructor && this.IsStructType()) || (!hasInstanceConstructor && !this.IsStatic && !this.IsInterface))
+            if ((!hasParameterlessInstanceConstructor && this.IsStructType()) ||
+                (!hasInstanceConstructor && !this.IsStatic && !this.IsInterface))
             {
                 members.Add((this.TypeKind == TypeKind.Submission) ?
                     new SynthesizedSubmissionConstructor(this, diagnostics) :

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

@@ -32,6 +32,13 @@ public SynthesizedRecordConstructor(
                 addRefReadOnlyModifier: false);
         }
 
+        internal override LexicalSortKey GetLexicalSortKey()
+        {
+            // We need a separate sort key because struct records will have two synthesized
+            // constructors: the record constructor, and the parameterless constructor
+            return LexicalSortKey.SynthesizedRecordCtor;
+        }
+
         internal override void GenerateMethodBodyStatements(SyntheticBoundNodeFactory F, ArrayBuilder<BoundStatement> statements, DiagnosticBag diagnostics)
         {
             // Write assignments to backing fields

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

@@ -22,6 +22,14 @@ internal sealed class SynthesizedRecordEquals : SynthesizedInstanceMethodSymbol
         public SynthesizedRecordEquals(NamedTypeSymbol containingType)
         {
             ContainingType = containingType;
+            if (containingType.IsStructType())
+            {
+                // If the record type is a struct, the parameter is marked 'in'
+                containingType.DeclaringCompilation.EnsureIsReadOnlyAttributeExists(
+                    diagnostics: null,
+                    location: Location.None,
+                    modifyCompilation: true);
+            }
         }
 
         public override string Name => "Equals";
@@ -152,7 +160,7 @@ internal override void GenerateMethodBody(TypeCompilationState compilationState,
                     other,
                     recordProperties,
                     F);
-                retExpr = F.LogicalAnd(retExpr, comparisons);
+                retExpr = retExpr is null ? comparisons : F.LogicalAnd(retExpr, comparisons);
             }
             recordProperties.Free();
 

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

@@ -14,12 +14,16 @@ namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
     internal sealed class SynthesizedRecordObjEquals : SynthesizedInstanceMethodSymbol
     {
+        private readonly MethodSymbol _typedRecordEquals;
+
         public override NamedTypeSymbol ContainingType { get; }
 
         public override ImmutableArray<ParameterSymbol> Parameters { get; }
 
-        public SynthesizedRecordObjEquals(NamedTypeSymbol containingType)
+
+        public SynthesizedRecordObjEquals(NamedTypeSymbol containingType, MethodSymbol typedRecordEquals)
         {
+            _typedRecordEquals = typedRecordEquals;
             ContainingType = containingType;
             Parameters = ImmutableArray.Create<ParameterSymbol>(SynthesizedParameterSymbol.Create(
                 this,
@@ -120,13 +124,32 @@ internal override void GenerateMethodBody(TypeCompilationState compilationState,
         {
             var F = new SyntheticBoundNodeFactory(this, ContainingType.GetNonNullSyntaxNode(), compilationState, diagnostics);
 
-            // return this.Equals(param as ContainingType);
-            var block = F.Block(ImmutableArray.Create<BoundStatement>(
-                F.Return(
-                    F.InstanceCall(F.This(), "Equals",
-                        F.As(F.Parameter(Parameters[0]), ContainingType)))));
-
-            F.CloseMethod(block);
+            var paramAccess = F.Parameter(Parameters[0]);
+
+            BoundExpression expression;
+            if (ContainingType.IsStructType())
+            {
+                // For structs:
+                //
+                //      return param is ContainingType i ? this.Equals(in i) : false;
+                expression = F.Conditional(
+                    F.Is(paramAccess, ContainingType),
+                    F.Call(
+                        F.This(),
+                        _typedRecordEquals,
+                        ImmutableArray.Create<RefKind>(RefKind.In),
+                        ImmutableArray.Create<BoundExpression>(F.Convert(ContainingType, paramAccess))),
+                    F.Literal(false),
+                    F.SpecialType(SpecialType.System_Boolean));
+            }
+            else
+            {
+                // For classes:
+                //      return this.Equals(param as ContainingType);
+                expression = F.InstanceCall(F.This(), "Equals", F.As(paramAccess, ContainingType));
+            }
+
+            F.CloseMethod(F.Block(ImmutableArray.Create<BoundStatement>(F.Return(expression))));
         }
     }
 }

src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedInstanceConstructor.cs

@@ -131,7 +131,7 @@ public sealed override ImmutableArray<TypeParameterSymbol> TypeParameters
             get { return ImmutableArray<TypeParameterSymbol>.Empty; }
         }
 
-        internal sealed override LexicalSortKey GetLexicalSortKey()
+        internal override LexicalSortKey GetLexicalSortKey()
         {
             //For the sake of matching the metadata output of the native compiler, make synthesized constructors appear last in the metadata.
             //This is not critical, but it makes it easier on tools that are comparing metadata.