[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

5047–5050

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?

5023–5026

Isn't the example wrong?

5043

5051

5058

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

5065–5066

Same here.

5104

Drop

5112–5114

A bit too much parens.

5124

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.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"
+#include <sal.h>
 
 #define DEBUG_TYPE "format-token-annotator"
 
 namespace clang {
 namespace format {
 
 namespace {
 
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.First && Line.First->isOneOf(Keywords.kw_get, Keywords.kw_set,
+                                           Keywords.kw_init))) {
+      return true;
+    }
+
+    // string Foo
+    // {
+    //     set; interal get {};
+    // }
+    if (Style.isCSharp() && Style.BraceWrapping.AfterCSharpProperty &&
+        ((Left.isOneOf(Keywords.kw_set, Keywords.kw_get, Keywords.kw_init) &&
+          Right.is(tok::l_brace) && Left.Previous &&
+          Left.Previous->isOneOf(tok::kw_public, tok::kw_private,
+                                 tok::kw_protected, Keywords.kw_internal)))) {
+      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.AlwaysBreakBetweenShortCSharpProperties &&
+      Left.is(tok::semi) &&
+      Right.isOneOf(Keywords.kw_set, Keywords.kw_get, Keywords.kw_init)) {
+    return true;
+  }
+
+  // Handle non short property on a single line
+  // string Foo {
+  //     set;get;
+  // }
+  if (Style.isCSharp() && !Style.BraceWrapping.AfterFunction &&
+      !Style.AllowShortCSharpPropertiesOnASingleLine) {
+    if (Left.is(tok::l_brace) &&
+        Right.isOneOf(Keywords.kw_set, Keywords.kw_get, Keywords.kw_init)) {
+      return true;
+    }
+    // string Foo {
+    //     <access> set;get;
+    // }
+    if (Left.is(tok::l_brace) &&
+        Right.isOneOf(tok::kw_public, tok::kw_private, tok::kw_protected,
+                      Keywords.kw_internal) &&
+        Right.Next &&
+        Right.Next->isOneOf(Keywords.kw_set, Keywords.kw_get,
+                            Keywords.kw_init)) {
+      return true;
+    }
+    if (Left.is(tok::semi) && Right.is(tok::r_brace) && Left.Previous &&
+        Left.Previous->isOneOf(Keywords.kw_set, Keywords.kw_get,
+                               Keywords.kw_init)) {
+      return true;
+    }
+  }
+
+  if (Style.isCSharp() && Style.BraceWrapping.AfterFunction &&
+      !Style.AllowShortCSharpPropertiesOnASingleLine) {
+    // string Foo
+    // {
+    //     <access> set;get;
+    // }
+    if (Left.is(tok::l_brace) &&
+        Right.isOneOf(tok::kw_public, tok::kw_private, tok::kw_protected,
+                      Keywords.kw_internal) &&
+        Right.Next &&
+        Right.Next->isOneOf(Keywords.kw_set, Keywords.kw_get,
+                            Keywords.kw_init)) {
+      return true;
+    }
+    // string Foo
+    // {
+    //     set; <access> get;
+    // }
+    if (Left.is(tok::semi) &&
+        Right.isOneOf(tok::kw_public, tok::kw_private, tok::kw_protected,
+                      Keywords.kw_internal) &&
+        Right.Next &&
+        Right.Next->isOneOf(Keywords.kw_set, Keywords.kw_get,
+                            Keywords.kw_init)) {
+      return Style.AlwaysBreakBetweenShortCSharpProperties;
+      ;
+    }
+  }
+
+  // string Foo
+  // {
+  //     set; get;
+  // }
+  if (Style.isCSharp() && Style.BraceWrapping.AfterCSharpProperty &&
+      ((Left.is(tok::l_brace) &&
+        Right.isOneOf(Keywords.kw_set, Keywords.kw_get, Keywords.kw_init)))) {
+    return true;
+  }
+
+  // string Foo
+  // {
+  //     set;
+  //     get;
+  // }
+  if (Style.isCSharp() && 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;

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;
 }
 
while (FormatTok->isNot(tok::l_brace)) {
     case tok::kw_mutable:
     case tok::kw_noexcept:
     case tok::kw_static:
       nextToken();
       break;
     // Specialization of a template with an integer parameter can contain
     // arithmetic, logical, comparison and ternary operators.
     //
-    // FIXME: This also accepts sequences of operators that are not in the scope
-    // of a template argument list.
+    // FIXME: This also accepts sequences of operators that are not in the
+    // scope of a template argument list.
     //
     // In a C++ lambda a template type can only occur after an arrow. We use
     // this as an heuristic to distinguish between Objective-C expressions
     // followed by an `a->b` expression, such as:
     // ([obj func:arg] + a->b)
     // Otherwise the code below would parse as a lambda.
     //
     // FIXME: This heuristic is incorrect for C++20 generic lambdas with
void UnwrappedLineParser::tryToParseJSFunction() {
 
   // Parse formal parameter list.
   parseParens();
 
   if (FormatTok->is(tok::colon)) {
     // Parse a type definition.
     nextToken();
 
-    // Eat the type declaration. For braced inline object types, balance braces,
-    // otherwise just parse until finding an l_brace for the function body.
+    // Eat the type declaration. For braced inline object types, balance
+    // braces, otherwise just parse until finding an l_brace for the function
+    // body.
     if (FormatTok->is(tok::l_brace))
       tryToParseBracedList();
     else
       while (!FormatTok->isOneOf(tok::l_brace, tok::semi) && !eof())
         nextToken();
   }
 
   if (FormatTok->is(tok::semi))
case tok::less:
         nextToken();
         parseBracedList(/*ContinueOnSemicolons=*/false, /*IsEnum=*/false,
                         /*ClosingBraceKind=*/tok::greater);
       } else {
         nextToken();
       }
       break;
     case tok::semi:
-      // JavaScript (or more precisely TypeScript) can have semicolons in braced
-      // lists (in so-called TypeMemberLists). Thus, the semicolon cannot be
-      // used for error recovery if we have otherwise determined that this is
-      // a braced list.
+      // JavaScript (or more precisely TypeScript) can have semicolons in
+      // braced lists (in so-called TypeMemberLists). Thus, the semicolon
+      // cannot be used for error recovery if we have otherwise determined
+      // that this is a braced list.
       if (Style.isJavaScript()) {
         nextToken();
         break;
       }
       HasError = true;
       if (!ContinueOnSemicolons)
         return !HasError;
       nextToken();
if (FormatTok->is(tok::l_brace)) {
     // the whole block.
     if (ManageWhitesmithsBraces)
       ++Line->Level;
 
     parseBlock(/*MustBeDeclaration=*/true, AddLevels, /*MunchSemi=*/true,
                /*KeepBraces=*/true, /*IfKind=*/nullptr,
                ManageWhitesmithsBraces);
 
-    // Munch the semicolon after a namespace. This is more common than one would
-    // think. Putting the semicolon into its own line is very ugly.
+    // Munch the semicolon after a namespace. This is more common than one
+    // would think. Putting the semicolon into its own line is very ugly.
     if (FormatTok->is(tok::semi))
       nextToken();
 
     addUnwrappedLine(AddLevels > 0 ? LineLevel::Remove : LineLevel::Keep);
 
     if (ManageWhitesmithsBraces)
       --Line->Level;
   }
do {
     // There should not be a ;, { or } before the new's open paren.
     if (FormatTok->isOneOf(tok::semi, tok::l_brace, tok::r_brace))
       return;
 
     // Consume the parens.
     if (FormatTok->is(tok::l_paren)) {
       parseParens();
 
-      // If there is a class body of an anonymous class, consume that as child.
+      // If there is a class body of an anonymous class, consume that as
+      // child.
       if (FormatTok->is(tok::l_brace))
         parseChildBlock();
       return;
     }
     nextToken();
   } while (!eof());
 }
 
void UnwrappedLineParser::parseForOrWhileLoop(bool HasParens) {
   nextToken();
   // JS' for await ( ...
   if (Style.isJavaScript() && FormatTok->is(Keywords.kw_await))
     nextToken();
   if (Style.isCpp() && FormatTok->is(tok::kw_co_await))
     nextToken();
   if (HasParens && FormatTok->is(tok::l_paren)) {
     // The type is only set for Verilog basically because we were afraid to
-    // change the existing behavior for loops. See the discussion on D121756 for
-    // details.
+    // change the existing behavior for loops. See the discussion on D121756
+    // for details.
     if (Style.isVerilog())
       FormatTok->setFinalizedType(TT_ConditionLParen);
     parseParens();
   }
   // Event control.
   if (Style.isVerilog())
     parseVerilogSensitivityList();
 
bool clang::format::UnwrappedLineParser::parseRequires() {
   nextToken();
 
   switch (FormatTok->Tok.getKind()) {
   case tok::l_brace:
     // This can only be an expression, never a clause.
     parseRequiresExpression(RequiresToken);
     return false;
   case tok::l_paren:
-    // Clauses and expression can start with a paren, it's unclear what we have.
+    // Clauses and expression can start with a paren, it's unclear what we
+    // have.
     break;
   default:
     // All other tokens can only be a clause.
     parseRequiresClause(RequiresToken);
     return true;
   }
 
   // Looking forward we would have to decide if there are function declaration
default:
     // It's an expression.
     parseRequiresExpression(RequiresToken);
     return false;
   }
 
   // Now we look forward and try to check if the paren content is a parameter
   // list. The parameters can be cv-qualified and contain references or
   // pointers.
-  // So we want basically to check for TYPE NAME, but TYPE can contain all kinds
-  // of stuff: typename, const, *, &, &&, ::, identifiers.
+  // So we want basically to check for TYPE NAME, but TYPE can contain all
+  // kinds of stuff: typename, const, *, &, &&, ::, identifiers.
 
   unsigned StoredPosition = Tokens->getPosition();
   FormatToken *NextToken = Tokens->getNextToken();
   int Lookahead = 0;
   auto PeekNext = [&Lookahead, &NextToken, this] {
     ++Lookahead;
     NextToken = Tokens->getNextToken();
   };

 ///
 /// Returns if it either has finished parsing the clause, or it detects, that
 /// the clause is incorrect.
 void UnwrappedLineParser::parseRequiresClause(FormatToken *RequiresToken) {
   assert(FormatTok->getPreviousNonComment() == RequiresToken);
   assert(RequiresToken->is(tok::kw_requires) && "'requires' expected");
 
   // If there is no previous token, we are within a requires expression,
-  // otherwise we will always have the template or function declaration in front
-  // of it.
+  // otherwise we will always have the template or function declaration in
+  // front of it.
   bool InRequiresExpression =
       !RequiresToken->Previous ||
       RequiresToken->Previous->is(TT_RequiresExpressionLBrace);
 
   RequiresToken->setFinalizedType(InRequiresExpression
                                       ? TT_RequiresClauseInARequiresExpression
                                       : TT_RequiresClause);
 
void UnwrappedLineParser::parseRequiresExpression(FormatToken *RequiresToken) {
   }
 }
 
 /// \brief Parses a constraint expression.
 ///
 /// This is the body of a requires clause. It returns, when the parsing is
 /// complete, or the expression is incorrect.
 void UnwrappedLineParser::parseConstraintExpression() {
-  // The special handling for lambdas is needed since tryToParseLambda() eats a
-  // token and if a requires expression is the last part of a requires clause
-  // and followed by an attribute like [[nodiscard]] the ClosesRequiresClause is
-  // not set on the correct token. Thus we need to be aware if we even expect a
-  // lambda to be possible.
-  // template <typename T> requires requires { ... } [[nodiscard]] ...;
+  // The special handling for lambdas is needed since tryToParseLambda() eats
+  // a token and if a requires expression is the last part of a requires
+  // clause and followed by an attribute like [[nodiscard]] the
+  // ClosesRequiresClause is not set on the correct token. Thus we need to be
+  // aware if we even expect a lambda to be possible. template <typename T>
+  // requires requires { ... } [[nodiscard]] ...;
   bool LambdaNextTimeAllowed = true;
 
-  // Within lambda declarations, it is permitted to put a requires clause after
-  // its template parameter list, which would place the requires clause right
-  // before the parentheses of the parameters of the lambda declaration. Thus,
-  // we track if we expect to see grouping parentheses at all.
-  // Without this check, `requires foo<T> (T t)` in the below example would be
-  // seen as the whole requires clause, accidentally eating the parameters of
-  // the lambda.
+  // Within lambda declarations, it is permitted to put a requires clause
+  // after its template parameter list, which would place the requires clause
+  // right before the parentheses of the parameters of the lambda declaration.
+  // Thus, we track if we expect to see grouping parentheses at all. Without
+  // this check, `requires foo<T> (T t)` in the below example would be seen as
+  // the whole requires clause, accidentally eating the parameters of the
+  // lambda.
   // [&]<typename T> requires foo<T> (T t) { ... };
   bool TopLevelParensAllowed = true;
 
   do {
     bool LambdaThisTimeAllowed = std::exchange(LambdaNextTimeAllowed, false);
 
     switch (FormatTok->Tok.getKind()) {
     case tok::kw_requires: {

 
 bool UnwrappedLineParser::parseEnum() {
   const FormatToken &InitialToken = *FormatTok;
 
   // Won't be 'enum' for NS_ENUMs.
   if (FormatTok->is(tok::kw_enum))
     nextToken();
 
-  // In TypeScript, "enum" can also be used as property name, e.g. in interface
-  // declarations. An "enum" keyword followed by a colon would be a syntax
-  // error and thus assume it is just an identifier.
+  // In TypeScript, "enum" can also be used as property name, e.g. in
+  // interface declarations. An "enum" keyword followed by a colon would be a
+  // syntax error and thus assume it is just an identifier.
   if (Style.isJavaScript() && FormatTok->isOneOf(tok::colon, tok::question))
     return false;
 
   // In protobuf, "enum" can be used as a field name.
   if (Style.Language == FormatStyle::LK_Proto && FormatTok->is(tok::equal))
     return false;
 
   // Eat up enum class ...
do {
         calculateBraceTypes(/*ExpectClassBody=*/true);
         if (!tryToParseBracedList())
           break;
       }
       if (FormatTok->is(tok::l_square)) {
         FormatToken *Previous = FormatTok->Previous;
         if (!Previous ||
             !(Previous->is(tok::r_paren) || Previous->isTypeOrIdentifier())) {
-          // Don't try parsing a lambda if we had a closing parenthesis before,
-          // it was probably a pointer to an array: int (*)[].
+          // Don't try parsing a lambda if we had a closing parenthesis
+          // before, it was probably a pointer to an array: int (*)[].
           if (!tryToParseLambda())
             continue;
         } else {
           parseSquare();
           continue;
         }
       }
       if (FormatTok->is(tok::semi))
void UnwrappedLineParser::parseJavaScriptEs6ImportExport() {
   bool IsImport = FormatTok->is(Keywords.kw_import);
   assert(IsImport || FormatTok->is(tok::kw_export));
   nextToken();
 
   // Consume the "default" in "export default class/function".
   if (FormatTok->is(tok::kw_default))
     nextToken();
 
-  // Consume "async function", "function" and "default function", so that these
-  // get parsed as free-standing JS functions, i.e. do not require a trailing
-  // semicolon.
+  // Consume "async function", "function" and "default function", so that
+  // these get parsed as free-standing JS functions, i.e. do not require a
+  // trailing semicolon.
   if (FormatTok->is(Keywords.kw_async))
     nextToken();
   if (FormatTok->is(Keywords.kw_function)) {
     nextToken();
     return;
   }
 
   // For imports, `export *`, `export {...}`, consume the rest of the line up
else if (Tok->isOneOf(tok::star, tok::colon, tok::question, tok::minus))
       Tok->setFinalizedType(TT_VerilogTableItem);
   }
   Line->Level = InitialLevel;
   nextToken(/*LevelDifference=*/-1);
   addUnwrappedLine();
 }
 
 void UnwrappedLineParser::parseVerilogCaseLabel() {
-  // The label will get unindented in AnnotatingParser. If there are no leading
-  // spaces, indent the rest here so that things inside the block will be
-  // indented relative to things outside. We don't use parseLabel because we
-  // don't know whether this colon is a label or a ternary expression at this
-  // point.
+  // The label will get unindented in AnnotatingParser. If there are no
+  // leading spaces, indent the rest here so that things inside the block will
+  // be indented relative to things outside. We don't use parseLabel because
+  // we don't know whether this colon is a label or a ternary expression at
+  // this point.
   auto OrigLevel = Line->Level;
   auto FirstLine = CurrentLines->size();
   if (Line->Level == 0 || (Line->InPPDirective && Line->Level <= 1))
     ++Line->Level;
   else if (!Style.IndentCaseBlocks && Keywords.isVerilogBegin(*FormatTok))
     --Line->Level;
   parseStructuralElement();
   // Restore the indentation in both the new line and the line that has the
void UnwrappedLineParser::addUnwrappedLine(LineLevel AdjustLevel) {
   // information so that the level can be decreased after the line is added.
   // This has to happen after the addition of the line since the line itself
   // needs to be indented.
   bool ClosesWhitesmithsBlock =
       Line->MatchingOpeningBlockLineIndex != UnwrappedLine::kInvalidIndex &&
       Style.BreakBeforeBraces == FormatStyle::BS_Whitesmiths;
 
   // If the current line was expanded from a macro call, we use it to
-  // reconstruct an unwrapped line from the structure of the expanded unwrapped
-  // line and the unexpanded token stream.
+  // reconstruct an unwrapped line from the structure of the expanded
+  // unwrapped line and the unexpanded token stream.
   if (!parsingPPDirective() && !InExpansion && containsExpansion(*Line)) {
     if (!Reconstruct)
       Reconstruct.emplace(Line->Level, Unexpanded);
     Reconstruct->addLine(*Line);
 
     // While the reconstructed unexpanded lines are stored in the normal
     // flow of lines, the expanded lines are stored on the side to be analyzed
     // in an extra step.
continuesLineCommentSection(const FormatToken &FormatTok,
   }
   if (CommentPragmasRegex.match(IndentContent))
     return false;
 
   // If Line starts with a line comment, then FormatTok continues the comment
   // section if its original column is greater or equal to the original start
   // column of the line.
   //
-  // Define the min column token of a line as follows: if a line ends in '{' or
-  // contains a '{' followed by a line comment, then the min column token is
-  // that '{'. Otherwise, the min column token of the line is the first token of
-  // the line.
+  // Define the min column token of a line as follows: if a line ends in '{'
+  // or contains a '{' followed by a line comment, then the min column token
+  // is that '{'. Otherwise, the min column token of the line is the first
+  // token of the line.
   //
   // If Line starts with a token other than a line comment, then FormatTok
   // continues the comment section if its original column is greater than the
   // original start column of the min column token of the line.
   //
   // For example, the second line comment continues the first in these cases:
   //
   // // first line
continuesLineCommentSection(const FormatToken &FormatTok,
 
   return continuesLineComment(FormatTok, /*Previous=*/Line.Tokens.back().Tok,
                               MinColumnToken);
 }
 
 void UnwrappedLineParser::flushComments(bool NewlineBeforeNext) {
   bool JustComments = Line->Tokens.empty();
   for (FormatToken *Tok : CommentsBeforeNextToken) {
-    // Line comments that belong to the same line comment section are put on the
-    // same line since later we might want to reflow content between them.
+    // Line comments that belong to the same line comment section are put on
+    // the same line since later we might want to reflow content between them.
     // Additional fine-grained breaking of line comment sections is controlled
-    // by the class BreakableLineCommentSection in case it is desirable to keep
-    // several line comment sections in the same unwrapped line.
+    // by the class BreakableLineCommentSection in case it is desirable to
+    // keep several line comment sections in the same unwrapped line.
     //
-    // FIXME: Consider putting separate line comment sections as children to the
-    // unwrapped line instead.
+    // FIXME: Consider putting separate line comment sections as children to
+    // the unwrapped line instead.
     Tok->ContinuesLineCommentSection =
         continuesLineCommentSection(*Tok, *Line, CommentPragmasRegex);
     if (isOnNewLine(*Tok) && JustComments && !Tok->ContinuesLineCommentSection)
       addUnwrappedLine();
     pushToken(Tok);
   }
   if (NewlineBeforeNext && JustComments)
     addUnwrappedLine();

 }
 
 void UnwrappedLineParser::distributeComments(
     const SmallVectorImpl<FormatToken *> &Comments,
     const FormatToken *NextTok) {
   // Whether or not a line comment token continues a line is controlled by
   // the method continuesLineCommentSection, with the following caveat:
   //
-  // Define a trail of Comments to be a nonempty proper postfix of Comments such
-  // that each comment line from the trail is aligned with the next token, if
-  // the next token exists. If a trail exists, the beginning of the maximal
-  // trail is marked as a start of a new comment section.
+  // Define a trail of Comments to be a nonempty proper postfix of Comments
+  // such that each comment line from the trail is aligned with the next
+  // token, if the next token exists. If a trail exists, the beginning of the
+  // maximal trail is marked as a start of a new comment section.
   //
   // For example in this code:
   //
   // int a; // line about a
   //   // line 1 about b
   //   // line 2 about b
   //   int b;
   //
-  // the two lines about b form a maximal trail, so there are two sections, the
-  // first one consisting of the single comment "// line about a" and the
+  // the two lines about b form a maximal trail, so there are two sections,
+  // the first one consisting of the single comment "// line about a" and the
   // second one consisting of the next two comments.
   if (Comments.empty())
     return;
   bool ShouldPushCommentsInCurrentLine = true;
   bool HasTrailAlignedWithNextToken = false;
   unsigned StartOfTrailAlignedWithNextToken = 0;
   if (NextTok) {
     // We are skipping the first element intentionally.
while (!Line->InPPDirective && FormatTok->is(tok::hash) &&
       bool SwitchToPreprocessorLines = !Line->Tokens.empty();
       ScopedLineState BlockState(*this, SwitchToPreprocessorLines);
       assert((LevelDifference >= 0 ||
               static_cast<unsigned>(-LevelDifference) <= Line->Level) &&
              "LevelDifference makes Line->Level negative");
       Line->Level += LevelDifference;
       // Comments stored before the preprocessor directive need to be output
       // before the preprocessor directive, at the same level as the
-      // preprocessor directive, as we consider them to apply to the directive.
+      // preprocessor directive, as we consider them to apply to the
+      // directive.
       if (Style.IndentPPDirectives == FormatStyle::PPDIS_BeforeHash &&
           PPBranchLevel > 0) {
         Line->Level += PPBranchLevel;
       }
       flushComments(isOnNewLine(*FormatTok));
       parsePPDirective();
       PreviousWasComment = FormatTok->is(tok::comment);
       FirstNonCommentOnLine = IsFirstNonCommentOnLine(
           FirstNonCommentOnLine, *FormatTok, PreviousWasComment);
     }
 
     if (!PPStack.empty() && (PPStack.back().Kind == PP_Unreachable) &&
         !Line->InPPDirective) {
       continue;
     }
 
     if (FormatTok->is(tok::identifier) &&
         Macros.defined(FormatTok->TokenText) &&
         // FIXME: Allow expanding macros in preprocessor directives.
         !Line->InPPDirective) {
       FormatToken *ID = FormatTok;
       unsigned Position = Tokens->getPosition();
 
-      // To correctly parse the code, we need to replace the tokens of the macro
-      // call with its expansion.
+      // To correctly parse the code, we need to replace the tokens of the
+      // macro call with its expansion.
       auto PreCall = std::move(Line);
       Line.reset(new UnwrappedLine);
       bool OldInExpansion = InExpansion;
       InExpansion = true;
       // We parse the macro call into a new line.
       auto Args = parseMacroCall();
       InExpansion = OldInExpansion;
       assert(Line->Tokens.front().Tok == ID);

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