[semi-auto-props]: Support assigning properties from constructor

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

@@ -1703,18 +1703,15 @@ private static bool IsPropertyAssignedThroughBackingField(BoundExpression receiv
                 propertySymbol = propertySymbol.OriginalDefinition;
             }
 
-            // PROTOTYPE(semi-auto-props): TODO: Support assigning semi auto prop from constructors.
-
             return propertySymbol is SourcePropertySymbolBase sourceProperty &&
-                    // PROTOTYPE(semi-auto-props): Consider `public int P { get => field; set; }`
-                    sourceProperty.GetMethod is SourcePropertyAccessorSymbol { IsEquivalentToBackingFieldAccess: true } &&
+                    IsConstructorOrField(fromMember, isStatic: sourceProperty.IsStatic) &&
+                    TypeSymbol.Equals(sourceProperty.ContainingType, fromMember.ContainingType, TypeCompareKind.ConsiderEverything2) &&
+                    (sourceProperty.IsStatic || receiver.Kind == BoundKind.ThisReference) &&
                     // To be assigned through backing field, either SetMethod is null, or it's equivalent to backing field write
                     // PROTOTYPE(semi-auto-props): TODO: Do we need to use `GetOwnOrInheritedSetMethod` instead of `SetMethod`?
                     // Legacy auto-properties are required to override all accessors. If this is not the case with semi auto props, we may need to use GetOwnOrInheritedSetMethod
                     sourceProperty.SetMethod is null or SourcePropertyAccessorSymbol { IsEquivalentToBackingFieldAccess: true } &&
-                    TypeSymbol.Equals(sourceProperty.ContainingType, fromMember.ContainingType, TypeCompareKind.ConsiderEverything2) &&
-                    IsConstructorOrField(fromMember, isStatic: sourceProperty.IsStatic) &&
-                    (sourceProperty.IsStatic || receiver.Kind == BoundKind.ThisReference);
+                    (sourceProperty.GetMethod is SourcePropertyAccessorSymbol { IsEquivalentToBackingFieldAccess: true } || sourceProperty.FieldKeywordBackingField is not null);
         }
 
         private static bool IsConstructorOrField(Symbol member, bool isStatic)

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

@@ -2581,7 +2581,19 @@ internal DiagnosticBag AdditionalCodegenWarnings
             }
         }
 
+        /// <summary>
+        /// A bag in which circular struct diagnostics should be reported.
+        /// </summary>
+        internal BindingDiagnosticBag CircularStructDiagnostics
+        {
+            get
+            {
+                return _circularStructDiagnostics;
+            }
+        }
+
         private readonly DiagnosticBag _additionalCodegenWarnings = new DiagnosticBag();
+        private readonly BindingDiagnosticBag _circularStructDiagnostics = new BindingDiagnosticBag();
 
         internal DeclarationTable Declarations
         {

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

@@ -202,6 +202,9 @@ public static void CompileMethodBodies(
                     new LocalizableResourceString(messageResourceName, CodeAnalysisResources.ResourceManager, typeof(CodeAnalysisResources)));
             }
 
+            addCircularStructDiagnostics(compilation.SourceModule.GlobalNamespace);
+            methodCompiler.WaitForWorkers();
+            diagnostics.AddRange(compilation.CircularStructDiagnostics);
             diagnostics.AddRange(compilation.AdditionalCodegenWarnings);
 
             // we can get unused field warnings only if compiling whole compilation.
@@ -214,6 +217,45 @@ public static void CompileMethodBodies(
                     moduleBeingBuiltOpt.SetPEEntryPoint(entryPoint, diagnostics.DiagnosticBag);
                 }
             }
+
+            void addCircularStructDiagnostics(NamespaceOrTypeSymbol symbol)
+            {
+                if (symbol is SourceMemberContainerTypeSymbol sourceMemberContainerTypeSymbol && PassesFilter(filterOpt, symbol))
+                {
+                    _ = sourceMemberContainerTypeSymbol.KnownCircularStruct;
+                }
+
+                foreach (var member in symbol.GetMembersUnordered())
+                {
+                    if (member is NamespaceOrTypeSymbol namespaceOrTypeSymbol)
+                    {
+                        if (compilation.Options.ConcurrentBuild)
+                        {
+                            Task worker = addCircularStructDiagnosticsAsAsync(namespaceOrTypeSymbol);
+                            methodCompiler._compilerTasks.Push(worker);
+                        }
+                        else
+                        {
+                            addCircularStructDiagnostics(namespaceOrTypeSymbol);
+                        }
+                    }
+                }
+            }
+
+            Task addCircularStructDiagnosticsAsAsync(NamespaceOrTypeSymbol symbol)
+            {
+                return Task.Run(UICultureUtilities.WithCurrentUICulture(() =>
+                {
+                    try
+                    {
+                        addCircularStructDiagnostics(symbol);
+                    }
+                    catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e))
+                    {
+                        throw ExceptionUtilities.Unreachable;
+                    }
+                }), methodCompiler._cancellationToken);
+            }
         }
 
         // Returns the MethodSymbol for the assembly entrypoint.  If the user has a Task returning main,
@@ -471,6 +513,43 @@ private void CompileNamedType(NamedTypeSymbol containingType)
             }
 
             var members = containingType.GetMembers();
+
+            // We first compile the accessors that contain 'field' keyword to avoid extra bindings for 'field' keyword when compiling other members.
+            for (int memberOrdinal = 0; memberOrdinal < members.Length; memberOrdinal++)
+            {
+                var member = members[memberOrdinal];
+
+                //When a filter is supplied, limit the compilation of members passing the filter.
+                if (member is not SourcePropertyAccessorSymbol { ContainsFieldKeyword: true } accessor ||
+                    !PassesFilter(_filterOpt, member))
+                {
+                    continue;
+                }
+
+                Debug.Assert(member.Kind == SymbolKind.Method);
+                Binder.ProcessedFieldInitializers processedInitializers = default;
+                CompileMethod(accessor, memberOrdinal, ref processedInitializers, synthesizedSubmissionFields, compilationState);
+            }
+
+            // After compiling accessors containing 'field' keyword, we mark the backing field of the corresponding property as calculated.
+            foreach (var member in members)
+            {
+                if (member is SourcePropertySymbolBase property)
+                {
+                    // PROTOTYPE(semi-auto-props): This can be optimized by checking for field keyword syntactically first.
+                    // If we don't have field keyword, we can safely ignore the filter check.
+                    // This will require more tests.
+                    var getMethod = property.GetMethod;
+                    var setMethod = property.SetMethod;
+                    if ((getMethod is null || PassesFilter(_filterOpt, getMethod)) &&
+                        (setMethod is null || PassesFilter(_filterOpt, setMethod)))
+                    {
+                        property.MarkBackingFieldAsCalculated();
+                    }
+                }
+            }
+
+            // Then we compile everything, excluding the accessors that contain field keyword we already compiled in the loop above.
             for (int memberOrdinal = 0; memberOrdinal < members.Length; memberOrdinal++)
             {
                 var member = members[memberOrdinal];
@@ -490,6 +569,22 @@ private void CompileNamedType(NamedTypeSymbol containingType)
                     case SymbolKind.Method:
                         {
                             MethodSymbol method = (MethodSymbol)member;
+                            if (method.MethodKind is MethodKind.PropertyGet or MethodKind.PropertySet)
+                            {
+                                // The loop for compiling accessors was written with these valid assumptions.
+                                // If this requirement has changed, the loop above may need to be modified (e.g, if partial accessors was allowed in future)
+                                Debug.Assert(!method.IsScriptConstructor);
+                                Debug.Assert((object)method != scriptEntryPoint);
+                                Debug.Assert(!IsFieldLikeEventAccessor(method));
+                                Debug.Assert(!method.IsPartialDefinition());
+                            }
+
+                            if (member is SourcePropertyAccessorSymbol { ContainsFieldKeyword: true })
+                            {
+                                // We already compiled these accessors in the loop above.
+                                continue;
+                            }
+
                             if (method.IsScriptConstructor)
                             {
                                 Debug.Assert(scriptCtorOrdinal == -1);
@@ -574,23 +669,6 @@ private void CompileNamedType(NamedTypeSymbol containingType)
                 }
             }
 
-            foreach (var member in members)
-            {
-                if (member is SourcePropertySymbolBase property)
-                {
-                    // PROTOTYPE(semi-auto-props): This can be optimized by checking for field keyword syntactically first.
-                    // If we don't have field keyword, we can safely ignore the filter check.
-                    // This will require more tests.
-                    var getMethod = property.GetMethod;
-                    var setMethod = property.SetMethod;
-                    if ((getMethod is null || PassesFilter(_filterOpt, getMethod)) &&
-                        (setMethod is null || PassesFilter(_filterOpt, setMethod)))
-                    {
-                        property.MarkBackingFieldAsCalculated();
-                    }
-                }
-            }
-
             Debug.Assert(containingType.IsScriptClass == (scriptCtorOrdinal >= 0));
 
             // process additional anonymous type members

src/Compilers/CSharp/Portable/FlowAnalysis/AbstractFlowPass.cs

@@ -571,7 +571,8 @@ protected void VisitLvalue(BoundExpression node)
 
                     if (Binder.IsPropertyAssignedThroughBackingField(access, _symbol))
                     {
-                        var backingField = (access.PropertySymbol as SourcePropertySymbolBase)?.BackingField;
+                        var property = access.PropertySymbol as SourcePropertySymbolBase;
+                        var backingField = property?.BackingField ?? property?.FieldKeywordBackingField;
                         if (backingField != null)
                         {
                             VisitFieldAccessInternal(access.ReceiverOpt, backingField);

src/Compilers/CSharp/Portable/FlowAnalysis/DefiniteAssignment.cs

@@ -1038,14 +1038,13 @@ protected override bool TryGetReceiverAndMember(BoundExpression expr, out BoundE
                 case BoundKind.PropertyAccess:
                     {
                         var propAccess = (BoundPropertyAccess)expr;
-
                         // PROTOTYPE(semi-auto-props): The call to IsPropertyAssignedThroughBackingField isn't sensible.
                         // We get here for both property read and write.
                         // This applies to ALL IsPropertyAssignedThroughBackingField calls in this file.
                         if (Binder.IsPropertyAssignedThroughBackingField(propAccess, this.CurrentSymbol)) // PROTOTYPE(semi-auto-props): Revise this method call is the behavior we want and add unit tests..
                         {
-                            var propSymbol = propAccess.PropertySymbol;
-                            member = (propSymbol as SourcePropertySymbolBase)?.BackingField;
+                            var propSymbol = propAccess.PropertySymbol as SourcePropertySymbolBase;
+                            member = propSymbol?.BackingField ?? propSymbol?.FieldKeywordBackingField;
                             if (member is null)
                             {
                                 return false;

src/Compilers/CSharp/Portable/FlowAnalysis/EmptyStructTypeCache.cs

@@ -215,12 +215,15 @@ private FieldSymbol GetActualField(Symbol member, NamedTypeSymbol type)
                     return (!eventSymbol.HasAssociatedField || ShouldIgnoreStructField(eventSymbol, eventSymbol.Type)) ? null : eventSymbol.AssociatedField.AsMember(type);
                 case SymbolKind.Property:
                     // PROTOTYPE(semi-auto-props): Review other event associated field callers and see if we have to do anything special for properties.
+
                     // Backing field for semi auto props are not included in GetMembers.
-                    // PROTOTYPE(semi-auto-props): This condition is always false after modifiying BackingField implementation. Figure out a
-                    // test that needs this.
-                    if (member is SourcePropertySymbol { BackingField: SynthesizedBackingFieldSymbol { IsCreatedForFieldKeyword: true } backingField })
+                    if (member is SourcePropertySymbol property)
                     {
-                        return backingField;
+                        // PROTOTYPE(semi-auto-props): Add definite assignment tests involving initializer, including error scenarios where a FieldKeywordBackingField is still created.
+                        if (property.FieldKeywordBackingField is { } backingField)
+                        {
+                            return backingField;
+                        }
                     }
                     return null;
             }

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

@@ -301,11 +301,11 @@ private BoundExpression MakePropertyAssignment(
             if (setMethod is null)
             {
                 var autoProp = (SourcePropertySymbolBase)property.OriginalDefinition;
-                Debug.Assert(autoProp.IsAutoPropertyWithGetAccessor,
+                Debug.Assert(autoProp.GetMethod is SourcePropertyAccessorSymbol { IsEquivalentToBackingFieldAccess: true } || autoProp.FieldKeywordBackingField is not null,
                     "only autoproperties can be assignable without having setters");
                 Debug.Assert(property.Equals(autoProp, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes));
 
-                var backingField = autoProp.BackingField;
+                var backingField = autoProp.BackingField ?? autoProp.FieldKeywordBackingField;
                 Debug.Assert(backingField is not null);
 
                 return _factory.AssignmentExpression(

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

@@ -92,9 +92,27 @@ private static void StructDependsClosure(NamedTypeSymbol type, HashSet<Symbol> p
             {
                 foreach (var member in type.GetMembersUnordered())
                 {
-                    var field = member as FieldSymbol;
-                    var fieldType = field?.NonPointerType();
-                    if (fieldType is null || fieldType.TypeKind != TypeKind.Struct || field.IsStatic)
+                    if (member.IsStatic)
+                    {
+                        continue;
+                    }
+
+                    FieldSymbol field;
+                    if (member is SourcePropertySymbolBase { FieldKeywordBackingField: { } fieldKeywordField })
+                    {
+                        field = fieldKeywordField;
+                    }
+                    else if (member.Kind == SymbolKind.Field)
+                    {
+                        field = (FieldSymbol)member;
+                    }
+                    else
+                    {
+                        continue;
+                    }
+
+                    var fieldType = field.NonPointerType();
+                    if (fieldType is null || fieldType.TypeKind != TypeKind.Struct)
                     {
                         continue;
                     }

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

@@ -1617,8 +1617,6 @@ protected void AfterMembersChecks(BindingDiagnosticBag diagnostics)
             CheckTypeParameterNameConflicts(diagnostics);
             CheckAccessorNameConflicts(diagnostics);
 
-            bool unused = KnownCircularStruct;
-
             CheckSequentialOnPartialType(diagnostics);
             CheckForProtectedInStaticClass(diagnostics);
             CheckForUnmatchedOperators(diagnostics);
@@ -2133,11 +2131,12 @@ internal override bool KnownCircularStruct
                     else
                     {
                         var diagnostics = BindingDiagnosticBag.GetInstance();
+                        Debug.Assert(diagnostics.DiagnosticBag is not null);
                         var value = (int)CheckStructCircularity(diagnostics).ToThreeState();
 
                         if (Interlocked.CompareExchange(ref _lazyKnownCircularStruct, value, (int)ThreeState.Unknown) == (int)ThreeState.Unknown)
                         {
-                            AddDeclarationDiagnostics(diagnostics);
+                            DeclaringCompilation.CircularStructDiagnostics.AddRange(diagnostics);
                         }
 
                         Debug.Assert(value == _lazyKnownCircularStruct);
@@ -2163,16 +2162,22 @@ private bool HasStructCircularity(BindingDiagnosticBag diagnostics)
             {
                 foreach (var member in valuesByName)
                 {
-                    if (member.Kind != SymbolKind.Field)
+                    FieldSymbol field;
+                    if (member is SourcePropertySymbolBase { IsStatic: false, FieldKeywordBackingField: { } fieldKeywordField })
                     {
-                        // NOTE: don't have to check field-like events, because they can't have struct types.
-                        continue;
+                        field = fieldKeywordField;
                     }
-                    var field = (FieldSymbol)member;
-                    if (field.IsStatic)
+                    else if (member.Kind == SymbolKind.Field && !member.IsStatic)
                     {
+                        field = (FieldSymbol)member;
+                    }
+                    else
+                    {
+                        // NOTE: don't have to check field-like events, because they can't have struct types.
                         continue;
                     }
+
+                    Debug.Assert(!field.IsStatic);
                     var type = field.NonPointerType();
                     if (((object)type != null) &&
                         (type.TypeKind == TypeKind.Struct) &&

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

@@ -459,6 +459,7 @@ internal Accessibility LocalAccessibility
         /// This is only calculated from syntax, so we don't know if it
         /// will bind to something or will create a backing field.
         /// </remarks>
+        // PROTOTYPE(semi-auto-props): Rename to ContainsFieldKeywordSyntactically or similar.
         internal bool ContainsFieldKeyword => _containsFieldKeyword;
 
         /// <summary>