Added "propr" snippet for required properties

src/Features/CSharp/Portable/Snippets/AbstractCSharpAutoPropertySnippetProvider.cs

@@ -58,6 +58,8 @@ protected override async Task<PropertyDeclarationSyntax> GenerateSnippetSyntaxAs
             modifiers = SyntaxTokenList.Create(PublicKeyword);
         }
 
+        modifiers = modifiers.AddRange(GetAdditionalPropertyModifiers(syntaxContext));
+
         return SyntaxFactory.PropertyDeclaration(
             attributeLists: default,
             modifiers: modifiers,
@@ -87,4 +89,9 @@ protected override ImmutableArray<SnippetPlaceholder> GetPlaceHolderLocationsLis
         var node = root.FindNode(TextSpan.FromBounds(position, position));
         return node.GetAncestorOrThis<PropertyDeclarationSyntax>();
     }
+
+    protected virtual SyntaxToken[] GetAdditionalPropertyModifiers(CSharpSyntaxContext? syntaxContext)
+    {
+        return [];
+    }
 }

src/Features/CSharp/Portable/Snippets/CSharpProprSnippetProvider.cs

@@ -0,0 +1,72 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Composition;
+using System.Linq;
+using System.Threading;
+using Microsoft.CodeAnalysis.CSharp.Extensions.ContextQuery;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Editing;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Snippets;
+using Microsoft.CodeAnalysis.Snippets.SnippetProviders;
+using Roslyn.Utilities;
+using static Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTokens;
+
+namespace Microsoft.CodeAnalysis.CSharp.Snippets;
+
+[ExportSnippetProvider(nameof(ISnippetProvider), LanguageNames.CSharp), Shared]
+[method: ImportingConstructor]
+[method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+internal sealed class CSharpProprSnippetProvider() : AbstractCSharpAutoPropertySnippetProvider
+{
+    public override string Identifier => CommonSnippetIdentifiers.RequiredProperty;
+
+    public override string Description => FeaturesResources.required_property;
+
+    protected override bool IsValidSnippetLocationCore(SnippetContext context, CancellationToken cancellationToken)
+    {
+        if(!base.IsValidSnippetLocationCore(context, cancellationToken))
+            return false;
+
+        var syntaxContext = (CSharpSyntaxContext)context.SyntaxContext;
+        var precedingModifiers = syntaxContext.PrecedingModifiers;
+
+        if (syntaxContext.PrecedingModifiers.IsEmpty())
+            return true;
+
+        // "private" and "private protected" modifiers are NOT valid for required property
+        if (precedingModifiers.Any(syntaxKind => syntaxKind == SyntaxKind.PrivateKeyword))
+            return false;
+
+        // "protected internal" modifiers are valid for required property
+        if(precedingModifiers.IsSupersetOf([SyntaxKind.ProtectedKeyword, SyntaxKind.InternalKeyword]))
+            return true;
+
+        // "protected" and "private protected" modifiers are NOT valid for required property
+        if(precedingModifiers.Any(syntaxKind => syntaxKind == SyntaxKind.ProtectedKeyword))
+            return false;
+
+        return true;
+    }
+
+    protected override AccessorDeclarationSyntax? GenerateSetAccessorDeclaration(CSharpSyntaxContext syntaxContext, SyntaxGenerator generator, CancellationToken cancellationToken)
+    {
+        // Having a property with `set` accessor in a readonly struct leads to a compiler error.
+        // So if user executes snippet inside a readonly struct the right thing to do is to not generate `set` accessor at all
+        if (syntaxContext.ContainingTypeDeclaration is StructDeclarationSyntax structDeclaration &&
+            syntaxContext.SemanticModel.GetDeclaredSymbol(structDeclaration, cancellationToken) is { IsReadOnly: true })
+        {
+            return null;
+        }
+
+        return base.GenerateSetAccessorDeclaration(syntaxContext, generator, cancellationToken);
+    }
+
+    protected override SyntaxToken[] GetAdditionalPropertyModifiers(CSharpSyntaxContext? syntaxContext)
+    {
+        return [RequiredKeyword];
+    }
+}

src/Features/CSharpTest/Snippets/AbstractCSharpAutoPropertySnippetProviderTests.cs

@@ -143,25 +143,13 @@ public Program()
             """);
     }
 
-    [Theory]
-    [MemberData(nameof(CommonSnippetTestData.AllAccessibilityModifiers), MemberType = typeof(CommonSnippetTestData))]
-    public async Task InsertSnippetAfterAccessibilityModifierTest(string modifier)
-    {
-        await VerifyPropertyAsync($$"""
-            class Program
-            {
-                {{modifier}} $$
-            }
-            """, $$"""{|0:int|} {|1:MyProperty|} {{DefaultPropertyBlockText}}""");
-    }
-
     protected async Task VerifyPropertyAsync([StringSyntax(PredefinedEmbeddedLanguageNames.CSharpTest)] string markup, string propertyMarkup)
     {
         TestFileMarkupParser.GetPosition(markup, out var code, out var position);
         var expectedCode = code.Insert(position, propertyMarkup + "$$");
         await VerifySnippetAsync(markup, expectedCode);
     }
 
-    protected Task VerifyDefaultPropertyAsync([StringSyntax(PredefinedEmbeddedLanguageNames.CSharpTest)] string markup, string propertyName = "MyProperty")
+    protected virtual Task VerifyDefaultPropertyAsync([StringSyntax(PredefinedEmbeddedLanguageNames.CSharpTest)] string markup, string propertyName = "MyProperty")
         => VerifyPropertyAsync(markup, $$"""public {|0:int|} {|1:{{propertyName}}|} {{DefaultPropertyBlockText}}""");
 }

src/Features/CSharpTest/Snippets/CSharpPropSnippetProviderTests.cs

@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Threading.Tasks;
+using Xunit;
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests.Snippets;
 
@@ -65,4 +66,16 @@ interface MyInterface
             }
             """);
     }
+
+    [Theory]
+    [MemberData(nameof(CommonSnippetTestData.AllAccessibilityModifiers), MemberType = typeof(CommonSnippetTestData))]
+    public async Task InsertSnippetAfterAccessibilityModifierTest(string modifier)
+    {
+        await VerifyPropertyAsync($$"""
+            class Program
+            {
+                {{modifier}} $$
+            }
+            """, $$"""{|0:int|} {|1:MyProperty|} {{DefaultPropertyBlockText}}""");
+    }
 }

src/Features/CSharpTest/Snippets/CSharpPropgSnippetProviderTests.cs

@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Threading.Tasks;
+using Xunit;
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests.Snippets;
 
@@ -66,4 +67,16 @@ interface MyInterface
             }
             """, "public {|0:int|} {|1:MyProperty|} { get; }");
     }
+
+    [Theory]
+    [MemberData(nameof(CommonSnippetTestData.AllAccessibilityModifiers), MemberType = typeof(CommonSnippetTestData))]
+    public async Task InsertSnippetAfterAccessibilityModifierTest(string modifier)
+    {
+        await VerifyPropertyAsync($$"""
+            class Program
+            {
+                {{modifier}} $$
+            }
+            """, $$"""{|0:int|} {|1:MyProperty|} {{DefaultPropertyBlockText}}""");
+    }
 }

src/Features/CSharpTest/Snippets/CSharpPropiSnippetProviderTests.cs

@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Threading.Tasks;
+using Xunit;
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests.Snippets;
 
@@ -59,4 +60,16 @@ interface MyInterface
             }
             """);
     }
+
+    [Theory]
+    [MemberData(nameof(CommonSnippetTestData.AllAccessibilityModifiers), MemberType = typeof(CommonSnippetTestData))]
+    public async Task InsertSnippetAfterAccessibilityModifierTest(string modifier)
+    {
+        await VerifyPropertyAsync($$"""
+            class Program
+            {
+                {{modifier}} $$
+            }
+            """, $$"""{|0:int|} {|1:MyProperty|} {{DefaultPropertyBlockText}}""");
+    }
 }

src/Features/CSharpTest/Snippets/CSharpProprSnippetProviderTests.cs

@@ -0,0 +1,107 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Diagnostics.CodeAnalysis;
+using System.Threading.Tasks;
+using Roslyn.Test.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.CSharp.UnitTests.Snippets;
+
+public sealed class CSharpProprSnippetProviderTests : AbstractCSharpAutoPropertySnippetProviderTests
+{
+    protected override string SnippetIdentifier => "propr";
+
+    protected override string DefaultPropertyBlockText => "{ get; set; }";
+
+    [WorkItem("https://github.com/dotnet/roslyn/issues/75128")]
+    public override async Task InsertSnippetInReadonlyStructTest()
+    {
+        // Ensure we don't generate redundant `set` accessor when executed in readonly struct
+        await VerifyPropertyAsync("""
+            readonly struct MyStruct
+            {
+                $$
+            }
+            """, "public required {|0:int|} {|1:MyProperty|} { get; }");
+    }
+
+    [WorkItem("https://github.com/dotnet/roslyn/issues/75128")]
+    public override async Task InsertSnippetInReadonlyStructTest_ReadonlyModifierInOtherPartialDeclaration()
+    {
+        // Ensure we don't generate redundant `set` accessor when executed in readonly struct
+        await VerifyPropertyAsync("""
+            partial struct MyStruct
+            {
+                $$
+            }
+
+            readonly partial struct MyStruct
+            {
+            }
+            """, "public required {|0:int|} {|1:MyProperty|} { get; }");
+    }
+
+    [WorkItem("https://github.com/dotnet/roslyn/issues/75128")]
+    public override async Task InsertSnippetInReadonlyStructTest_ReadonlyModifierInOtherPartialDeclaration_MissingPartialModifier()
+    {
+        // Even though there is no `partial` modifier on the first declaration
+        // compiler still treats the whole type as partial since it is more likely that
+        // the user's intent was to have a partial type and they just forgot the modifier.
+        // Thus we still recognize that as `readonly` context and don't generate a setter
+        await VerifyPropertyAsync("""
+            struct MyStruct
+            {
+                $$
+            }
+
+            readonly partial struct MyStruct
+            {
+            }
+            """, "public required {|0:int|} {|1:MyProperty|} { get; }");
+    }
+
+    [WorkItem("https://github.com/dotnet/roslyn/issues/75128")]
+    public override async Task InsertSnippetInInterfaceTest()
+    {
+        await VerifyDefaultPropertyAsync("""
+            interface MyInterface
+            {
+                $$
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/75128")]
+    [InlineData("public")]
+    [InlineData("internal")]
+    [InlineData("protected internal")]
+    public async Task InsertSnippetAfterAccessibilityModifierTest(string modifier)
+    {
+        await VerifyPropertyAsync($$"""
+            class Program
+            {
+                {{modifier}} $$
+            }
+            """,
+            $$"""required {|0:int|} {|1:MyProperty|} {{DefaultPropertyBlockText}}""");
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/75128")]
+    [InlineData("private")]
+    [InlineData("protected")]
+    [InlineData("private protected")]
+    public async Task DoNotInsertSnippetAfterAccessibilityModifierTest(string modifier)
+    {
+        await VerifySnippetIsAbsentAsync($$"""
+            class Program
+            {
+                {{modifier}} $$
+            }
+            """);
+    }
+
+    protected override Task VerifyDefaultPropertyAsync([StringSyntax(PredefinedEmbeddedLanguageNames.CSharpTest)] string markup, string propertyName = "MyProperty")
+        => VerifyPropertyAsync(markup, $$"""public required {|0:int|} {|1:{{propertyName}}|} {{DefaultPropertyBlockText}}""");
+}

src/Features/Core/Portable/FeaturesResources.resx

@@ -3171,4 +3171,7 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
   <data name="Symbol_search" xml:space="preserve">
     <value>Symbol search</value>
   </data>
+  <data name="required_property" xml:space="preserve">
+    <value>required property</value>
+  </data>
 </root>

src/Features/Core/Portable/Snippets/CommonSnippetIdentifiers.cs

@@ -13,5 +13,6 @@ internal static class CommonSnippetIdentifiers
     public const string ConsoleWriteLine = "cw";
     public const string Constructor = "ctor";
     public const string Property = "prop";
+    public const string RequiredProperty = "propr";
     public const string GetOnlyProperty = "propg";
 }