This is an archive of the discontinued LLVM Phabricator instance.

Differential D93170

[clang-format][NFC] Expand BreakBeforeBraces examples
ClosedPublic

Authored by HazardyKnusperkeks on Dec 12 2020, 2:20 PM.

Details

Reviewers
MyDeveloperDay
Commits
rG5e5ef5359742: [clang-format][NFC] Expand BreakBeforeBraces examples

Diff Detail

Event Timeline

HazardyKnusperkeks requested review of this revision.Dec 12 2020, 2:20 PM
HazardyKnusperkeks created this revision.
Herald added a project: Restricted Project. · View Herald TranscriptDec 12 2020, 2:20 PM
Herald added a subscriber: cfe-commits. · View Herald Transcript
Harbormaster completed remote builds in B82162: Diff 311413.Dec 12 2020, 2:58 PM
MyDeveloperDay accepted this revision.Dec 13 2020, 4:46 AM

We should have the same examples added to the unit tests so we know they are correct (and stay correct)

But I really appreciate the documentation effort

This revision is now accepted and ready to land.Dec 13 2020, 4:46 AM
This revision was landed with ongoing or failed builds.Dec 18 2020, 10:08 AM
Closed by commit rG5e5ef5359742: [clang-format][NFC] Expand BreakBeforeBraces examples (authored by HazardyKnusperkeks). · Explain Why
This revision was automatically updated to reflect the committed changes.
HazardyKnusperkeks added a commit: rG5e5ef5359742: [clang-format][NFC] Expand BreakBeforeBraces examples.

Revision Contents

PathSize
clang/
docs/
446 lines
include/
clang/
Format/
446 lines

Diff 312842

clang/docs/ClangFormatStyleOptions.rst

Show First 20 Lines • Show All 1,199 Lines • ▼ Show 20 Lines**BreakBeforeBraces** (``BraceBreakingStyle``)
Possible values: Possible values:
* ``BS_Attach`` (in configuration: ``Attach``) * ``BS_Attach`` (in configuration: ``Attach``)
Always attach braces to surrounding context. Always attach braces to surrounding context.
.. code-block:: c++ .. code-block:: c++
namespace N {
enum E {
E1,
E2,
};
class C {
public:
C();
};
bool baz(int i) {
try { try {
foo(); do {
} catch () { switch (i) {
case 1: {
foobar();
break;
} }
void foo() { bar(); } default: {
class foo {}; break;
if (foo()) { }
}
} while (--i);
return true;
} catch (...) {
handleError();
return false;
}
}
void foo(bool b) {
if (b) {
baz(2);
} else { } else {
baz(5);
} }
enum X : int { A, B }; }
void bar() { foo(true); }
} // namespace N
* ``BS_Linux`` (in configuration: ``Linux``) * ``BS_Linux`` (in configuration: ``Linux``)
Like ``Attach``, but break before braces on function, namespace and Like ``Attach``, but break before braces on function, namespace and
class definitions. class definitions.
.. code-block:: c++ .. code-block:: c++
namespace N
{
enum E {
E1,
E2,
};
class C
{
public:
C();
};
bool baz(int i)
{
try { try {
foo(); do {
} catch () { switch (i) {
case 1: {
foobar();
break;
} }
void foo() { bar(); } default: {
class foo break;
}
}
} while (--i);
return true;
} catch (...) {
handleError();
return false;
}
}
void foo(bool b)
{ {
}; if (b) {
if (foo()) { baz(2);
} else { } else {
baz(5);
} }
enum X : int { A, B }; }
void bar() { foo(true); }
} // namespace N
* ``BS_Mozilla`` (in configuration: ``Mozilla``) * ``BS_Mozilla`` (in configuration: ``Mozilla``)
Like ``Attach``, but break before braces on enum, function, and record Like ``Attach``, but break before braces on enum, function, and record
definitions. definitions.
.. code-block:: c++ .. code-block:: c++
namespace N {
enum E
{
E1,
E2,
};
class C
{
public:
C();
};
bool baz(int i)
{
try { try {
foo(); do {
} catch () { switch (i) {
case 1: {
foobar();
break;
} }
void foo() { bar(); } default: {
class foo break;
}
}
} while (--i);
return true;
} catch (...) {
handleError();
return false;
}
}
void foo(bool b)
{ {
}; if (b) {
if (foo()) { baz(2);
} else { } else {
baz(5);
} }
enum X : int { A, B }; }
void bar() { foo(true); }
} // namespace N
* ``BS_Stroustrup`` (in configuration: ``Stroustrup``) * ``BS_Stroustrup`` (in configuration: ``Stroustrup``)
Like ``Attach``, but break before function definitions, ``catch``, and Like ``Attach``, but break before function definitions, ``catch``, and
``else``. ``else``.
.. code-block:: c++ .. code-block:: c++
namespace N {
enum E {
E1,
E2,
};
class C {
public:
C();
};
bool baz(int i)
{
try { try {
foo(); do {
switch (i) {
case 1: {
foobar();
break;
} }
catch () { default: {
break;
} }
void foo() { bar(); } }
class foo { } while (--i);
}; return true;
if (foo()) { }
catch (...) {
handleError();
return false;
}
}
void foo(bool b)
{
if (b) {
baz(2);
} }
else { else {
baz(5);
}
} }
enum X : int { A, B };
void bar() { foo(true); }
} // namespace N
* ``BS_Allman`` (in configuration: ``Allman``) * ``BS_Allman`` (in configuration: ``Allman``)
Always break before braces. Always break before braces.
.. code-block:: c++ .. code-block:: c++
namespace N
{
enum E
{
E1,
E2,
};
class C
{
public:
C();
};
bool baz(int i)
{
try try
{ {
foo(); do
{
switch (i)
{
case 1:
{
foobar();
break;
} }
catch () default:
{ {
break;
} }
void foo() { bar(); } }
class foo } while (--i);
return true;
}
catch (...)
{ {
}; handleError();
if (foo()) return false;
}
}
void foo(bool b)
{
if (b)
{ {
baz(2);
} }
else else
{ {
baz(5);
}
} }
enum X : int
{ void bar() { foo(true); }
A, } // namespace N
B
};
* ``BS_Whitesmiths`` (in configuration: ``Whitesmiths``) * ``BS_Whitesmiths`` (in configuration: ``Whitesmiths``)
Like ``Allman`` but always indent braces and line up code with braces. Like ``Allman`` but always indent braces and line up code with braces.
.. code-block:: c++ .. code-block:: c++
namespace N
{
enum E
{
E1,
E2,
};
class C
{
public:
C();
};
bool baz(int i)
{
try try
{ {
foo(); do
{
switch (i)
{
case 1:
{
foobar();
break;
} }
catch () default:
{ {
break;
} }
void foo() { bar(); } }
class foo } while (--i);
return true;
}
catch (...)
{ {
}; handleError();
if (foo()) return false;
}
}
void foo(bool b)
{ {
if (b)
{
baz(2);
} }
else else
{ {
baz(5);
} }
enum X : int }
{
A, void bar() { foo(true); }
B } // namespace N
};
* ``BS_GNU`` (in configuration: ``GNU``) * ``BS_GNU`` (in configuration: ``GNU``)
Always break before braces and add an extra level of indentation to Always break before braces and add an extra level of indentation to
braces of control statements, not to those of class, function braces of control statements, not to those of class, function
or other definitions. or other definitions.
.. code-block:: c++ .. code-block:: c++
namespace N
{
enum E
{
E1,
E2,
};
class C
{
public:
C();
};
bool baz(int i)
{
try try
{ {
foo(); do
{
switch (i)
{
case 1:
{
foobar();
break;
} }
catch () default:
{ {
break;
} }
void foo() { bar(); } }
class foo }
while (--i);
return true;
}
catch (...)
{ {
}; handleError();
if (foo()) return false;
}
}
void foo(bool b)
{
if (b)
{ {
baz(2);
} }
else else
{ {
baz(5);
}
} }
enum X : int
{ void bar() { foo(true); }
A, } // namespace N
B
};
* ``BS_WebKit`` (in configuration: ``WebKit``) * ``BS_WebKit`` (in configuration: ``WebKit``)
Like ``Attach``, but break before functions. Like ``Attach``, but break before functions.
.. code-block:: c++ .. code-block:: c++
namespace N {
enum E {
E1,
E2,
};
class C {
public:
C();
};
bool baz(int i)
{
try { try {
foo(); do {
} catch () { switch (i) {
case 1: {
foobar();
break;
} }
void foo() { bar(); } default: {
class foo { break;
}; }
if (foo()) { }
} while (--i);
return true;
} catch (...) {
handleError();
return false;
}
}
void foo(bool b)
{
if (b) {
baz(2);
} else { } else {
baz(5);
}
} }
enum X : int { A, B };
void bar() { foo(true); }
} // namespace N
* ``BS_Custom`` (in configuration: ``Custom``) * ``BS_Custom`` (in configuration: ``Custom``)
Configure each individual brace in `BraceWrapping`. Configure each individual brace in `BraceWrapping`.
**BreakBeforeConceptDeclarations** (``bool``) **BreakBeforeConceptDeclarations** (``bool``)
If ``true``, concept will be placed on a new line. If ``true``, concept will be placed on a new line.
▲ Show 20 Lines • Show All 1,629 Lines • Show Last 20 Lines

clang/include/clang/Format/Format.h

Show First 20 Lines • Show All 714 Lines • ▼ Show 20 Linesstruct FormatStyle {
/// The way to wrap binary operators. /// The way to wrap binary operators.
BinaryOperatorStyle BreakBeforeBinaryOperators; BinaryOperatorStyle BreakBeforeBinaryOperators;
/// Different ways to attach braces to their surrounding context. /// Different ways to attach braces to their surrounding context.
enum BraceBreakingStyle { enum BraceBreakingStyle {
/// Always attach braces to surrounding context. /// Always attach braces to surrounding context.
/// \code /// \code
/// namespace N {
/// enum E {
/// E1,
/// E2,
/// };
///
/// class C {
/// public:
/// C();
/// };
///
/// bool baz(int i) {
/// try { /// try {
/// foo(); /// do {
/// } catch () { /// switch (i) {
/// case 1: {
/// foobar();
/// break;
/// } /// }
/// void foo() { bar(); } /// default: {
/// class foo {}; /// break;
/// if (foo()) { /// }
/// }
/// } while (--i);
/// return true;
/// } catch (...) {
/// handleError();
/// return false;
/// }
/// }
///
/// void foo(bool b) {
/// if (b) {
/// baz(2);
/// } else { /// } else {
/// baz(5);
/// }
/// } /// }
/// enum X : int { A, B }; ///
/// void bar() { foo(true); }
/// } // namespace N
/// \endcode /// \endcode
BS_Attach, BS_Attach,
/// Like ``Attach``, but break before braces on function, namespace and /// Like ``Attach``, but break before braces on function, namespace and
/// class definitions. /// class definitions.
/// \code /// \code
/// namespace N
/// {
/// enum E {
/// E1,
/// E2,
/// };
///
/// class C
/// {
/// public:
/// C();
/// };
///
/// bool baz(int i)
/// {
/// try { /// try {
/// foo(); /// do {
/// } catch () { /// switch (i) {
/// case 1: {
/// foobar();
/// break;
/// } /// }
/// void foo() { bar(); } /// default: {
/// class foo /// break;
/// }
/// }
/// } while (--i);
/// return true;
/// } catch (...) {
/// handleError();
/// return false;
/// }
/// }
///
/// void foo(bool b)
/// { /// {
/// }; /// if (b) {
/// if (foo()) { /// baz(2);
/// } else { /// } else {
/// baz(5);
/// } /// }
/// enum X : int { A, B }; /// }
///
/// void bar() { foo(true); }
/// } // namespace N
/// \endcode /// \endcode
BS_Linux, BS_Linux,
/// Like ``Attach``, but break before braces on enum, function, and record /// Like ``Attach``, but break before braces on enum, function, and record
/// definitions. /// definitions.
/// \code /// \code
/// namespace N {
/// enum E
/// {
/// E1,
/// E2,
/// };
///
/// class C
/// {
/// public:
/// C();
/// };
///
/// bool baz(int i)
/// {
/// try { /// try {
/// foo(); /// do {
/// } catch () { /// switch (i) {
/// case 1: {
/// foobar();
/// break;
/// } /// }
/// void foo() { bar(); } /// default: {
/// class foo /// break;
/// }
/// }
/// } while (--i);
/// return true;
/// } catch (...) {
/// handleError();
/// return false;
/// }
/// }
///
/// void foo(bool b)
/// { /// {
/// }; /// if (b) {
/// if (foo()) { /// baz(2);
/// } else { /// } else {
/// baz(5);
/// } /// }
/// enum X : int { A, B }; /// }
///
/// void bar() { foo(true); }
/// } // namespace N
/// \endcode /// \endcode
BS_Mozilla, BS_Mozilla,
/// Like ``Attach``, but break before function definitions, ``catch``, and /// Like ``Attach``, but break before function definitions, ``catch``, and
/// ``else``. /// ``else``.
/// \code /// \code
/// namespace N {
/// enum E {
/// E1,
/// E2,
/// };
///
/// class C {
/// public:
/// C();
/// };
///
/// bool baz(int i)
/// {
/// try { /// try {
/// foo(); /// do {
/// switch (i) {
/// case 1: {
/// foobar();
/// break;
/// } /// }
/// catch () { /// default: {
/// break;
/// } /// }
/// void foo() { bar(); } /// }
/// class foo { /// } while (--i);
/// }; /// return true;
/// if (foo()) { /// }
/// catch (...) {
/// handleError();
/// return false;
/// }
/// }
///
/// void foo(bool b)
/// {
/// if (b) {
/// baz(2);
/// } /// }
/// else { /// else {
/// baz(5);
/// }
/// } /// }
/// enum X : int { A, B }; ///
/// void bar() { foo(true); }
/// } // namespace N
/// \endcode /// \endcode
BS_Stroustrup, BS_Stroustrup,
/// Always break before braces. /// Always break before braces.
/// \code /// \code
/// namespace N
/// {
/// enum E
/// {
/// E1,
/// E2,
/// };
///
/// class C
/// {
/// public:
/// C();
/// };
///
/// bool baz(int i)
/// {
/// try /// try
/// { /// {
/// foo(); /// do
/// {
/// switch (i)
/// {
/// case 1:
/// {
/// foobar();
/// break;
/// } /// }
/// catch () /// default:
/// { /// {
/// break;
/// } /// }
/// void foo() { bar(); } /// }
/// class foo /// } while (--i);
/// return true;
/// }
/// catch (...)
/// { /// {
/// }; /// handleError();
/// if (foo()) /// return false;
/// }
/// }
///
/// void foo(bool b)
/// {
/// if (b)
/// { /// {
/// baz(2);
/// } /// }
/// else /// else
/// { /// {
/// baz(5);
/// } /// }
/// enum X : int /// }
/// { ///
/// A, /// void bar() { foo(true); }
/// B /// } // namespace N
/// };
/// \endcode /// \endcode
BS_Allman, BS_Allman,
/// Like ``Allman`` but always indent braces and line up code with braces. /// Like ``Allman`` but always indent braces and line up code with braces.
/// \code /// \code
/// namespace N
/// {
/// enum E
/// {
/// E1,
/// E2,
/// };
///
/// class C
/// {
/// public:
/// C();
/// };
///
/// bool baz(int i)
/// {
/// try /// try
/// { /// {
/// foo(); /// do
/// {
/// switch (i)
/// {
/// case 1:
/// {
/// foobar();
/// break;
/// } /// }
/// catch () /// default:
/// { /// {
/// break;
/// } /// }
/// void foo() { bar(); } /// }
/// class foo /// } while (--i);
/// return true;
/// }
/// catch (...)
/// { /// {
/// }; /// handleError();
/// if (foo()) /// return false;
/// }
/// }
///
/// void foo(bool b)
/// { /// {
/// if (b)
/// {
/// baz(2);
/// } /// }
/// else /// else
/// { /// {
/// baz(5);
/// } /// }
/// enum X : int /// }
/// { ///
/// A, /// void bar() { foo(true); }
/// B /// } // namespace N
/// };
/// \endcode /// \endcode
BS_Whitesmiths, BS_Whitesmiths,
/// Always break before braces and add an extra level of indentation to /// Always break before braces and add an extra level of indentation to
/// braces of control statements, not to those of class, function /// braces of control statements, not to those of class, function
/// or other definitions. /// or other definitions.
/// \code /// \code
/// namespace N
/// {
/// enum E
/// {
/// E1,
/// E2,
/// };
///
/// class C
/// {
/// public:
/// C();
/// };
///
/// bool baz(int i)
/// {
/// try /// try
/// { /// {
/// foo(); /// do
/// {
/// switch (i)
/// {
/// case 1:
/// {
/// foobar();
/// break;
/// } /// }
/// catch () /// default:
/// { /// {
/// break;
/// } /// }
/// void foo() { bar(); } /// }
/// class foo /// }
/// while (--i);
/// return true;
/// }
/// catch (...)
/// { /// {
/// }; /// handleError();
/// if (foo()) /// return false;
/// }
/// }
///
/// void foo(bool b)
/// {
/// if (b)
/// { /// {
/// baz(2);
/// } /// }
/// else /// else
/// { /// {
/// baz(5);
/// } /// }
/// enum X : int /// }
/// { ///
/// A, /// void bar() { foo(true); }
/// B /// } // namespace N
/// };
/// \endcode /// \endcode
BS_GNU, BS_GNU,
/// Like ``Attach``, but break before functions. /// Like ``Attach``, but break before functions.
/// \code /// \code
/// namespace N {
/// enum E {
/// E1,
/// E2,
/// };
///
/// class C {
/// public:
/// C();
/// };
///
/// bool baz(int i)
/// {
/// try { /// try {
/// foo(); /// do {
/// } catch () { /// switch (i) {
/// case 1: {
/// foobar();
/// break;
/// } /// }
/// void foo() { bar(); } /// default: {
/// class foo { /// break;
/// }; /// }
/// if (foo()) { /// }
/// } while (--i);
/// return true;
/// } catch (...) {
/// handleError();
/// return false;
/// }
/// }
///
/// void foo(bool b)
/// {
/// if (b) {
/// baz(2);
/// } else { /// } else {
/// baz(5);
/// } /// }
/// enum X : int { A, B }; /// }
///
/// void bar() { foo(true); }
/// } // namespace N
/// \endcode /// \endcode
BS_WebKit, BS_WebKit,
/// Configure each individual brace in `BraceWrapping`. /// Configure each individual brace in `BraceWrapping`.
BS_Custom BS_Custom
}; };
/// The brace breaking style to use. /// The brace breaking style to use.
BraceBreakingStyle BreakBeforeBraces; BraceBreakingStyle BreakBeforeBraces;
▲ Show 20 Lines • Show All 1,977 Lines • Show Last 20 Lines