Improve the experience of completion around required members

For completion inside an object initializer, this makes a few tweaks to
the experience:

1. Show the word "required" so those that are required are more easily
   identified.
2. Preselect the first required member, so that you can just immediately
   hit equals to type them out.

Closes dotnet#61534

src/EditorFeatures/CSharpTest/Completion/CompletionProviders/ObjectInitializerCompletionProviderTests.cs

@@ -996,6 +996,28 @@ static void Main(string[] args)
             await VerifyItemIsAbsentAsync(markup, "this");
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task RequiredMembersLabeledAndSelected()
+        {
+            var markup = @"
+class C
+{
+    public required int RequiredField;
+    public required int RequiredProperty { get; set; }
+}
+
+class D
+{
+    static void Main(string[] args)
+    {
+        var t = new C() { $$ };
+    }
+}";
+
+            await VerifyItemExistsAsync(markup, "RequiredField", inlineDescription: FeaturesResources.Required, matchPriority: MatchPriority.Preselect);
+            await VerifyItemExistsAsync(markup, "RequiredProperty", inlineDescription: FeaturesResources.Required);
+        }
+
         [WorkItem(15205, "https://github.com/dotnet/roslyn/issues/15205")]
         [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
         public async Task NestedPropertyInitializers1()

src/Features/Core/Portable/Completion/Providers/AbstractObjectInitializerCompletionProvider.cs

@@ -62,17 +62,32 @@ public override async Task ProvideCompletionsAsync(CompletionContext context)
             var alreadyTypedMembers = GetInitializedMembers(semanticModel.SyntaxTree, position, cancellationToken);
             var uninitializedMembers = members.Where(m => !alreadyTypedMembers.Contains(m.Name));
 
-            uninitializedMembers = uninitializedMembers.Where(m => m.IsEditorBrowsable(context.CompletionOptions.HideAdvancedMembers, semanticModel.Compilation));
+            // Sort the members by name so if we preselect one, it'll be stable
+            uninitializedMembers = uninitializedMembers.Where(m => m.IsEditorBrowsable(context.CompletionOptions.HideAdvancedMembers, semanticModel.Compilation))
+                                                       .OrderBy(m => m.Name);
+
+            var firstUnitializedRequiredMember = true;
 
             foreach (var uninitializedMember in uninitializedMembers)
             {
+                var rules = s_rules;
+
+                // We'll hard select the first required member to make it a bit easier to type out an object initializer
+                // with a bunch of members.
+                if (firstUnitializedRequiredMember && uninitializedMember.IsRequired())
+                {
+                    rules = rules.WithSelectionBehavior(CompletionItemSelectionBehavior.HardSelection).WithMatchPriority(MatchPriority.Preselect);
+                    firstUnitializedRequiredMember = false;
+                }
+
                 context.AddItem(SymbolCompletionItem.CreateWithSymbolId(
                     displayText: EscapeIdentifier(uninitializedMember),
                     displayTextSuffix: "",
                     insertionText: null,
                     symbols: ImmutableArray.Create(uninitializedMember),
                     contextPosition: initializerLocation.SourceSpan.Start,
-                    rules: s_rules));
+                    inlineDescription: uninitializedMember.IsRequired() ? FeaturesResources.Required : null,
+                    rules: rules));
             }
         }
 

src/Features/Core/Portable/FeaturesResources.resx

@@ -3147,4 +3147,8 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
   <data name="Fixing_0" xml:space="preserve">
     <value>Fixing '{0}'</value>
   </data>
+  <data name="Required" xml:space="preserve">
+    <value>required</value>
+    <comment>Used in the object initializer completion.</comment>
+  </data>
 </root>