[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

1644

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

1269

Please sort. :)

4327

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

1644

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

1269

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

5057–5060

clang/unittests/Format/FormatTestCSharp.cpp

1625

Ditto below.

[HazardyKnusperkeks]

clang/include/clang/Format/Format.h

1269

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

1269

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

1269

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?

5035–5038

Isn't the example wrong?

5053

5061

5068

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

5075–5076

Same here.

5114

Drop

5122–5124

A bit too much parens.

5134

Also not needed.

clang/lib/Format/UnwrappedLineParser.cpp

2076–2091

[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

* ``SBS_Always`` (in configuration: ``Always``)
 
     .. code-block:: c++
 
       while (true) {}
       while (true) { continue; }
 
 
 
+.. _AllowShortCSharpPropertiesOnASingleLine:
+
+**AllowShortCSharpPropertiesOnASingleLine** (``Boolean``) :versionbadge:`clang-format 17.0` :ref:`¶ <AllowShortCSharpPropertiesOnASingleLine>`
+  If ``true``, short CSharp properties will be contracted to a single line.
+
+  .. code-block:: c++
+
+    true:                                   false:
+    public string Foo { set; get; }         public string Foo {
+                                              set; get;
+                                            }
+
 .. _AllowShortCaseLabelsOnASingleLine:
 
 **AllowShortCaseLabelsOnASingleLine** (``Boolean``) :versionbadge:`clang-format 3.6` :ref:`¶ <AllowShortCaseLabelsOnASingleLine>`
   If ``true``, short case labels will be contracted to a single line.
 
   .. code-block:: c++
 
     true:                                   false:
**AlwaysBreakBeforeMultilineStrings** (``Boolean``) :versionbadge:`clang-format 3.4` :ref:`¶ <AlwaysBreakBeforeMultilineStrings>`
 
   .. code-block:: c++
 
      true:                                  false:
      aaaa =                         vs.     aaaa = "bbbb"
          "bbbb"                                    "cccc";
          "cccc";
 
+.. _AlwaysBreakBetweenShortCSharpProperties:
+
+**AlwaysBreakBetweenShortCSharpProperties** (``Boolean``) :versionbadge:`clang-format 17.0` :ref:`¶ <AlwaysBreakBetweenShortCSharpProperties>`
+  If ``true``, short CSharp properties will be contracted to a single line.
+
+  .. code-block:: c++
+
+    true:                                   false:
+    public string Foo {                     public string Foo {
+      set;                                    set; get;
+      get;                                  }
+    }
+
 .. _AlwaysBreakTemplateDeclarations:
 
 **AlwaysBreakTemplateDeclarations** (``BreakTemplateDeclarationsStyle``) :versionbadge:`clang-format 3.4` :ref:`¶ <AlwaysBreakTemplateDeclarations>`
   The template declaration breaking style to use.
 
   Possible values:
 
   * ``BTDS_No`` (in configuration: ``No``)
* ``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;``.
+- Add ``AllowShortCSharpPropertiesOnASingleLine`` style to allow C# properties
+  To be on a single line.
+- Add ``AlwaysBreakBetweenShortCSharpProperties`` style to allow C# auto 
+  properties to be split across multiple lines.
 
 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 FormatStyle {
   ///   }                                         break;
   ///                                           case 2:
   ///                                             return;
   ///                                           }
   /// \endcode
   /// \version 3.6
   bool AllowShortCaseLabelsOnASingleLine;
 
+  /// If ``true``, short CSharp properties will be contracted to a single line.
+  /// \code
+  ///   true:                                   false:
+  ///   public string Foo { set; get; }         public string Foo {
+  ///                                             set; get;
+  ///                                           }
+  /// \endcode
+  /// \version 17.0
+  bool AllowShortCSharpPropertiesOnASingleLine;
+
   /// Allow short enums on a single line.
   /// \code
   ///   true:
   ///   enum { A, B } myEnum;
   ///
   ///   false:
   ///   enum {
   ///     A,
enum BreakTemplateDeclarationsStyle : int8_t {
     ///    template <typename T>
     ///    T foo(int aaaaaaaaaaaaaaaaaaaaa,
     ///          int bbbbbbbbbbbbbbbbbbbbb) {
     ///    }
     /// \endcode
     BTDS_Yes
   };
 
+  /// If ``true``, short CSharp properties will be contracted to a single line.
+  /// \code
+  ///   true:                                   false:
+  ///   public string Foo {                     public string Foo {
+  ///     set;                                    set; get;
+  ///     get;                                  }
+  ///   }
+  /// \endcode
+  /// \version 17.0
+  bool AlwaysBreakBetweenShortCSharpProperties;
+
   /// The template declaration breaking style to use.
   /// \version 3.4
   BreakTemplateDeclarationsStyle AlwaysBreakTemplateDeclarations;
 
   /// A vector of strings that should be interpreted as attributes/qualifiers
   /// instead of identifiers. This can be useful for language extensions or
   /// static analyzer annotations.
   ///
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 &&
            AlignOperands == R.AlignOperands &&
            AlignTrailingComments == R.AlignTrailingComments &&
            AllowAllArgumentsOnNextLine == R.AllowAllArgumentsOnNextLine &&
            AllowAllParametersOfDeclarationOnNextLine ==
                R.AllowAllParametersOfDeclarationOnNextLine &&
            AllowShortBlocksOnASingleLine == R.AllowShortBlocksOnASingleLine &&
            AllowShortCaseLabelsOnASingleLine ==
                R.AllowShortCaseLabelsOnASingleLine &&
+           AllowShortCSharpPropertiesOnASingleLine ==
+               R.AllowShortCSharpPropertiesOnASingleLine &&
            AllowShortEnumsOnASingleLine == R.AllowShortEnumsOnASingleLine &&
            AllowShortFunctionsOnASingleLine ==
                R.AllowShortFunctionsOnASingleLine &&
            AllowShortIfStatementsOnASingleLine ==
                R.AllowShortIfStatementsOnASingleLine &&
            AllowShortLambdasOnASingleLine == R.AllowShortLambdasOnASingleLine &&
            AllowShortLoopsOnASingleLine == R.AllowShortLoopsOnASingleLine &&
            AlwaysBreakAfterReturnType == R.AlwaysBreakAfterReturnType &&
            AlwaysBreakBeforeMultilineStrings ==
                R.AlwaysBreakBeforeMultilineStrings &&
+           AlwaysBreakBetweenShortCSharpProperties ==
+               R.AlwaysBreakBetweenShortCSharpProperties &&
            AlwaysBreakTemplateDeclarations ==
                R.AlwaysBreakTemplateDeclarations &&
            AttributeMacros == R.AttributeMacros &&
            BinPackArguments == R.BinPackArguments &&
            BinPackParameters == R.BinPackParameters &&
            BitFieldColonSpacing == R.BitFieldColonSpacing &&
            BreakAfterAttributes == R.BreakAfterAttributes &&
            BreakAfterJavaFieldAnnotations == R.BreakAfterJavaFieldAnnotations &&

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 mapping(IO &IO, FormatStyle &Style) {
     IO.mapOptional("AllowAllArgumentsOnNextLine",
                    Style.AllowAllArgumentsOnNextLine);
     IO.mapOptional("AllowAllParametersOfDeclarationOnNextLine",
                    Style.AllowAllParametersOfDeclarationOnNextLine);
     IO.mapOptional("AllowShortBlocksOnASingleLine",
                    Style.AllowShortBlocksOnASingleLine);
     IO.mapOptional("AllowShortCaseLabelsOnASingleLine",
                    Style.AllowShortCaseLabelsOnASingleLine);
+    IO.mapOptional("AllowShortCSharpPropertiesOnASingleLine",
+                   Style.AllowShortCSharpPropertiesOnASingleLine);
     IO.mapOptional("AllowShortEnumsOnASingleLine",
                    Style.AllowShortEnumsOnASingleLine);
     IO.mapOptional("AllowShortFunctionsOnASingleLine",
                    Style.AllowShortFunctionsOnASingleLine);
     IO.mapOptional("AllowShortIfStatementsOnASingleLine",
                    Style.AllowShortIfStatementsOnASingleLine);
     IO.mapOptional("AllowShortLambdasOnASingleLine",
                    Style.AllowShortLambdasOnASingleLine);
     IO.mapOptional("AllowShortLoopsOnASingleLine",
                    Style.AllowShortLoopsOnASingleLine);
     IO.mapOptional("AlwaysBreakAfterDefinitionReturnType",
                    Style.AlwaysBreakAfterDefinitionReturnType);
     IO.mapOptional("AlwaysBreakAfterReturnType",
                    Style.AlwaysBreakAfterReturnType);
     IO.mapOptional("AlwaysBreakBeforeMultilineStrings",
                    Style.AlwaysBreakBeforeMultilineStrings);
+    IO.mapOptional("AlwaysBreakBetweenShortCSharpProperties",
+                   Style.AlwaysBreakBetweenShortCSharpProperties);
     IO.mapOptional("AlwaysBreakTemplateDeclarations",
                    Style.AlwaysBreakTemplateDeclarations);
     IO.mapOptional("AttributeMacros", Style.AttributeMacros);
     IO.mapOptional("BinPackArguments", Style.BinPackArguments);
     IO.mapOptional("BinPackParameters", Style.BinPackParameters);
     IO.mapOptional("BitFieldColonSpacing", Style.BitFieldColonSpacing);
     IO.mapOptional("BraceWrapping", Style.BraceWrapping);
     IO.mapOptional("BreakAfterAttributes", Style.BreakAfterAttributes);

 }
 
 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.AlignConsecutiveMacros = {};
   LLVMStyle.AlignTrailingComments = {};
   LLVMStyle.AlignTrailingComments.Kind = FormatStyle::TCAS_Always;
   LLVMStyle.AlignTrailingComments.OverEmptyLines = 0;
   LLVMStyle.AllowAllArgumentsOnNextLine = true;
   LLVMStyle.AllowAllParametersOfDeclarationOnNextLine = true;
   LLVMStyle.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;
   LLVMStyle.AllowShortCaseLabelsOnASingleLine = false;
+  LLVMStyle.AllowShortCSharpPropertiesOnASingleLine = true;
   LLVMStyle.AllowShortEnumsOnASingleLine = true;
   LLVMStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
   LLVMStyle.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Never;
   LLVMStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_All;
   LLVMStyle.AllowShortLoopsOnASingleLine = false;
   LLVMStyle.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
   LLVMStyle.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_None;
   LLVMStyle.AlwaysBreakBeforeMultilineStrings = false;
+  LLVMStyle.AlwaysBreakBetweenShortCSharpProperties = 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.h

FormatToken *calculateInitializerColumnList(AnnotatedLine &Line,
                                               FormatToken *CurrentToken,
                                               unsigned Depth) const;
   FormatStyle::PointerAlignmentStyle
   getTokenReferenceAlignment(const FormatToken &PointerOrReference) const;
 
   FormatStyle::PointerAlignmentStyle getTokenPointerOrReferenceAlignment(
       const FormatToken &PointerOrReference) const;
 
+  // Convienience Function for C# properties.
+  bool isCSharpProperty(const FormatToken &Tok) const;
+  bool isCSharpProperty(const FormatToken *Tok) const;
+
+  // Convienience Function for C# accessor.
+  bool isCSharpAccessor(const FormatToken &Tok) const;
+  bool isCSharpAccessor(const FormatToken *Tok) const;
+
   const FormatStyle &Style;
 
   const AdditionalKeywords &Keywords;
 
   SmallVector<ScopeType> Scopes;
 };
 
 } // end namespace format
 } // end namespace clang
 
 #endif

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
static const FormatToken *getFirstNonComment(const AnnotatedLine &Line) {
   const FormatToken *Next = Line.First;
   if (!Next)
     return Next;
   if (Next->is(tok::comment))
     Next = Next->getNextNonComment();
   return Next;
 }
 
+bool TokenAnnotator::isCSharpProperty(const FormatToken &Tok) const {
+  return Tok.isOneOf(Keywords.kw_get, Keywords.kw_set, Keywords.kw_init);
+}
+
+bool TokenAnnotator::isCSharpProperty(const FormatToken *Tok) const {
+  return Tok && isCSharpProperty(*Tok);
+}
+
+bool TokenAnnotator::isCSharpAccessor(const FormatToken &Tok) const {
+  return Tok.isOneOf(Keywords.kw_internal, tok::kw_public, tok::kw_private,
+                     tok::kw_protected);
+}
+bool TokenAnnotator::isCSharpAccessor(const FormatToken *Tok) const {
+  return Tok && isCSharpAccessor(*Tok);
+}
+
 bool TokenAnnotator::mustBreakBefore(const AnnotatedLine &Line,
                                      const FormatToken &Right) const {
   const FormatToken &Left = *Right.Previous;
   if (Right.NewlinesBefore > 1 && Style.MaxEmptyLinesToKeep > 0)
     return true;
 
   if (Style.isCSharp()) {
     if (Left.is(TT_FatArrow) && Right.is(tok::l_brace) &&
if ((Left.is(tok::l_brace) || (Left.is(tok::less) && Left.Previous &&
     // buffers.
     return true;
   }
   if (Right.is(TT_InlineASMBrace))
     return Right.HasUnescapedNewline;
 
   if (isAllmanBrace(Left) || isAllmanBrace(Right)) {
     auto FirstNonComment = getFirstNonComment(Line);
-    bool AccessSpecifier =
-        FirstNonComment &&
-        FirstNonComment->isOneOf(Keywords.kw_internal, tok::kw_public,
-                                 tok::kw_private, tok::kw_protected);
+    bool AccessSpecifier = isCSharpAccessor(FirstNonComment);
 
     if (Style.BraceWrapping.AfterEnum) {
       if (Line.startsWith(tok::kw_enum) ||
           Line.startsWith(tok::kw_typedef, tok::kw_enum)) {
         return true;
       }
       // Ensure BraceWrapping for `public enum A {`.
       if (AccessSpecifier && FirstNonComment->Next &&
           FirstNonComment->Next->is(tok::kw_enum)) {
         return true;
       }
     }
 
     // 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;
     }
 
+    // We need to handle the '{' cases here.
+    // Handle `string Foo {{set {} get {}}`.
+    if (Style.isCSharp() && Style.BraceWrapping.AfterCSharpProperty) {
+      if (isCSharpProperty(Line.First))
+        return true;
+
+      // string Foo
+      // {
+      //     set; internal get
+      //     {}
+      // }
+      if (isCSharpProperty(Left) && Right.is(tok::l_brace) &&
+          isCSharpAccessor(Left.Previous)) {
+        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);
     }
   }
 
+  // The handling of C# properties and auto-properties.
+  if (Style.isCSharp()) {
+    // Handle default `string Foo {set;get }`.
+    if (Style.AlwaysBreakBetweenShortCSharpProperties && Left.is(tok::semi) &&
+        isCSharpProperty(Right)) {
+      return true;
+    }
+
+    // Handle non short property on a single line.
+    // string Foo {
+    //     set;get;
+    // }
+    if (!Style.BraceWrapping.AfterFunction &&
+        !Style.AllowShortCSharpPropertiesOnASingleLine) {
+      if (Left.is(tok::l_brace) && isCSharpProperty(Right))
+        return true;
+      // string Foo {
+      //     <access> set;get;
+      // }
+      if (Left.is(tok::l_brace) && isCSharpAccessor(Right) &&
+          isCSharpProperty(Right.Next)) {
+        return true;
+      }
+      if (Left.is(tok::semi) && Right.is(tok::r_brace) &&
+          isCSharpProperty(Left.Previous)) {
+        return true;
+      }
+    }
+
+    if (Style.BraceWrapping.AfterFunction &&
+        !Style.AllowShortCSharpPropertiesOnASingleLine) {
+      // string Foo
+      // {
+      //     <access> set;get;
+      // }
+      if (Left.is(tok::l_brace) && isCSharpAccessor(Right) &&
+          isCSharpProperty(Right.Next)) {
+        return true;
+      }
+      // string Foo
+      // {
+      //     set; <access> get;
+      // }
+      if (Left.is(tok::semi) && isCSharpAccessor(Right) &&
+          isCSharpProperty(Right.Next)) {
+        return Style.AlwaysBreakBetweenShortCSharpProperties;
+      }
+    }
+
+    // string Foo
+    // {
+    //     set; get;
+    // }
+    if (Style.BraceWrapping.AfterCSharpProperty && Left.is(tok::l_brace) &&
+        isCSharpProperty(Right)) {
+      return true;
+    }
+
+    // string Foo
+    // {
+    //     set;
+    //     get;
+    // }
+    if (Style.BraceWrapping.AfterCSharpProperty && Left.is(tok::semi) &&
+        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;
     }

clang/lib/Format/UnwrappedLineParser.cpp

bool UnwrappedLineParser::tryToParsePropertyAccessor() {
   if (!HasSpecialAccessor) {
     Tokens->setPosition(StoredPosition);
     return false;
   }
 
   // Try to parse the property accessor:
   // https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/properties
   Tokens->setPosition(StoredPosition);
-  if (!IsTrivialPropertyAccessor && Style.BraceWrapping.AfterFunction)
+  if (!IsTrivialPropertyAccessor &&
+      Style.AllowShortCSharpPropertiesOnASingleLine &&
+      Style.BraceWrapping.AfterFunction) {
     addUnwrappedLine();
+  }
+
+  // Handle non short property on a single line
+  // string Foo
+  // {
+  //     set;get;
+  // }
+  if (!Style.AllowShortCSharpPropertiesOnASingleLine &&
+      Style.BraceWrapping.AfterFunction) {
+    addUnwrappedLine();
+  }
+
   nextToken();
   do {
     switch (FormatTok->Tok.getKind()) {
     case tok::r_brace:
       nextToken();
       if (FormatTok->is(tok::equal)) {
         while (!eof() && FormatTok->isNot(tok::semi))
           nextToken();
         nextToken();
       }
       addUnwrappedLine();
       return true;
+    case tok::semi:
+      if (!IsTrivialPropertyAccessor) {
+        ++Line->Level;
+        nextToken();
+        addUnwrappedLine();
+        --Line->Level;
+        break;
+      }
+      nextToken();
+      break;
     case tok::l_brace:
       ++Line->Level;
       parseBlock(/*MustBeDeclaration=*/true);
       addUnwrappedLine();
       --Line->Level;
       break;
     case tok::equal:
       if (FormatTok->is(TT_FatArrow)) {
         ++Line->Level;
         do {
           nextToken();
         } while (!eof() && FormatTok->isNot(tok::semi));
         nextToken();
         addUnwrappedLine();
         --Line->Level;
         break;
       }
       nextToken();
       break;
     default:
-      if (FormatTok->isOneOf(Keywords.kw_get, Keywords.kw_init,
-                             Keywords.kw_set) &&
+      bool WrappedAlready = false;
+      if (FormatTok->isOneOf(Keywords.kw_internal, tok::kw_private,
+                             tok::kw_public, tok::kw_protected) &&
           !IsTrivialPropertyAccessor) {
         // Non-trivial get/set needs to be on its own line.
         addUnwrappedLine();
+        nextToken();
+        WrappedAlready = true;
       }
+      if (FormatTok->isOneOf(Keywords.kw_get, Keywords.kw_init, Keywords.kw_set,
+                             Keywords.kw_internal, tok::kw_private,
+                             tok::kw_public, tok::kw_protected) &&
+          !IsTrivialPropertyAccessor) {
+        // Non-trivial get/set needs to be on its own line.
+        if (!WrappedAlready)
+          addUnwrappedLine();
+      }
+
       nextToken();
     }
   } while (!eof());
 
   // Unreachable for well-formed code (paired '{' and '}').
   return true;
 }
 

clang/unittests/Format/FormatTestCSharp.cpp

protected:
   }
 
   static FormatStyle getStyleWithColumns(unsigned ColumnLimit) {
     FormatStyle Style = getMicrosoftStyle(FormatStyle::LK_CSharp);
     Style.ColumnLimit = ColumnLimit;
     return Style;
   }
 
-  static void verifyFormat(
-      llvm::StringRef Code,
+  static void _verifyFormat(
+      const char *File, int Line, llvm::StringRef Code,
       const FormatStyle &Style = getMicrosoftStyle(FormatStyle::LK_CSharp)) {
+    ::testing::ScopedTrace t(File, Line, ::testing::Message() << Code.str());
     EXPECT_EQ(Code.str(), format(Code, Style)) << "Expected code is not stable";
     EXPECT_EQ(Code.str(), format(test::messUp(Code), Style));
   }
 };
 
+#define verifyFormat(...) _verifyFormat(__FILE__, __LINE__, __VA_ARGS__)
+
 TEST_F(FormatTestCSharp, CSharpClass) {
   verifyFormat("public class SomeClass\n"
                "{\n"
                "    void f()\n"
                "    {\n"
                "    }\n"
                "    int g()\n"
                "    {\n"
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;
+  Style.AllowShortCSharpPropertiesOnASingleLine = true;
+  Style.AlwaysBreakBetweenShortCSharpProperties = false;
+  Style.BraceWrapping.AfterFunction = true;
+
+  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 { get; init; }\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);
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Foo\n"
+               "    {\n"
+               "        init {\n"
+               "            val = value;\n"
+               "        }\n"
+               "        get {\n"
+               "            return value;\n"
+               "        }\n"
+               "    }\n"
+               "}",
+               Style);
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Foo\n"
+               "    {\n"
+               "        get;\n"
+               "        set {\n"
+               "            val = value;\n"
+               "        }\n"
+               "    }\n"
+               "}",
+               Style);
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Foo\n"
+               "    {\n"
+               "        get;\n"
+               "        init {\n"
+               "            val = value;\n"
+               "        }\n"
+               "    }\n"
+               "}",
+               Style);
+
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Foo { private set; get; }\n"
+               "}",
+               Style);
+
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Foo { set; public get; }\n"
+               "}",
+               Style);
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Foo\n"
+               "    {\n"
+               "        get;\n"
+               "        public init {\n"
+               "            val = value;\n"
+               "        }\n"
+               "    }\n"
+               "}",
+               Style);
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Foo\n"
+               "    {\n"
+               "        public init {\n"
+               "            val = value;\n"
+               "        }\n"
+               "        get;\n"
+               "    }\n"
+               "}",
+               Style);
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Foo\n"
+               "    {\n"
+               "        public get;\n"
+               "        init {\n"
+               "            val = value;\n"
+               "        }\n"
+               "    }\n"
+               "}",
+               Style);
+
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Foo\n"
+               "    {\n"
+               "        get;\n"
+               "        public init {\n"
+               "            val = value;\n"
+               "        }\n"
+               "    }\n"
+               "}",
+               Style);
+
+  Style.BraceWrapping.AfterCSharpProperty = true;
+  Style.AllowShortCSharpPropertiesOnASingleLine = false;
+  Style.AlwaysBreakBetweenShortCSharpProperties = true;
+  Style.BraceWrapping.AfterFunction = true;
+
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Bar\n"
+               "    {\n"
+               "        set;\n"
+               "        get;\n"
+               "    }\n"
+               "}",
+               Style);
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Bar\n"
+               "    {\n"
+               "        get;\n"
+               "        set;\n"
+               "    }\n"
+               "}",
+               Style);
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Bar\n"
+               "    {\n"
+               "        get;\n"
+               "        init;\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);
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Bar\n"
+               "    {\n"
+               "        init\n"
+               "        {\n"
+               "            val = value;\n"
+               "        }\n"
+               "        get\n"
+               "        {\n"
+               "            return value;\n"
+               "        }\n"
+               "    }\n"
+               "}",
+               Style);
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Bar\n"
+               "    {\n"
+               "        get;\n"
+               "        set\n"
+               "        {\n"
+               "            val = value;\n"
+               "        }\n"
+               "    }\n"
+               "}",
+               Style);
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Bar\n"
+               "    {\n"
+               "        get;\n"
+               "        init\n"
+               "        {\n"
+               "            val = value;\n"
+               "        }\n"
+               "    }\n"
+               "}",
+               Style);
+
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Bar\n"
+               "    {\n"
+               "        private set;\n"
+               "        get;\n"
+               "    }\n"
+               "}",
+               Style);
+
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Bar\n"
+               "    {\n"
+               "        set;\n"
+               "        internal get;\n"
+               "    }\n"
+               "}",
+               Style);
+
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Bar6\n"
+               "    {\n"
+               "        set;\n"
+               "        internal get\n"
+               "        {\n"
+               "            return value;\n"
+               "        };\n"
+               "    }\n"
+               "}",
+               Style);
+
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Bar5\n"
+               "    {\n"
+               "        internal get\n"
+               "        {\n"
+               "            return value;\n"
+               "        };\n"
+               "        set;\n"
+               "    }\n"
+               "}",
+               Style);
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Bar\n"
+               "    {\n"
+               "        internal set;\n"
+               "        get\n"
+               "        {\n"
+               "            return value;\n"
+               "        };\n"
+               "    }\n"
+               "}",
+               Style);
+
+  Style.BraceWrapping.AfterCSharpProperty = true;
+  Style.AllowShortCSharpPropertiesOnASingleLine = false;
+  Style.AlwaysBreakBetweenShortCSharpProperties = false;
+  Style.BraceWrapping.AfterFunction = true;
+
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Bar\n"
+               "    {\n"
+               "        set; get;\n"
+               "    }\n"
+               "}",
+               Style);
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Bar\n"
+               "    {\n"
+               "        get; set;\n"
+               "    }\n"
+               "}",
+               Style);
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Bar\n"
+               "    {\n"
+               "        init; get;\n"
+               "    }\n"
+               "}",
+               Style);
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Bar\n"
+               "    {\n"
+               "        internal set; get;\n"
+               "    }\n"
+               "}",
+               Style);
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Bar\n"
+               "    {\n"
+               "        set; protected get;\n"
+               "    }\n"
+               "}",
+               Style);
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Bar\n"
+               "    {\n"
+               "        set;\n"
+               "        protected get\n"
+               "        {\n"
+               "            return value;\n"
+               "        }\n"
+               "    }\n"
+               "}",
+               Style);
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Bar\n"
+               "    {\n"
+               "        public get\n"
+               "        {\n"
+               "            return value;\n"
+               "        }\n"
+               "        set;\n"
+               "    }\n"
+               "}",
+               Style);
+
+  Style.BraceWrapping.AfterCSharpProperty = false;
+  Style.AllowShortCSharpPropertiesOnASingleLine = false;
+  Style.AlwaysBreakBetweenShortCSharpProperties = false;
+  Style.BraceWrapping.AfterFunction = false;
+
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Bar1 {\n"
+               "        set; get;\n"
+               "    }\n"
+               "}",
+               Style);
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Bar1 {\n"
+               "        get; set;\n"
+               "    }\n"
+               "}",
+               Style);
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Bar1 {\n"
+               "        init; get;\n"
+               "    }\n"
+               "}",
+               Style);
+
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Bar2 {\n"
+               "        public set; get;\n"
+               "    }\n"
+               "}",
+               Style);
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Bar2 {\n"
+               "        set; private get;\n"
+               "    }\n"
+               "}",
+               Style);
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Bar3 {\n"
+               "        set { value = 123 }\n"
+               "        get;\n"
+               "    }\n"
+               "}",
+               Style);
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Bar4 {\n"
+               "        get;\n"
+               "        set { value = 123 }\n"
+               "    }\n"
+               "}",
+               Style);
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Bar4 {\n"
+               "        private get;\n"
+               "        set { value = 123 }\n"
+               "    }\n"
+               "}",
+               Style);
+  verifyFormat("class A\n"
+               "{\n"
+               "    string Bar4 {\n"
+               "        get;\n"
+               "        private set { value = 123 }\n"
+               "    }\n"
+               "}",
+               Style);
+}
+
 } // namespace format
 } // end namespace clang