Add support for init-only members

docs/contributing/Compiler Test Plan.md

@@ -32,7 +32,7 @@ This document provides guidance for thinking about language interactions and tes
 - Performance and stress testing
 
 # Type and members
-- Access modifiers (public, protected, internal, protected internal, private protected, private), static, ref
+- Access modifiers (public, protected, internal, protected internal, private protected, private), static, ref, init
     - types
     - methods
     - fields

src/Compilers/CSharp/CSharpAnalyzerDriver/CSharpDeclarationComputer.cs

@@ -210,8 +210,9 @@ private static void ComputeDeclarations(
 
                 case SyntaxKind.AddAccessorDeclaration:
                 case SyntaxKind.RemoveAccessorDeclaration:
-                case SyntaxKind.SetAccessorDeclaration:
                 case SyntaxKind.GetAccessorDeclaration:
+                case SyntaxKind.SetAccessorDeclaration:
+                case SyntaxKind.InitAccessorDeclaration:
                     {
                         var t = (AccessorDeclarationSyntax)node;
                         var blocks = ArrayBuilder<SyntaxNode>.GetInstance();

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

@@ -709,7 +709,8 @@ private bool CheckFieldValueKind(SyntaxNode node, BoundFieldAccess fieldAccess,
                         {
                             MethodSymbol containingMethod = (MethodSymbol)containing;
                             MethodKind desiredMethodKind = fieldIsStatic ? MethodKind.StaticConstructor : MethodKind.Constructor;
-                            canModifyReadonly = containingMethod.MethodKind == desiredMethodKind;
+                            canModifyReadonly = (containingMethod.MethodKind == desiredMethodKind) ||
+                                isAssignedFromInitOnlySetterOnThis(fieldAccess.ReceiverOpt);
                         }
                         else if (containing.Kind == SymbolKind.Field)
                         {
@@ -745,6 +746,24 @@ private bool CheckFieldValueKind(SyntaxNode node, BoundFieldAccess fieldAccess,
 
             // for other fields defer to the receiver.
             return CheckIsValidReceiverForVariable(node, fieldAccess.ReceiverOpt, valueKind, diagnostics);
+
+            bool isAssignedFromInitOnlySetterOnThis(BoundExpression receiver)
+            {
+                // bad: other.readonlyField = ...
+                // bad: base.readonlyField = ...
+                if (!(receiver is BoundThisReference))
+                {
+                    return false;
+                }
+
+                var containingMember = ContainingMemberOrLambda;
+                if (!(containingMember is MethodSymbol method))
+                {
+                    return false;
+                }
+
+                return method.MethodKind == MethodKind.PropertySet && method.IsInitOnly;
+            }
         }
 
         private bool CheckSimpleAssignmentValueKind(SyntaxNode node, BoundAssignmentOperator assignment, BindValueKind valueKind, DiagnosticBag diagnostics)
@@ -931,9 +950,7 @@ private bool CheckPropertyValueKind(SyntaxNode node, BoundExpression expr, BindV
 
             // Addendum: Assignment is also allowed for get-only autoprops in their constructor
 
-            BoundExpression receiver;
-            SyntaxNode propertySyntax;
-            var propertySymbol = GetPropertySymbol(expr, out receiver, out propertySyntax);
+            var propertySymbol = GetPropertySymbol(expr, out BoundExpression receiver, out SyntaxNode propertySyntax);
 
             Debug.Assert((object)propertySymbol != null);
             Debug.Assert(propertySyntax != null);
@@ -970,7 +987,7 @@ private bool CheckPropertyValueKind(SyntaxNode node, BoundExpression expr, BindV
             {
                 var setMethod = propertySymbol.GetOwnOrInheritedSetMethod();
 
-                if ((object)setMethod == null)
+                if (setMethod is null)
                 {
                     var containing = this.ContainingMemberOrLambda;
                     if (!AccessingAutoPropertyFromConstructor(receiver, propertySymbol, containing))
@@ -981,6 +998,13 @@ private bool CheckPropertyValueKind(SyntaxNode node, BoundExpression expr, BindV
                 }
                 else
                 {
+                    if (setMethod.IsInitOnly &&
+                        !isAllowedInitOnlySet(receiver))
+                    {
+                        Error(diagnostics, ErrorCode.ERR_AssignmentInitOnly, node, propertySymbol);
+                        return false;
+                    }
+
                     var accessThroughType = this.GetAccessThroughType(receiver);
                     bool failedThroughTypeCheck;
                     HashSet<DiagnosticInfo> useSiteDiagnostics = null;
@@ -1069,6 +1093,36 @@ private bool CheckPropertyValueKind(SyntaxNode node, BoundExpression expr, BindV
             }
 
             return true;
+
+            bool isAllowedInitOnlySet(BoundExpression receiver)
+            {
+                // ok: new C() { InitOnlyProperty = ... }
+                if (receiver is BoundObjectOrCollectionValuePlaceholder)
+                {
+                    return true;
+                }
+
+                // bad: other.InitOnlyProperty = ...
+                if (!(receiver is BoundThisReference || receiver is BoundBaseReference))
+                {
+                    return false;
+                }
+
+                var containingMember = ContainingMemberOrLambda;
+                if (!(containingMember is MethodSymbol method))
+                {
+                    return false;
+                }
+
+                bool isInitOnlySetter = method.MethodKind == MethodKind.PropertySet && method.IsInitOnly;
+                if (method.IsConstructor() || isInitOnlySetter)
+                {
+                    // ok: setting on `this` or `base` from a constructor or init-only setter
+                    return true;
+                }
+
+                return false;
+            }
         }
 
         private bool IsBadBaseAccess(SyntaxNode node, BoundExpression receiverOpt, Symbol member, DiagnosticBag diagnostics,

src/Compilers/CSharp/Portable/Binder/BinderFactory.BinderFactoryVisitor.cs

@@ -252,7 +252,7 @@ public override Binder VisitAccessorDeclaration(AccessorDeclarationSyntax parent
                                     var propertySymbol = GetPropertySymbol((BasePropertyDeclarationSyntax)propertyOrEventDecl, resultBinder);
                                     if ((object)propertySymbol != null)
                                     {
-                                        accessor = (parent.Kind() == SyntaxKind.SetAccessorDeclaration) ? propertySymbol.SetMethod : propertySymbol.GetMethod;
+                                        accessor = (parent.Kind() == SyntaxKind.GetAccessorDeclaration) ? propertySymbol.GetMethod : propertySymbol.SetMethod;
                                     }
                                     break;
                                 }

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

@@ -743,6 +743,7 @@ private static ImmutableArray<Symbol> PerformCrefOverloadResolution(ArrayBuilder
                                 containingType: null,
                                 name: null,
                                 refKind: RefKind.None,
+                                isInitOnly: false,
                                 returnType: default,
                                 refCustomModifiers: ImmutableArray<CustomModifier>.Empty,
                                 explicitInterfaceImplementations: ImmutableArray<MethodSymbol>.Empty);

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

@@ -1442,9 +1442,18 @@ internal static bool ReportUseSiteDiagnostics(Symbol symbol, DiagnosticBag diagn
         /// </summary>
         internal NamedTypeSymbol GetWellKnownType(WellKnownType type, DiagnosticBag diagnostics, SyntaxNode node)
         {
-            NamedTypeSymbol typeSymbol = this.Compilation.GetWellKnownType(type);
+            return GetWellKnownType(this.Compilation, type, diagnostics, node.Location);
+        }
+
+        /// <summary>
+        /// This is a layer on top of the Compilation version that generates a diagnostic if the well-known
+        /// type isn't found.
+        /// </summary>
+        internal static NamedTypeSymbol GetWellKnownType(CSharpCompilation compilation, WellKnownType type, DiagnosticBag diagnostics, Location location)
+        {
+            NamedTypeSymbol typeSymbol = compilation.GetWellKnownType(type);
             Debug.Assert((object)typeSymbol != null, "Expect an error type if well-known type isn't found");
-            ReportUseSiteDiagnostics(typeSymbol, diagnostics, node);
+            ReportUseSiteDiagnostics(typeSymbol, diagnostics, location);
             return typeSymbol;
         }
 

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -630,6 +630,9 @@
   <data name="ERR_BadMemberFlag" xml:space="preserve">
     <value>The modifier '{0}' is not valid for this item</value>
   </data>
+  <data name="ERR_BadInitAccessor" xml:space="preserve">
+    <value>The 'init' accessor is not valid on static members</value>
+  </data>
   <data name="ERR_BadMemberProtection" xml:space="preserve">
     <value>More than one protection modifier</value>
   </data>
@@ -1592,6 +1595,9 @@ If such a class is used as a base class and if the deriving class defines a dest
   <data name="ERR_ExplicitPropertyAddingAccessor" xml:space="preserve">
     <value>'{0}' adds an accessor not found in interface member '{1}'</value>
   </data>
+  <data name="ERR_ExplicitPropertyMismatchInitOnly" xml:space="preserve">
+    <value>Accessors '{0}' and '{1}' should both be init-only or neither</value>
+  </data>
   <data name="ERR_ExplicitPropertyMissingAccessor" xml:space="preserve">
     <value>Explicit interface implementation '{0}' is missing accessor '{1}'</value>
   </data>
@@ -2891,7 +2897,7 @@ A catch() block after a catch (System.Exception e) block can catch non-CLS excep
     <value>Members of readonly field '{0}' cannot be used as a ref or out value (except in a constructor)</value>
   </data>
   <data name="ERR_AssgReadonly" xml:space="preserve">
-    <value>A readonly field cannot be assigned to (except in a constructor of the class in which the field is defined or a variable initializer))</value>
+    <value>A readonly field cannot be assigned to (except in a constructor or init-only setter of the class in which the field is defined or a variable initializer))</value>
   </data>
   <data name="ERR_AssgReadonly2" xml:space="preserve">
     <value>Members of readonly field '{0}' cannot be modified (except in a constructor or a variable initializer)</value>
@@ -4918,6 +4924,9 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_CantChangeRefReturnOnOverride" xml:space="preserve">
     <value>'{0}' must match by reference return of overridden member '{1}'</value>
   </data>
+  <data name="ERR_CantChangeInitOnlyOnOverride" xml:space="preserve">
+    <value>'{0}' must match by init-only of overridden member '{1}'</value>
+  </data>
   <data name="ERR_MustNotHaveRefReturn" xml:space="preserve">
     <value>By-reference returns may only be used in methods that return by reference</value>
   </data>
@@ -4930,6 +4939,9 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_CloseUnimplementedInterfaceMemberWrongRefReturn" xml:space="preserve">
     <value>'{0}' does not implement interface member '{1}'. '{2}' cannot implement '{1}' because it does not have matching return by reference.</value>
   </data>
+  <data name="ERR_CloseUnimplementedInterfaceMemberWrongInitOnly" xml:space="preserve">
+    <value>'{0}' does not implement interface member '{1}'. '{2}' cannot implement '{1}' because it does not match by init-only.</value>
+  </data>
   <data name="ERR_BadIteratorReturnRef" xml:space="preserve">
     <value>The body of '{0}' cannot be an iterator block because '{0}' returns by reference</value>
   </data>
@@ -6049,6 +6061,9 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="IDS_FeatureRecords" xml:space="preserve">
     <value>records</value>
   </data>
+  <data name="IDS_FeatureInitOnlySetters" xml:space="preserve">
+    <value>init-only setters</value>
+  </data>
   <data name="ERR_BadRecordDeclaration" xml:space="preserve">
     <value>Records must have both a 'data' modifier and non-empty parameter list</value>
   </data>
@@ -6067,4 +6082,7 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="WRN_GeneratorFailedDuringInitialization_Title" xml:space="preserve">
     <value>Generator failed to initialize.</value>
   </data>
+  <data name="ERR_AssignmentInitOnly" xml:space="preserve">
+    <value>Init-only member '{0}' can only be assigned from a constructor, object initialization or 'with' expression of that type.</value>
+  </data>
 </root>

src/Compilers/CSharp/Portable/Compilation/MemberSemanticModel.cs

@@ -2098,6 +2098,7 @@ internal protected virtual CSharpSyntaxNode GetBindableSyntaxNode(CSharpSyntaxNo
             {
                 case SyntaxKind.GetAccessorDeclaration:
                 case SyntaxKind.SetAccessorDeclaration:
+                case SyntaxKind.InitAccessorDeclaration:
                 case SyntaxKind.AddAccessorDeclaration:
                 case SyntaxKind.RemoveAccessorDeclaration:
                 case SyntaxKind.MethodDeclaration:

src/Compilers/CSharp/Portable/Compilation/MethodBodySemanticModel.cs

@@ -91,6 +91,7 @@ internal override BoundNode Bind(Binder binder, CSharpSyntaxNode node, Diagnosti
                 case SyntaxKind.DestructorDeclaration:
                 case SyntaxKind.GetAccessorDeclaration:
                 case SyntaxKind.SetAccessorDeclaration:
+                case SyntaxKind.InitAccessorDeclaration:
                 case SyntaxKind.AddAccessorDeclaration:
                 case SyntaxKind.RemoveAccessorDeclaration:
                     return binder.BindMethodBody(node, diagnostics);

src/Compilers/CSharp/Portable/Compilation/SyntaxTreeSemanticModel.cs

@@ -763,6 +763,7 @@ private MemberSemanticModel GetMemberModel(int position)
                     case SyntaxKind.RemoveAccessorDeclaration:
                     case SyntaxKind.GetAccessorDeclaration:
                     case SyntaxKind.SetAccessorDeclaration:
+                    case SyntaxKind.InitAccessorDeclaration:
                         // NOTE: not UnknownAccessorDeclaration since there's no corresponding method symbol from which to build a member model.
                         outsideMemberDecl = !LookupPosition.IsInBody(position, (AccessorDeclarationSyntax)memberDecl);
                         break;
@@ -836,6 +837,7 @@ internal override MemberSemanticModel GetMemberModel(SyntaxNode node)
 
                     case SyntaxKind.GetAccessorDeclaration:
                     case SyntaxKind.SetAccessorDeclaration:
+                    case SyntaxKind.InitAccessorDeclaration:
                     case SyntaxKind.AddAccessorDeclaration:
                     case SyntaxKind.RemoveAccessorDeclaration:
                         // NOTE: not UnknownAccessorDeclaration since there's no corresponding method symbol from which to build a member model.
@@ -1034,6 +1036,7 @@ private MemberSemanticModel CreateMemberModel(CSharpSyntaxNode node)
                     }
                 case SyntaxKind.GetAccessorDeclaration:
                 case SyntaxKind.SetAccessorDeclaration:
+                case SyntaxKind.InitAccessorDeclaration:
                 case SyntaxKind.AddAccessorDeclaration:
                 case SyntaxKind.RemoveAccessorDeclaration:
                     {

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

@@ -1775,6 +1775,11 @@ internal enum ErrorCode
 
         ERR_BadRecordDeclaration = 8800,
         ERR_DuplicateRecordConstructor = 8801,
+        ERR_AssignmentInitOnly = 8802,
+        ERR_CantChangeInitOnlyOnOverride = 8803,
+        ERR_CloseUnimplementedInterfaceMemberWrongInitOnly = 8804,
+        ERR_ExplicitPropertyMismatchInitOnly = 8805,
+        ERR_BadInitAccessor = 8806,
 
         // Note: you will need to re-generate compiler code after adding warnings (eng\generate-compiler-code.cmd)
     }

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

@@ -191,8 +191,9 @@ internal enum MessageID
         IDS_FeatureExternLocalFunctions = MessageBase + 12767,
         IDS_FeatureMemberNotNull = MessageBase + 12768,
 
-        IDS_FeatureRecords = MessageBase + 12770,
         IDS_FeatureNativeInt = MessageBase + 12769,
+        IDS_FeatureRecords = MessageBase + 12770,
+        IDS_FeatureInitOnlySetters = MessageBase + 12771,
     }
 
     // Message IDs may refer to strings that need to be localized.
@@ -306,6 +307,7 @@ internal static LanguageVersion RequiredVersion(this MessageID feature)
                 case MessageID.IDS_FeatureMemberNotNull:
                 case MessageID.IDS_FeatureRecords:
                 case MessageID.IDS_FeatureNativeInt:
+                case MessageID.IDS_FeatureInitOnlySetters: // semantic check
                     return LanguageVersion.Preview;
 
                 // C# 8.0 features.