Address prototype comments

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -7136,6 +7136,15 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_UnsupportedCompilerFeature" xml:space="preserve">
     <value>'{0}' requires compiler feature '{1}', which is not supported by this version of the C# compiler.</value>
   </data>
+  <data name="WRN_ObsoleteMembersShouldNotBeRequired" xml:space="preserve">
+    <value>Required member '{0}' should not be attributed with 'ObsoleteAttribute' unless the containing type is obsolete or all constructors are obsolete.</value>
+  </data>
+  <data name="WRN_ObsoleteMembersShouldNotBeRequired_Title" xml:space="preserve">
+    <value>Members attributed with 'ObsoleteAttribute' should not be required unless the containing type is obsolete or all constructors are obsolete.</value>
+  </data>
+  <data name="ERR_RefReturningPropertiesCannotBeRequired" xml:space="preserve">
+    <value>Ref returning properties cannot be required.</value>
+  </data>
   <data name="ERR_MisplacedUnchecked" xml:space="preserve">
     <value>Unexpected keyword 'unchecked'</value>
   </data>

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

@@ -2089,5 +2089,7 @@ internal enum ErrorCode
         ERR_ChainingToSetsRequiredMembersRequiresSetsRequiredMembers = 9510,
         ERR_NewConstraintCannotHaveRequiredMembers = 9511,
         ERR_UnsupportedCompilerFeature = 9512,
+        WRN_ObsoleteMembersShouldNotBeRequired = 9513,
+        ERR_RefReturningPropertiesCannotBeRequired = 9514,
     }
 }

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

@@ -501,6 +501,7 @@ internal static int GetWarningLevel(ErrorCode code)
                 case ErrorCode.WRN_UseDefViolationThisSupportedVersion:
                 case ErrorCode.WRN_UnassignedThisAutoPropertySupportedVersion:
                 case ErrorCode.WRN_UnassignedThisSupportedVersion:
+                case ErrorCode.WRN_ObsoleteMembersShouldNotBeRequired:
                     return 1;
                 default:
                     return 0;

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

@@ -676,7 +676,7 @@ void checkMemberStateOnConstructorExit(MethodSymbol constructor, Symbol member,
                     return;
                 }
 
-                if (symbol.IsRequired())
+                if (symbol.IsRequired() && constructor.ShouldCheckRequiredMembers())
                 {
                     return;
                 }

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

@@ -49,15 +49,16 @@ internal enum CompletionPart
         SynthesizedExplicitImplementations = 1 << 13,
         StartMemberChecks = 1 << 14,
         FinishMemberChecks = 1 << 15,
-        MembersCompleted = 1 << 16, // this should be the last (highest-value) part
+        MembersCompletedChecksStarted = 1 << 16,
+        MembersCompleted = 1 << 17, // this should be the last (highest-value) part
 
-        All = (1 << 17) - 1,
+        All = (1 << 18) - 1,
 
         // This is the work we can do if ForceComplete is scoped to a particular SyntaxTree.
         NamedTypeSymbolWithLocationAll = Attributes | StartBaseType | FinishBaseType | StartInterfaces | FinishInterfaces | EnumUnderlyingType |
             TypeArguments | TypeParameters | Members | TypeMembers | SynthesizedExplicitImplementations | StartMemberChecks | FinishMemberChecks,
 
-        NamedTypeSymbolAll = NamedTypeSymbolWithLocationAll | MembersCompleted,
+        NamedTypeSymbolAll = NamedTypeSymbolWithLocationAll | MembersCompletedChecksStarted | MembersCompleted,
 
         // For Usings
         StartValidatingImports = 1 << 4,

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

@@ -244,6 +244,8 @@ internal override LexicalSortKey GetLexicalSortKey()
                 // so we will keep them the same.
                 return new LexicalSortKey(this.syntaxReferenceOpt.GetLocation(), this.DeclaringCompilation);
             }
+
+            protected override bool HasSetsRequiredMembersImpl => false;
         }
 
         private sealed class InvokeMethod : SourceDelegateMethodSymbol

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

@@ -598,6 +598,7 @@ internal override void ForceComplete(SourceLocation? locationOpt, CancellationTo
                         }
                         break;
 
+                    case CompletionPart.MembersCompletedChecksStarted:
                     case CompletionPart.MembersCompleted:
                         {
                             ImmutableArray<Symbol> members = this.GetMembersUnordered();
@@ -631,12 +632,22 @@ internal override void ForceComplete(SourceLocation? locationOpt, CancellationTo
                             }
 
                             EnsureFieldDefinitionsNoted();
+                            cancellationToken.ThrowIfCancellationRequested();
 
-                            // We've completed all members, so we're ready for the PointedAtManagedTypeChecks;
-                            // proceed to the next iteration.
-                            state.NotePartComplete(CompletionPart.MembersCompleted);
-                            break;
+                            if (state.NotePartComplete(CompletionPart.MembersCompletedChecksStarted))
+                            {
+                                var diagnostics = BindingDiagnosticBag.GetInstance();
+                                AfterMembersCompletedChecks(diagnostics);
+                                AddDeclarationDiagnostics(diagnostics);
+
+                                // We've completed all members, so we're ready for the PointedAtManagedTypeChecks;
+                                // proceed to the next iteration.
+                                var thisThreadCompleted = state.NotePartComplete(CompletionPart.MembersCompleted);
+                                Debug.Assert(thisThreadCompleted);
+                                diagnostics.Free();
+                            }
                         }
+                        break;
 
                     case CompletionPart.None:
                         return;
@@ -1744,6 +1755,10 @@ static bool needsTupleElementNamesAttribute(TypeSymbol type)
             }
         }
 
+        protected virtual void AfterMembersCompletedChecks(BindingDiagnosticBag diagnostics)
+        {
+        }
+
         private void CheckMemberNamesDistinctFromType(BindingDiagnosticBag diagnostics)
         {
             foreach (var member in GetMembersAndInitializers().NonTypeMembers)

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

@@ -199,7 +199,6 @@ internal static DeclarationModifiers MakeModifiers(NamedTypeSymbol containingTyp
 
                 if ((result & DeclarationModifiers.Required) != 0)
                 {
-                    // PROTOTYPE(req): capture the allowed modifier combinations in the specification
                     // The modifier 'required' is not valid for this item
                     diagnostics.Add(ErrorCode.ERR_BadMemberFlag, errorLocation, SyntaxFacts.GetText(SyntaxKind.RequiredKeyword));
                 }

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

@@ -1638,5 +1638,42 @@ internal bool IsSimpleProgram
                 return this.declaration.Declarations.Any(d => d.IsSimpleProgram);
             }
         }
+
+        protected override void AfterMembersCompletedChecks(BindingDiagnosticBag diagnostics)
+        {
+            base.AfterMembersCompletedChecks(diagnostics);
+
+            // We need to give warnings if Obsolete is applied to any required members and there are constructors where a user would be forced to set that member,
+            // unless:
+            //  1. We're in an obsolete context ourselves, or
+            //  2. All constructors of this type are obsolete or attributed with SetsRequiredMembersAttribute
+            // We don't warn for obsolete required members from base types, as the user either has a warning that they're depending on an obsolete constructor/type
+            // already, or the original author ignored this warning.
+
+            // Obsolete states should have already been calculated by this point in the pipeline.
+            Debug.Assert(ObsoleteKind != ObsoleteAttributeKind.Uninitialized);
+            Debug.Assert(GetMembers().All(m => m.ObsoleteKind != ObsoleteAttributeKind.Uninitialized));
+
+            if (ObsoleteKind != ObsoleteAttributeKind.None
+                || GetMembers().All(m => m is not MethodSymbol { MethodKind: MethodKind.Constructor, ObsoleteKind: ObsoleteAttributeKind.None } method
+                                         || !method.ShouldCheckRequiredMembers()))
+            {
+                return;
+            }
+
+            foreach (var member in GetMembers())
+            {
+                if (!member.IsRequired())
+                {
+                    continue;
+                }
+
+                if (member.ObsoleteKind != ObsoleteAttributeKind.None)
+                {
+                    // Required member '{0}' should not be attributed with 'ObsoleteAttribute' unless the containing type is obsolete or all constructors are obsolete.
+                    diagnostics.Add(ErrorCode.WRN_ObsoleteMembersShouldNotBeRequired, member.Locations[0], member);
+                }
+            }
+        }
     }
 }

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

@@ -677,6 +677,12 @@ internal override void AfterAddingTypeMembersChecks(ConversionsBase conversions,
                 CheckInitializer(IsAutoProperty, ContainingType.IsInterface, IsStatic, Location, diagnostics);
             }
 
+            if (RefKind != RefKind.None && IsRequired)
+            {
+                // Ref returning properties cannot be required.
+                diagnostics.Add(ErrorCode.ERR_RefReturningPropertiesCannotBeRequired, Location);
+            }
+
             if (IsAutoPropertyWithGetAccessor)
             {
                 Debug.Assert(GetMethod is object);