Error when required members are not set

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

@@ -215,6 +215,11 @@ private BoundAttribute BindAttributeCore(AttributeSyntax node, NamedTypeSymbol a
             ImmutableArray<BoundAssignmentOperator> boundNamedArguments = analyzedArguments.NamedArguments?.ToImmutableAndFree() ?? ImmutableArray<BoundAssignmentOperator>.Empty;
             Debug.Assert(boundNamedArguments.All(arg => !arg.Right.NeedsToBeConverted()));
 
+            if (attributeConstructor is not null)
+            {
+                CheckRequiredMembersInObjectInitializer(attributeConstructor, ImmutableArray<BoundExpression>.CastUp(boundNamedArguments), node, diagnostics);
+            }
+
             analyzedArguments.ConstructorArguments.Free();
 
             return new BoundAttribute(node, attributeConstructor, boundConstructorArguments, boundConstructorArgumentNamesOpt, argsToParamsOpt, expanded,
@@ -572,7 +577,8 @@ protected MethodSymbol BindAttributeConstructor(
                 diagnostics,
                 out memberResolutionResult,
                 out candidateConstructors,
-                allowProtectedConstructorsOfBaseType: true))
+                allowProtectedConstructorsOfBaseType: true,
+                suppressUnsupportedRequiredMembersError: false))
             {
                 resultKind = resultKind.WorseResultKind(
                     memberResolutionResult.IsValid && !IsConstructorAccessible(memberResolutionResult.Member, ref useSiteInfo) ?

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

@@ -4064,7 +4064,8 @@ private BoundExpression BindConstructorInitializerCore(
                                     diagnostics,
                                     out memberResolutionResult,
                                     out candidateConstructors,
-                                    allowProtectedConstructorsOfBaseType: true);
+                                    allowProtectedConstructorsOfBaseType: true,
+                                    suppressUnsupportedRequiredMembersError: true);
                 MethodSymbol resultMember = memberResolutionResult.Member;
 
                 validateRecordCopyConstructor(constructor, baseType, resultMember, errorLocation, diagnostics);
@@ -4967,55 +4968,71 @@ private static void ReportDuplicateObjectMemberInitializers(BoundExpression boun
             }
         }
 
+#nullable enable
         private static void CheckRequiredMembersInObjectInitializer(
-            BoundObjectCreationExpression creation,
+            MethodSymbol constructor,
+            ImmutableArray<BoundExpression> initializers,
+            SyntaxNode creationSyntax,
             BindingDiagnosticBag diagnostics)
         {
-            if (!creation.Constructor.ShouldCheckRequiredMembers())
+            if (!constructor.ShouldCheckRequiredMembers())
             {
                 return;
             }
 
-            if (creation.Constructor.ContainingType.HasRequiredMembersError)
+            if (constructor.ContainingType.HasRequiredMembersError)
             {
                 // An error will be reported on the constructor if from source, or a use-site diagnostic will be reported on the use if from metadata.
                 return;
             }
 
-            var requiredMembers = creation.Constructor.ContainingType.AllRequiredMembers.ToBuilder();
+            var requiredMembers = constructor.ContainingType.AllRequiredMembers.ToBuilder();
 
             if (requiredMembers.Count == 0)
             {
                 return;
             }
 
-            if (creation.InitializerExpressionOpt == null)
+            if (initializers.IsDefaultOrEmpty)
             {
                 reportMembers();
                 return;
             }
 
-            foreach (var initializer in creation.InitializerExpressionOpt.Initializers)
+            foreach (var initializer in initializers)
             {
-                if (initializer is not BoundAssignmentOperator { Left: BoundObjectInitializerMember member, Right: { } initializerExpression })
+                var (memberSymbol, initializerExpression) = initializer is BoundAssignmentOperator assignmentOperator
+                    ? (assignmentOperator.Left switch
+                    {
+                        // Regular initializers
+                        BoundObjectInitializerMember member => member.MemberSymbol,
+                        // Attribute initializers
+                        BoundPropertyAccess propertyAccess => propertyAccess.PropertySymbol,
+                        BoundFieldAccess fieldAccess => fieldAccess.FieldSymbol,
+                        _ => null
+                    }, assignmentOperator.Right)
+                    : default;
+
+                if (memberSymbol is null)
                 {
                     continue;
                 }
 
-                if (!requiredMembers.TryGetValue(member.MemberSymbol.Name, out var requiredMember))
+                if (!requiredMembers.TryGetValue(memberSymbol.Name, out var requiredMember))
                 {
                     continue;
                 }
 
-                if (!member.MemberSymbol.Equals(requiredMember, TypeCompareKind.ConsiderEverything))
+                if (!memberSymbol.Equals(requiredMember, TypeCompareKind.ConsiderEverything))
                 {
                     continue;
                 }
 
-                requiredMembers.Remove(member.MemberSymbol.Name);
+                requiredMembers.Remove(memberSymbol.Name);
 
                 if (initializerExpression is BoundObjectInitializerExpressionBase)
                 {
+                    // Required member '{0}' must be assigned a value, it cannot use a nested member or collection initializer.
                     diagnostics.Add(ErrorCode.ERR_RequiredMembersMustBeAssignment, initializerExpression.Syntax.Location, requiredMember);
                 }
             }
@@ -5024,20 +5041,22 @@ private static void CheckRequiredMembersInObjectInitializer(
 
             void reportMembers()
             {
-                Location location = creation.Syntax switch
+                Location location = creationSyntax switch
                 {
                     ObjectCreationExpressionSyntax { Type: { } type } => type.Location,
                     BaseObjectCreationExpressionSyntax { NewKeyword: { } newKeyword } => newKeyword.GetLocation(),
-                    _ => creation.Syntax.Location
+                    AttributeSyntax { Name: { } name } => name.Location,
+                    _ => creationSyntax.Location
                 };
 
                 foreach (var (_, member) in requiredMembers)
                 {
-                    // Required member '{0}' must be set in the object initializer.
+                    // Required member '{0}' must be set in the object initializer or attribute constructor.
                     diagnostics.Add(ErrorCode.ERR_RequiredMemberMustBeSet, location, member);
                 }
             }
         }
+#nullable disable
 
         private BoundCollectionInitializerExpression BindCollectionInitializerExpression(
             InitializerExpressionSyntax initializerSyntax,
@@ -5437,7 +5456,8 @@ protected BoundExpression BindClassCreationExpression(
                     diagnostics,
                     out MemberResolutionResult<MethodSymbol> memberResolutionResult,
                     out ImmutableArray<MethodSymbol> candidateConstructors,
-                    allowProtectedConstructorsOfBaseType: false) &&
+                    allowProtectedConstructorsOfBaseType: false,
+                    suppressUnsupportedRequiredMembersError: false) &&
                 !type.IsAbstract)
             {
                 var method = memberResolutionResult.Member;
@@ -5499,7 +5519,7 @@ protected BoundExpression BindClassCreationExpression(
                     type,
                     hasError);
 
-                CheckRequiredMembersInObjectInitializer(creation, diagnostics);
+                CheckRequiredMembersInObjectInitializer(creation.Constructor, creation.InitializerExpressionOpt?.Initializers ?? default, creation.Syntax, diagnostics);
 
                 return creation;
             }
@@ -5773,7 +5793,8 @@ internal bool TryPerformConstructorOverloadResolution(
             BindingDiagnosticBag diagnostics,
             out MemberResolutionResult<MethodSymbol> memberResolutionResult,
             out ImmutableArray<MethodSymbol> candidateConstructors,
-            bool allowProtectedConstructorsOfBaseType) // Last to make named arguments more convenient.
+            bool allowProtectedConstructorsOfBaseType,
+            bool suppressUnsupportedRequiredMembersError) // Last to make named arguments more convenient.
         {
             // Get accessible constructors for performing overload resolution.
             ImmutableArray<MethodSymbol> allInstanceConstructors;
@@ -5821,7 +5842,23 @@ internal bool TryPerformConstructorOverloadResolution(
                 }
             }
 
-            diagnostics.Add(errorLocation, useSiteInfo);
+            if (suppressUnsupportedRequiredMembersError && useSiteInfo.AccumulatesDiagnostics && useSiteInfo.Diagnostics is { Count: not 0 })
+            {
+                diagnostics.AddDependencies(useSiteInfo);
+                foreach (var diagnostic in useSiteInfo.Diagnostics)
+                {
+                    if ((ErrorCode)diagnostic.Code == ErrorCode.ERR_RequiredMembersInvalid)
+                    {
+                        continue;
+                    }
+
+                    diagnostics.ReportUseSiteDiagnostic(diagnostic, errorLocation);
+                }
+            }
+            else
+            {
+                diagnostics.Add(errorLocation, useSiteInfo);
+            }
 
             if (succeededIgnoringAccessibility)
             {

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -7008,7 +7008,7 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
     <value>Required member '{0}' must be settable.</value>
   </data>
   <data name="ERR_RequiredMemberMustBeSet" xml:space="preserve">
-    <value>Required member '{0}' must be set in the object initializer.</value>
+    <value>Required member '{0}' must be set in the object initializer or attribute constructor.</value>
   </data>
   <data name="ERR_RequiredMembersMustBeAssignment" xml:space="preserve">
     <value>Required member '{0}' must be assigned a value, it cannot use a nested member or collection initializer.</value>
@@ -7017,7 +7017,7 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
     <value>The required members list for '{0}' is malformed and cannot be interpreted.</value>
   </data>
   <data name="ERR_RequiredMembersBaseTypeInvalid" xml:space="preserve">
-    <value>The required members list for the base type '{0}' is malformed and cannot be interpreted. To use this constructor, apply the `SetsRequiredMembers` attribute.</value>
+    <value>The required members list for the base type '{0}' is malformed and cannot be interpreted. To use this constructor, apply the 'SetsRequiredMembers' attribute.</value>
   </data>
   <data name="ERR_LineContainsDifferentWhitespace" xml:space="preserve">
     <value>Line contains different whitespace than the closing line of the raw string literal: '{0}' versus '{1}'</value>

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

@@ -2410,7 +2410,7 @@ private void CheckForRequiredMemberAttribute(BindingDiagnosticBag diagnostics)
                         continue;
                     }
 
-                    // The required members list for the base type '{0}' is malformed and cannot be interpreted. To use this constructor, apply the `SetsRequiredMembers` attribute.
+                    // The required members list for the base type '{0}' is malformed and cannot be interpreted. To use this constructor, apply the 'SetsRequiredMembers' attribute.
                     diagnostics.Add(ErrorCode.ERR_RequiredMembersBaseTypeInvalid, method.Locations[0], BaseTypeNoUseSiteDiagnostics);
                 }
             }

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

@@ -842,8 +842,8 @@ internal static bool HasAsyncMethodBuilderAttribute(this Symbol symbol, [NotNull
 
         internal static bool IsRequired(this Symbol symbol) => symbol is FieldSymbol { IsRequired: true } or PropertySymbol { IsRequired: true };
 
-        internal static bool ShouldCheckRequiredMembers(this MethodSymbol constructor)
+        internal static bool ShouldCheckRequiredMembers(this MethodSymbol method)
             // PROTOTYPE(req): Check for the SetsRequiredMembersAttribute and return false for that case
-            => constructor.MethodKind == MethodKind.Constructor;
+            => method.MethodKind == MethodKind.Constructor;
     }
 }