[clang-format] Add a new AfterCSharpProperty to BraceWrapping

[MyDeveloperDay]

Summary

This change allows always breaking before braces on C# setter and getter properties

Fixes #61968

https://github.com/llvm/llvm-project/issues/61968

[MyDeveloperDay]

clang/unittests/Format/FormatTestCSharp.cpp

1641

Hmm.. maybe this should be

string Foo 
{
    set;get
}

[MyDeveloperDay]

I'm not convinced AfterCSharpProperty is a good name, open for suggestions

[MyDeveloperDay]

for default set;get or get;set for when AfterCSharpProperty is true,

public Foo {
    set;
    get;
}

[MyDeveloperDay]

re clang-format

[HazardyKnusperkeks]

In D148467#4272173, @MyDeveloperDay wrote:

I'm not convinced AfterCSharpProperty is a good name, open for suggestions

I've not enough domain knowledge to name it.

clang/include/clang/Format/Format.h

1248

Please sort. :)

4306

It's missing in operator==. And I think we should add operator== to BraceWrappingFlags and use that here.

clang/lib/Format/Format.cpp

185

A bit up.

clang/unittests/Format/FormatTestCSharp.cpp

1641

I'm no C# guy, but when we split the lines, I think get and set should be on it's own line.

[MyDeveloperDay]

clang/include/clang/Format/Format.h

1248

Are we sure we want THIS to be alphabetic, as this changes the initializer order, if someone is using the format() library in downstream code this could subtly break them?

Expanded.BraceWrapping = {/*AfterCaseLabel=*/false,
                            /*AfterClass=*/false,
                            /*AfterControlStatement=*/FormatStyle::BWACS_Never,
                            /*AfterEnum=*/false,
                            /*AfterFunction=*/false,
                            /*AfterNamespace=*/false,
                            /*AfterObjCDeclaration=*/false,
                            /*AfterStruct=*/false,
                            /*AfterUnion=*/false,
                            /*AfterExternBlock=*/false,
                            /*BeforeCatch=*/false,
                            /*BeforeElse=*/false,
                            /*BeforeLambdaBody=*/false,
                            /*BeforeWhile=*/false,
                            /*IndentBraces=*/false,
                            /*SplitEmptyFunction=*/true,
                            /*SplitEmptyRecord=*/true,
                            /*SplitEmptyNamespace=*/true,
                            /*AfterCSharpProperty=*/false};

[owenpan]

clang/lib/Format/TokenAnnotator.cpp

5034–5037

clang/unittests/Format/FormatTestCSharp.cpp

1622

Ditto below.

[HazardyKnusperkeks]

clang/include/clang/Format/Format.h

1248

I'd say yes, we are breaking this stuff always.

Granted this one may compile without an error, but they should get a warning of a missing initializer.

You could add a constructor to initialize out of struct order.

[MyDeveloperDay]

clang/include/clang/Format/Format.h

1248

I'm ok with making the change, just wanted to double check that we are ok to break the ordering.

[owenpan]

clang/include/clang/Format/Format.h

1248

I kept them sorted in D52527 years ago. :)

[MyDeveloperDay]

Address review comments, still would like to solve the indenting issue.

[MyDeveloperDay]

need to handle init;
need to handle public|private|internal accessors

[StrangeRanger]

In D148467#4272231, @MyDeveloperDay wrote:

for default set;get or get;set for when AfterCSharpProperty is true,

public Foo {
    set;
    get;
}

At least from my experience, the getter is specified before the setter, though I'm unsure how important this is in your eyes.
If we assume the above sentence is always true, and the brace doesn't break after the property name, the following are (some of) the options in formatting that I've seen:

When autoproperty is used:

public Foo {
    get;
    set;
}

// OR

public FooTwo { set; get; }  // What I prefer.

When a non-autoproperty is used:

/* When only one thing is provided in the getter and setter. */

public Foo {
    get { return _next; }  
    set { _next = value; }
}  // What I prefer.

// OR

public Foo {
    get => return _next; 
    set => _next = value;
}  // Another option that I like (which really doesn't apply to this code change).

// OR

public Foo {
    get 
    { 
        return _next; 
    }  

    set 
    { 
        _next = value; 
    }
}

// ----------------------------------

/* When more than one thing is provided in the getter and setter. */

public Foo {
    get 
    { 
        // ...
        return _next; 
    }  

    set 
    { 
        _next = value;
        // ...
    }
}

Please note that the above examples *slightly* ignore the different variations in how the braces could be set (new line or not).

I hope this input is enough/helps. Please let me know if you'd like any clarification.

[MyDeveloperDay]

public Foo {
    set;
    get;
}

At least from my experience, the getter is specified before the setter, though I'm unsure how important this is in your eyes.

Lets hold off the idea of swapping set;get around from this patch, but this is something that I think we could do.. (using the FormatTokenLexer.cpp to swap trivial set;get into get;set but lets leave that for another feature, as it would be code altering)

honeslty I think we need another option maybe

enum AllowShortCSharpProperties {
      Leave,
      Never,
      Empty,
      Always
}

Leave = Don't touch them
Never = always break (braces follow AfterCSharpProperty

set;
get;

set { 
  val = value; 
}
get { 
  return = value; 
}

Empty = only one the same line when empty

set; get

set { 
   val = value; 
}
get { 
  return = value;
}

Always = always short form for trivial

set; get;

set {  val = value; }
get {  return = value; }

I'm trying to decide if I put that option in this change or in a seperate change (thoughts @HazardyKnusperkeks, @owenpan )

FYI, I've solved the indention issue in my branch which has been broken forever from what I can tell.

verifyFormat("class A\n"
             "{\n"
             "    string Bar {\n"
             "        get;\n"
             "        set\n"
             "        {\n"
             "            val = value;\n"
             "        }\n"
             "    }\n"
             "}",
             Style);

[MyDeveloperDay]

add init support and fix indentation issue when only one property is defined but the is an auto-property

[MyDeveloperDay]

upload the correct patch file

[StrangeRanger]

In D148467#4277960, @MyDeveloperDay wrote:

I'm trying to decide if I put that option in this change or in a separate change (thoughts @HazardyKnusperkeks, @owenpan )

I'm not too privy to your workflow, but if by "in a separate change" you mean like "in a different PR", I'd probably say implement it in a different change, for the sake of revision history.

[HazardyKnusperkeks]

In D148467#4277960, @MyDeveloperDay wrote:

public Foo {
    set;
    get;
}

At least from my experience, the getter is specified before the setter, though I'm unsure how important this is in your eyes.

Lets hold off the idea of swapping set;get around from this patch, but this is something that I think we could do.. (using the FormatTokenLexer.cpp to swap trivial set;get into get;set but lets leave that for another feature, as it would be code altering)

honeslty I think we need another option maybe

enum AllowShortCSharpProperties {
      Leave,
      Never,
      Empty,
      Always
}

Leave = Don't touch them
Never = always break (braces follow AfterCSharpProperty

set;
get;

set { 
  val = value; 
}
get { 
  return = value; 
}

Empty = only one the same line when empty

set; get

set { 
   val = value; 
}
get { 
  return = value;
}

Always = always short form for trivial

set; get;

set {  val = value; }
get {  return = value; }

I'm trying to decide if I put that option in this change or in a seperate change (thoughts @HazardyKnusperkeks, @owenpan )

FYI, I've solved the indention issue in my branch which has been broken forever from what I can tell.

verifyFormat("class A\n"
             "{\n"
             "    string Bar {\n"
             "        get;\n"
             "        set\n"
             "        {\n"
             "            val = value;\n"
             "        }\n"
             "    }\n"
             "}",
             Style);

I'd say do it now. No need to introduce a new option, when we want to change it directly.

Or at least make it the enum right now, with just 2 values.

[MyDeveloperDay]

There is more to this than meets the eye.. what we have so far, from existing AfterFunction use and the propsed here AfterCSharpProperty is...

public Foo
{                        <--- controlled by **AfterFunction **(rightly or wrongly)
     get {               <--- proposing to controlled by **AfterCSharpProperty**
        return;
     }
     set {
        val= value;
     }
}

But for trivial Properties, these are automatically assumed to be wanted on the same line.

public Foo { set; get}

Trivial Properties are defined as:

 all ordering variants  (public/internal/private)
set;get;
public set;get
public init;get
get;set

My problem is AfterFunction ONLY kicks in if this isn't a TrivialProperty.. We can't currently force TrivialProperties to be handled differently.

AfterFunction = true we get

public Foo { set; get}  

// we can't get to
public Foo { 
  set; get
}

Handling of Trivial Properties I feel there should be an "AllowCSharpPropertiesOnASingleLine" to match other options, otherwise it should follow AfterFunction (AllowCSharpPropertiesOnASingleLine default would need to be true to match current behaviour)

AllowCSharpPropertiesOnASingleLine =true, AfterFunction = true/false

public Foo {  set; get }

AllowCSharpPropertiesOnASingleLine = false, AfterFunction = true

public Foo { 
     set; get
}

So then how do we handle

set;get

vs

set;
get;

Should AfterCSharpProperty be use in this case? or do we introduce "BreakBetweenCSharpProperties " (default false)

I know it seems strange to add 3 options to handle this, but I think it would give people the best of both worlds

you can have the following in the same file (which is actually quite common)

BreakBetweenCSharpProperties = false
AllowCSharpPropertiesOnASingleLine = true
AfterFunction = true
AfterCSharpProperty = true

public Foo
{                        
     get 
     {               
          return value;
     }
     set {
          value = 123;
     }
}

public Bar
{                        
     get; set;
}

If we useAfterCSharpProperty to control BreakBetweenCSharpProperties then I think we have to have the following and we can't control Bar how we might want

public Foo
{                        
     get 
     {               
          return value;
     }
     set {
          value = 123;
     }
}

public Bar
{                        
     get; 
     set;
}

From what I can tell...Microsoft .NET Framework seems to be

BreakBetweenCSharpProperties = true
AllowCSharpPropertiesOnASingleLine = false
AfterFunction = true
AfterCSharpProperty = true

https://github.com/microsoft/referencesource/blob/5697c29004a34d80acdaf5742d7e699022c64ecd/mscorlib/system/iappdomainsetup.cs

https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/using-properties

It would seem they don't seem to put Trivial Properties/AutoProperties on the same line

[MyDeveloperDay]

Adds additional options to give us much greater control over how we format C# properties especially auto properties

(Submitting this for safe keeping, I need to try and minimize the if expression, I'm sure it could be simplified into a few less clauses)

[MyDeveloperDay]

Sorry had a clang-format reflow comments moment, revert the unrelated comment changes
simplify the if's a little

[MyDeveloperDay]

In my C# project, these settings give me just what we tend to use.

BreakBeforeBraces: Custom
BraceWrapping:
  AfterFunction: true
  AfterCSharpProperty: true
AllowShortCSharpPropertiesOnASingleLine: false
AlwaysBreakBetweenShortCSharpProperties: false

for AutoProperties

public int min_value
{
    get; set;
}

but for formal properties,

public int Margin
{
    get
    {
        return this.value> 0? 10 : 0;
    }
}

although I like the idea of being able to change this to this with AfterCSharpProperty: false

public int Margin
{
    get {
        return this.value> 0? 10 : 0;
    }
}

[HazardyKnusperkeks]

clang/lib/Format/TokenAnnotator.cpp

21

What is this?

5022–5025

Isn't the example wrong?

5030

5038

5045

This gets keeping repeated, maybe put it in a own function?

5052–5053

Same here.

5091

Drop

5099–5101

A bit too much parens.

5111

Also not needed.

clang/lib/Format/UnwrappedLineParser.cpp

2076–2078 ↗

(On Diff #515068)

[MyDeveloperDay]

Address review comment, add convenience functions to simplify conditions

[MyDeveloperDay]

There is another case I need to cover

Style.BraceWrapping.AfterCSharpProperty = false;
Style.AllowShortCSharpPropertiesOnASingleLine = false;
Style.AlwaysBreakBetweenShortCSharpProperties = false;
Style.BraceWrapping.AfterFunction = true;

verifyFormat("class A\n"
               "{\n"
               "    string Bar1\n"
               "    {\n"
               "        set; get;\n"
               "    }\n"
               "}",
               Style);

This is currently formatting as

class A
{
    string Bar1 
    { set; get; }
}

which doesn't feel quite right.

clang/lib/Format/TokenAnnotator.cpp

21

huh! I've no idea? where did that come from?

[MyDeveloperDay]

Handle the case

string Foo 
{
     set;get;
}

[MyDeveloperDay]

Just an update on this, it works well but some of the cases are not tolerant to comments, I'm working my way through those issues

clang/docs/ClangFormatStyleOptions.rst

* ``BWACS_Always`` (in configuration: ``Always``)
         if (foo())
         {
         } else
         {}
         for (int i = 0; i < 10; ++i)
         {}
 
 
+  * ``bool AfterCSharpProperty`` Wrap C# setter/getter properties.
+
+    .. code-block:: c++
+
+      true:
+      string Foo {
+        get
+        {
+          return _foo;
+        }
+        set
+        {
+          _foo = value;
+        }
+      }
+
+      false:
+      string Foo {
+        get {
+          return _foo;
+        }
+        set {
+          return _value
+        }
+      }
+
   * ``bool AfterEnum`` Wrap enum definitions.
 
     .. code-block:: c++
 
       true:
       enum X : int
       {
         B

clang/docs/ReleaseNotes.rst

 
 - Add ``NextLineOnly`` style to option ``PackConstructorInitializers``.
   Compared to ``NextLine`` style, ``NextLineOnly`` style will not try to
   put the initializers on the current line first, instead, it will try to
   put the initializers on the next line only.
 - Add additional Qualifier Ordering support for special cases such
   as templates, requires clauses, long qualified names.
 - Fix all known issues associated with ``LambdaBodyIndentation: OuterScope``.
+- Add ``AfterCSharpProperty`` style to option ``BraceWrapping`` to allow 
+  newline before the opening brace of ``set;get;``.
 
 libclang
 --------
 
 - Introduced the new function ``clang_CXXMethod_isExplicit``,
   which identifies whether a constructor or conversion function cursor
   was marked with the explicit identifier.
 

clang/include/clang/Format/Format.h

struct BraceWrappingFlags {
     ///     default: {                            }
     ///       plop();                             default:
     ///     }                                     {
     ///   }                                         plop();
     ///                                           }
     ///                                         }
     /// \endcode
     bool AfterCaseLabel;
+
     /// Wrap class definitions.
     /// \code
     ///   true:
     ///   class foo
     ///   {};
     ///
     ///   false:
     ///   class foo {};
     /// \endcode
     bool AfterClass;
 
     /// Wrap control statements (``if``/``for``/``while``/``switch``/..).
     BraceWrappingAfterControlStatementStyle AfterControlStatement;
+
+    /// Wrap C# setter/getter properties.
+    /// \code
+    ///   true:
+    ///   string Foo {
+    ///     get
+    ///     {
+    ///       return _foo;
+    ///     }
+    ///     set
+    ///     {
+    ///       _foo = value;
+    ///     }
+    ///   }
+    ///
+    ///   false:
+    ///   string Foo {
+    ///     get {
+    ///       return _foo;
+    ///     }
+    ///     set {
+    ///       return _value
+    ///     }
+    ///   }
+    /// \endcode
+    bool AfterCSharpProperty;
+
     /// Wrap enum definitions.
     /// \code
     ///   true:
     ///   enum X : int
     ///   {
     ///     B
     ///   };
     ///
struct BraceWrappingFlags {
     /// \code
     ///   false:               true:
     ///   namespace Foo   vs.  namespace Foo
     ///   {}                   {
     ///                        }
     /// \endcode
     ///
     bool SplitEmptyNamespace;
+
+    bool operator==(const BraceWrappingFlags &Other) const {
+      return AfterCaseLabel == Other.AfterCaseLabel &&
+             AfterClass == Other.AfterClass &&
+             AfterControlStatement == Other.AfterControlStatement &&
+             AfterCSharpProperty == Other.AfterCSharpProperty &&
+             AfterEnum == Other.AfterEnum &&
+             AfterFunction == Other.AfterFunction &&
+             AfterNamespace == Other.AfterNamespace &&
+             AfterObjCDeclaration == Other.AfterObjCDeclaration &&
+             AfterStruct == Other.AfterStruct &&
+             AfterUnion == Other.AfterUnion &&
+             AfterExternBlock == Other.AfterExternBlock &&
+             BeforeCatch == Other.BeforeCatch &&
+             BeforeElse == Other.BeforeElse &&
+             BeforeLambdaBody == Other.BeforeLambdaBody &&
+             BeforeWhile == Other.BeforeWhile &&
+             IndentBraces == Other.IndentBraces &&
+             SplitEmptyFunction == Other.SplitEmptyFunction &&
+             SplitEmptyRecord == Other.SplitEmptyRecord &&
+             SplitEmptyNamespace == Other.SplitEmptyNamespace;
+    }
   };
 
   /// Control of individual brace wrapping cases.
   ///
   /// If ``BreakBeforeBraces`` is set to ``BS_Custom``, use this to specify how
   /// each individual brace case should be handled. Otherwise, this is ignored.
   /// \code{.yaml}
   ///   # Example of usage:

   /// \code{.yaml}
   ///   WhitespaceSensitiveMacros: ['STRINGIZE', 'PP_STRINGIZE']
   /// \endcode
   ///
   /// For example: BOOST_PP_STRINGIZE
   /// \version 11
   std::vector<std::string> WhitespaceSensitiveMacros;
 
   bool operator==(const FormatStyle &R) const {
     return AccessModifierOffset == R.AccessModifierOffset &&
            AlignAfterOpenBracket == R.AlignAfterOpenBracket &&
            AlignArrayOfStructures == R.AlignArrayOfStructures &&
            AlignConsecutiveAssignments == R.AlignConsecutiveAssignments &&
            AlignConsecutiveBitFields == R.AlignConsecutiveBitFields &&
            AlignConsecutiveDeclarations == R.AlignConsecutiveDeclarations &&
            AlignConsecutiveMacros == R.AlignConsecutiveMacros &&
            AlignEscapedNewlines == R.AlignEscapedNewlines &&

clang/lib/Format/Format.cpp

template <> struct ScalarEnumerationTraits<FormatStyle::BraceBreakingStyle> {
   }
 };
 
 template <> struct MappingTraits<FormatStyle::BraceWrappingFlags> {
   static void mapping(IO &IO, FormatStyle::BraceWrappingFlags &Wrapping) {
     IO.mapOptional("AfterCaseLabel", Wrapping.AfterCaseLabel);
     IO.mapOptional("AfterClass", Wrapping.AfterClass);
     IO.mapOptional("AfterControlStatement", Wrapping.AfterControlStatement);
+    IO.mapOptional("AfterCSharpProperty", Wrapping.AfterCSharpProperty);
     IO.mapOptional("AfterEnum", Wrapping.AfterEnum);
     IO.mapOptional("AfterExternBlock", Wrapping.AfterExternBlock);
     IO.mapOptional("AfterFunction", Wrapping.AfterFunction);
     IO.mapOptional("AfterNamespace", Wrapping.AfterNamespace);
     IO.mapOptional("AfterObjCDeclaration", Wrapping.AfterObjCDeclaration);
     IO.mapOptional("AfterStruct", Wrapping.AfterStruct);
     IO.mapOptional("AfterUnion", Wrapping.AfterUnion);
     IO.mapOptional("BeforeCatch", Wrapping.BeforeCatch);
     IO.mapOptional("BeforeElse", Wrapping.BeforeElse);
     IO.mapOptional("BeforeLambdaBody", Wrapping.BeforeLambdaBody);
     IO.mapOptional("BeforeWhile", Wrapping.BeforeWhile);
     IO.mapOptional("IndentBraces", Wrapping.IndentBraces);

 }
 
 static void expandPresetsBraceWrapping(FormatStyle &Expanded) {
   if (Expanded.BreakBeforeBraces == FormatStyle::BS_Custom)
     return;
   Expanded.BraceWrapping = {/*AfterCaseLabel=*/false,
                             /*AfterClass=*/false,
                             /*AfterControlStatement=*/FormatStyle::BWACS_Never,
+                            /*AfterCSharpProperty=*/false,
                             /*AfterEnum=*/false,
                             /*AfterFunction=*/false,
                             /*AfterNamespace=*/false,
                             /*AfterObjCDeclaration=*/false,
                             /*AfterStruct=*/false,
                             /*AfterUnion=*/false,
                             /*AfterExternBlock=*/false,
                             /*BeforeCatch=*/false,
case FormatStyle::BS_Whitesmiths:
     Expanded.BraceWrapping.BeforeElse = true;
     Expanded.BraceWrapping.BeforeLambdaBody = true;
     break;
   case FormatStyle::BS_GNU:
     Expanded.BraceWrapping = {
         /*AfterCaseLabel=*/true,
         /*AfterClass=*/true,
         /*AfterControlStatement=*/FormatStyle::BWACS_Always,
+        /*AfterCSharpProperty=*/false,
         /*AfterEnum=*/true,
         /*AfterFunction=*/true,
         /*AfterNamespace=*/true,
         /*AfterObjCDeclaration=*/true,
         /*AfterStruct=*/true,
         /*AfterUnion=*/true,
         /*AfterExternBlock=*/true,
         /*BeforeCatch=*/true,
FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) {
   LLVMStyle.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
   LLVMStyle.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_None;
   LLVMStyle.AlwaysBreakBeforeMultilineStrings = false;
   LLVMStyle.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_MultiLine;
   LLVMStyle.AttributeMacros.push_back("__capability");
   LLVMStyle.BitFieldColonSpacing = FormatStyle::BFCS_Both;
   LLVMStyle.BinPackArguments = true;
   LLVMStyle.BinPackParameters = true;
-  LLVMStyle.BraceWrapping = {/*AfterCaseLabel=*/false,
-                             /*AfterClass=*/false,
-                             /*AfterControlStatement=*/FormatStyle::BWACS_Never,
-                             /*AfterEnum=*/false,
-                             /*AfterFunction=*/false,
-                             /*AfterNamespace=*/false,
-                             /*AfterObjCDeclaration=*/false,
-                             /*AfterStruct=*/false,
-                             /*AfterUnion=*/false,
-                             /*AfterExternBlock=*/false,
-                             /*BeforeCatch=*/false,
-                             /*BeforeElse=*/false,
-                             /*BeforeLambdaBody=*/false,
-                             /*BeforeWhile=*/false,
-                             /*IndentBraces=*/false,
-                             /*SplitEmptyFunction=*/true,
-                             /*SplitEmptyRecord=*/true,
-                             /*SplitEmptyNamespace=*/true};
+  LLVMStyle.BraceWrapping = {
+      /*AfterCaseLabel=*/false,
+      /*AfterCSharpProperty=*/false,
+      /*SplitEmptyNamespace=*/true,
+  };
   LLVMStyle.BreakAfterAttributes = FormatStyle::ABS_Never;
   LLVMStyle.BreakAfterJavaFieldAnnotations = false;
   LLVMStyle.BreakArrays = true;
   LLVMStyle.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
   LLVMStyle.BreakBeforeBraces = FormatStyle::BS_Attach;
   LLVMStyle.BreakBeforeConceptDeclarations = FormatStyle::BBCDS_Always;
   LLVMStyle.BreakBeforeInlineASMColon = FormatStyle::BBIAS_OnlyMultiline;
   LLVMStyle.BreakBeforeTernaryOperators = true;

clang/lib/Format/TokenAnnotator.cpp

 //===----------------------------------------------------------------------===//
 
 #include "TokenAnnotator.h"
 #include "FormatToken.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TokenKinds.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Support/Debug.h"
 
 #define DEBUG_TYPE "format-token-annotator"
 
 namespace clang {
 namespace format {
 
 namespace {
 
 /// Returns \c true if the line starts with a token that can start a statement
if (isAllmanBrace(Left) || isAllmanBrace(Right)) {
     // Ensure BraceWrapping for `public interface A {`.
     if (Style.BraceWrapping.AfterClass &&
         ((AccessSpecifier && FirstNonComment->Next &&
           FirstNonComment->Next->is(Keywords.kw_interface)) ||
          Line.startsWith(Keywords.kw_interface))) {
       return true;
     }
 
+    // Handle `string Foo {{set {} get {}}`.
+    if (Style.isCSharp() && Style.BraceWrapping.AfterCSharpProperty &&
+        (Line.startsWith(Keywords.kw_get) ||
+         Line.startsWith(Keywords.kw_set))) {
+      return true;
+    }
+
     // Don't attempt to interpret struct return types as structs.
     if (Right.isNot(TT_FunctionLBrace)) {
       return (Line.startsWith(tok::kw_class) &&
               Style.BraceWrapping.AfterClass) ||
              (Line.startsWith(tok::kw_struct) &&
               Style.BraceWrapping.AfterStruct);
     }
   }
 
+  // Handle default `string Foo {set;get }`.
+  if (Style.isCSharp() && Style.BraceWrapping.AfterCSharpProperty &&
+      ((Left.isOneOf(tok::l_brace, tok::semi) &&
+        Right.isOneOf(Keywords.kw_set, Keywords.kw_get)) ||
+       (Left.is(tok::semi) && Left.Previous &&
+        Left.Previous->isOneOf(Keywords.kw_get, Keywords.kw_set) &&
+        Right.is(tok::r_brace)))) {
+    return true;
+  }
+
   if (Left.is(TT_ObjCBlockLBrace) &&
       Style.AllowShortBlocksOnASingleLine == FormatStyle::SBS_Never) {
     return true;
   }
 
   // Ensure wrapping after __attribute__((XX)) and @interface etc.
   if (Left.is(TT_AttributeParen) && Right.is(TT_ObjCDecl))
     return true;
 
   if (Left.is(TT_LambdaLBrace)) {
     if (IsFunctionArgument(Left) &&
         Style.AllowShortLambdasOnASingleLine == FormatStyle::SLS_Inline) {
       return false;
     }
 
     if (Style.AllowShortLambdasOnASingleLine == FormatStyle::SLS_None ||
         Style.AllowShortLambdasOnASingleLine == FormatStyle::SLS_Inline ||
         (!Left.Children.empty() &&
          Style.AllowShortLambdasOnASingleLine == FormatStyle::SLS_Empty)) {
       return true;
     }
   }
bool TokenAnnotator::mustBreakBefore(const AnnotatedLine &Line,
   //
   // Example: these can stay on one line:
   // a { scalar_1: 1 scalar_2: 2 }
   // a { b { key: value } }
   //
   // and these entries need to be on a new line even if putting them all in one
   // line is under the column limit:
   // a {
   //   scalar: 1
   //   b { key: value }
   // }
   //
   // We enforce this by breaking before a submessage field that has previous
   // siblings, *and* breaking before a field that follows a submessage field.
   //
   // Be careful to exclude the case  [proto.ext] { ... } since the `]` is
   // the TT_SelectorName there, but we don't want to break inside the brackets.
   //
   // Another edge case is @submessage { key: value }, which is a common
   // substitution placeholder. In this case we want to keep `@` and `submessage`
   // together.
   //
   // We ensure elsewhere that extensions are always on their own line.
   if ((Style.Language == FormatStyle::LK_Proto ||
        Style.Language == FormatStyle::LK_TextProto) &&
       Right.is(TT_SelectorName) && !Right.is(tok::r_square) && Right.Next) {
     // Keep `@submessage` together in:
     // @submessage { key: value }
     if (Left.is(tok::at))
       return false;
     // Look for the scope opener after selector in cases like:
     // selector { ...
     // selector: { ...
     // selector: @base { ...
     FormatToken *LBrace = Right.Next;
     if (LBrace && LBrace->is(tok::colon)) {
       LBrace = LBrace->Next;

clang/unittests/Format/FormatTestCSharp.cpp

verifyFormat("namespace union {\n"
                "};",
                Style);
 }
 
 TEST_F(FormatTestCSharp, BrokenBrackets) {
   EXPECT_NE("", format("int where b <")); // reduced from crasher
 }
 
+TEST_F(FormatTestCSharp, PropertyWrapping) {
+  FormatStyle Style = getMicrosoftStyle(FormatStyle::LK_CSharp);
+
+  Style.BraceWrapping.AfterCSharpProperty = false;
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Foo { set; get; }\n"
+               "}",
+               Style);
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Foo { get; set; }\n"
+               "}",
+               Style);
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Foo\n"
+               "    {\n"
+               "        set {\n"
+               "            val = value;\n"
+               "        }\n"
+               "        get {\n"
+               "            return value;\n"
+               "        }\n"
+               "    }\n"
+               "}",
+               Style);
+  /* TODO fix the indentation of get;
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Bar {\n"
+               "        get;\n"
+               "        set {\n"
+               "            val = value;\n"
+               "        }\n"
+               "    }\n"
+               "}",
+               Style);
+  */
+
+  Style.BraceWrapping.AfterCSharpProperty = true;
+
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Bar {\n"
+               "        set;\n"
+               "        get;\n"
+               "    }\n"
+               "}",
+               Style);
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Bar {\n"
+               "        get;\n"
+               "        set;\n"
+               "    }\n"
+               "}",
+               Style);
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Bar\n"
+               "    {\n"
+               "        set\n"
+               "        {\n"
+               "            val = value;\n"
+               "        }\n"
+               "        get\n"
+               "        {\n"
+               "            return value;\n"
+               "        }\n"
+               "    }\n"
+               "}",
+               Style);
+  /* TODO fix the indentation of get;
+  verifyFormat("class A\n"
+             "{\n"
+             "    string Bar {\n"
+             "        get;\n"
+             "        set\n"
+             "        {\n"
+             "            val = value;\n"
+             "        }\n"
+             "    }\n"
+             "}",
+             Style);
+  */
+}
+
 } // namespace format
 } // end namespace clang