Clang-Formatの書式について

clang-formatを用いてコードを整形する際のコマンドライン引数又は定義ファイル(.clang-format)の書式についての説明になります。

なお、本稿は以下の公式ドキュメントの記述に、解説を付与した内容となります。
(全文の直訳ではありません。噛み砕いて解釈を追加したものとなります。)

前提条件

本稿を記載の為、以下の環境での確認をおこなっています。
・RHEL9.0、clang-format 15.0
・Windows10Pro 21H2、VSCode1.69.2、clang-format 8.0.1

１. 指定方法及び基本的な書式について

大きく2通りの指定方法がある。

その１．コマンドライン引数としてパラメータを指定する

書式例

clang-format --style="{ BasedOnStyle: LLVM, IndentWidth: 4 }" input_file_name.cpp

その２．コマンドライン引数として設定ファイルを指定する

書式例

clang-format --style=file:"~/project_dir/.clang-format" input_file_name.cpp

clang-formatのコマンドオプションの詳細は以下を参照。

また、VSCodeで使用の際は設定ファイルより値を指定する方法となる。
設定ファイルは、「.clang-format」の名称で作成する。
作成したファイルは、ソースコード直下又はC_Cpp:Clang_format_pathにて指定したパスから読み込みを行う。
C_Cpp:Clang_format_pathの設定方法は次を参照。

設定ファイルはYAML形式で記載を行う。

例

キー1: 値1
キー2: 値2
# コメント
...

また、言語を指定して定義を切り分けることもできる。

書式例

---
# Language指定なし(共通定義)。
# 既定値としてLLVMを使用、インデントをスペース4つに指定する。
BasedOnStyle: LLVM
IndentWidth: 4
---
♯ C++用の定義
Language: Cpp
DerivePointerAlignment: false
PointerAlignment: Left
---
♯ JavaScript用の定義
Language: JavaScript
ColumnLimit: 100
---
♯ Protocol Buffers用の定義
Language: Proto
DisableFormat: true
---
♯ C#用の定義
Language: CSharp
ColumnLimit: 100
...

以下のコマンドを実行すると、clang-formatの既定値の定義を出力することができる。
(ベースファイルとして使える)

clang-format -style=llvm -dump-config > .clang-format

※styleに指定できる値は、BasedOnStyleを参照

２. 書式及びオプション

style及び.clang-formatファイルに指定可能な個々のフォーマットスタイルについて記載する。

【凡例】

キー名(値の型) 使用可能なバージョン

　概要
　値の範囲
　書式例

の順で記載する。
値の型は、

型	意味	例	備考
Integer	数値	100,-20
Unsigned	正の数値	50	負数を指定するとエラーとなる
String	文字列	"(_test)?$"	主に正規表現を指定する項目で使用
List of Strings	文字列の配列	['com.example', 'com', 'org']	主にキーワードのリストを指定する項目で使用
Boolean	真偽値	true, false

その他、個別の列挙型がある。
列挙型の一覧については、以下のドキュメントを参照

注意
一部のキーについてデータ型がclang-formatのバージョンによって、Booleanから列挙型に変更となっているものがあります。
旧のデータ型がBooleanの場合、レガシーオプションとして列挙型＋Booleanのどちらでも指定可能となっています。
本稿を執筆するにあたり、各キーがどのバージョンでBooleanから列挙型に変更となったかまでの調査は出来ておりません。
ただし、レガシーオプションが存在するキーについてはその内容も記述をおこなっています。
ご自身が使用する環境で列挙型での指定がエラーとなる場合、Booleanでの指定を試してください。

BasedOnStyle(String)

すべてのオプションの既定値となる値を指定する。

値	意味
LLVM	LLVMコーディング規約を標準とする
Google	Google C++ スタイルガイドを標準とする
Chromium	Chromium スタイルガイドを標準とする
Mozilla	Mozilla コーディングスタイルを標準とする
WebKit	WebKit コードスタイル ガイドラインを標準とする
Microsoft	.NET コードスタイルのルールオプションを標準とする
GNU	GNU コーディング規約を標準とする
InheritParentConfig	親の設定を読み込み使用する。親が見つからない場合、フォールバックとして動作する。

AccessModifierOffset(Integer) 3.3以降

アクセス修飾子(public等)のインデントまたはアウトデントに対する補正を指定する。
つまり、IndentWidthで指定した値にAccessModifierOffsetで指定した値を足した値が、インデントとして設定されます。
合計した値は最低0以上である必要があり、0より小さい値となる場合、AccessModifierOffsetの値は破棄されます。

AlignAfterOpenBracket(BracketAlignmentStyle) 3.8以降

開き括弧の後の引数の並べ方を指定する。
この指定は、丸括弧、波括弧及び角括弧に適用となる。

値	意味
Align	開き括弧にパラメータの先頭を合わせる。
DontAlign	位置を合わせない。次行以降のインデントにはContinuationIndentWidthを使用する。
AlwaysBreak	パラメータが1行に収まらない場合、常に開き括弧の後で改行を行う。
BlockIndent	AlwaysBreakと同じ動作。ただし、閉じ括弧を改行する。

Align

someLongFunction(argument1,
                 argument2);

DontAlign

someLongFunction(argument1,
    argument2);

AlwaysBreak

someLongFunction(
    argument1, argument2);

BlockIndent

someLongFunction(
    argument1, argument2
);

警告
現在(clang-format15.0時点)、丸括弧のみに適用されます。

AlignArrayOfStructures(ArrayInitializerAlignmentStyle) 13以降

構造体配列の初期化子について、整列方向を指定する。

値	意味
Left	配列の初期化リストを左寄せに整列する。
Right	配列の初期化リストを右寄せに整列する。
None	配列の初期化リストを整列を行わない。

Left

// 配列の初期化リストを左寄せに整列する
struct test demo[] =
{
    {56, 23,    "hello"},
    {-1, 93463, "world"},
    {7,  5,     "!!"   }
};

Right

// 配列の初期化リストを右寄せに整列する
struct test demo[] =
{
    {56,    23, "hello"},
    {-1, 93463, "world"},
    { 7,     5,    "!!"}
};

AlignConsecutiveAssignments(AlignConsecutiveStyle) 3.8以降

連続した代入の揃え方を指定する。
指定した値により、次のパラメータの値を決定する。
　・Enabled
　・AcrossEmptyLines
　・AcrossComments
　・AlignCompound
　・PadOperators
パラメータの意味については後述する。
※公式ドキュメントの記述に誤りがある。公式の例にある個別パラメータへの真偽値の設定は出来ない。

値 \ パラメータ	Enabled	AcrossEmptyLines	AcrossComments	AlignCompound	PadOperators
None	false	false	false	false	true
Consecutive	true	false	false	false	true
AcrossEmptyLines	true	true	false	false	true
AcrossComments	true	false	true	false	true
AcrossEmptyLinesAndComments	true	true	true	false	true
true	true	false	false	false	true
false	false	false	false	false	true

※AlignCompoundがtrueとなる値は存在しない。
　値にtrueを指定した場合、Consecutiveと同じ動作となる。同様にfalseを指定した場合、Noneと同じ動作となる。

各パラメータの設定値により、次の動作を行う。

Enabled(Boolean)

アライメントを有効とするかを指定する。

true

// アライメントを有効にする
int a            = 1;
int somelongname = 2;
double c         = 3;

false

// アライメントを無効とする
int a = 1;
int somelongname = 2;
double c = 3;

AcrossEmptyLines(Boolean)

空白行を挟んだ要素を整列するかを指定する。

true

// 空白行を挟んだ要素も整列を行う
int a            = 1;
int somelongname = 2;

double c         = 3;

false

// 空白行を挟んだ要素は別で整列を行う
int a            = 1;
int somelongname = 2;

double c = 3;

AcrossComments(Boolean)

コメント行を挟んだ要素を整列するかを指定する。

true

// コメント行を挟んだ要素も整列を行う
int a            = 1;
int somelongname = 2;
/* コメント */
double c         = 3;

false

// コメント行を挟んだ要素は別で整列を行う
int a            = 1;
int somelongname = 2;
/* コメント */
double c = 3;

AlignCompound(Boolean)

複合した演算子についての整列方法を指定する。
このフラグはAlignConsecutiveAssignmentsに対してのみ有効となる。

true

// 演算子と複合の=について、演算子を加味した位置に調整を行う
a   &= 2;
bbb  = 2;

false

// 演算子と複合の=について、演算子を加味しない位置に調整を行う
a &= 2;
bbb = 2;

PadOperators(Boolean)

長い演算子と短い演算子についての整列方法を指定する。
このフラグはAlignConsecutiveAssignmentsに対してのみ有効となる。

true

// 演算子と複合の=について、演算子を加味した位置に調整を行う
// 演算子の幅も加味して=の位置を調整する
a   >>= 2;
bbb   = 2;

a     = 2;
bbb >>= 2;

false

// =の位置を軸として調整を行う
a >>= 2;
bbb = 2;

a     = 2;
bbb >>= 2;

AlignConsecutiveBitFields(AlignConsecutiveStyle) 11以降

連続したビットフィールドの揃え方を指定する。
指定可能な値の範囲はAlignConsecutiveAssignmentsと同じのため、そちらを参照のこと。

AlignConsecutiveDeclarations(AlignConsecutiveStyle) 3.8以降

連続した宣言の揃え方を指定する。
指定可能な値の範囲はAlignConsecutiveAssignmentsと同じのため、そちらを参照のこと。

AlignConsecutiveMacros(AlignConsecutiveStyle) 9以降

連続したマクロ定義の揃え方を指定する。
指定可能な値の範囲はAlignConsecutiveAssignmentsと同じのため、そちらを参照のこと。

AlignEscapedNewlines(EscapedNewlineAlignmentStyle) 5以降

エスケープ文字された改行文字の揃え方を指定する。

値	意味
DontAlign	エスケープされた改行文字を揃えない
Left	エスケープされた改行文字をできるだけ左に揃える
Right	エスケープされた改行文字を右端の列に揃える

DontAlign

// エスケープされた改行文字を揃えない(各行左詰めにする)
#define A \
  int aaaa; \
  int b; \
  int dddddddddd;

Left

// エスケープされた改行文字をできるだけ左に揃える
#define A   \
  int aaaa; \
  int b;    \
  int dddddddddd;

Right

// ColumnLimitで指定した値の位置にエスケープ文字を合わせる。
// ColumnLimitが0(無制限)の場合、Leftと同じ動作となる。
#define A                                                                      \
  int aaaa;                                                                    \
  int b;                                                                       \
  int dddddddddd;

AlignOperands(OperandAlignmentStyle) 3.5以降

2項式及び3項式のオペランドの位置を指定する。

値	意味
DontAlign	オペランドの整列を行わない。改行した行は行頭からContinuationIndentWidth分のスペースがインデントされる。
Align	水平に揃える
AlignAfterOperator	水平に揃える。Alignとの差はBreakBeforeBinaryOperatorsを指定した場合の動作だけとなる。
true	Alignと同じ動作。(レガシーオプション)
false	DontAlignと同じ動作。(レガシーオプション)

Align及びAlignAfterOperator(BreakBeforeBinaryOperatorsがNone又は未指定)

// オペランドは行末に付与され、改行後は変数名等を先頭に整列が行われる
int aaa = bbbbbbbbbbbbbbb +
          ccccccccccccccc;

Align(BreakBeforeBinaryOperatorsが指定あり)

// オペランドは改行後の先頭に付与され、オペランドの位置は先頭行の変数の頭に整列される
int aaa = bbbbbbbbbbbbbbb
          + ccccccccccccccc;

AlignAfterOperator(BreakBeforeBinaryOperatorsが指定あり)

// オペランドは改行後の先頭に付与され、オペランドの位置は先頭行のオペランドに整列される
int aaa = bbbbbbbbbbbbbbb
        + ccccccccccccccc;

AlignTrailingComments(Boolean) 3.7以降

コメントの整列方法を指定する。

true

// コメントの位置を整列する
int a;     // comment a
int b = 2; // comment b

false

// コメントの位置を整列しない(スペース1個分の位置まで詰める)
int a; // comment a
int b = 2; // comment b

AllowAllArgumentsOnNextLine(Boolean) 9以降

関数の引数や初期化リストが1行に収まらない場合の動作を指定する。BinPackArgumentsにfalseを指定している場合でもこの処理は動作する。

true

// 関数の引数を1行で記載する
callFunction(
    a, b, c, d);

false

// 関数の引数を複数行で記載する
callFunction(a,
             b,
             c,
             d);

メモ書き
筆者環境にて動作が確認できず。(RHEL9.0、clang-format15)
--style={ BreakBeforeBraces: Linux, BinPackArguments: true/false, AllowAllArgumentsOnNextLine: true/false }で4パターン試行して、どの指定でも変換が行われなかった。

AllowAllConstructorInitializersOnNextLine(Boolean) 9以降

非推奨なオプション。PackConstructorInitializersのNextLineを参照すること。

AllowShortBlocksOnASingleLine(ShortBlockStyle) 3.5以降

短いwhile文( while (true) { continue; } )の並べ方を指定する。
※ステートメントを波括弧で囲んでいる場合の動作。波括弧を付与しない場合、AllowShortLoopsOnASingleLineにより指定を行う。

値	意味
Never	ブロックを1行に並べない。
Empty	空のブロックだけ1行に並べる。
Always	短いブロックは1行に並べる。
true	Alwaysと同じ動作となる。(レガシーオプション)
false	Neverと同じ動作となる。(レガシーオプション)

Never

// 短いwhile文も必ず折り返す
while (true) {
}
while (true) {
  continue;
}

Empty

// 空のwhile文は1行に纏める
while (true) {}
while (true) {
  continue;
}

Always

// while文を1行に纏める
while (true) {}
while (true) { continue; }

AllowShortCaseLabelsOnASingleLine(Boolean) 3.6以降

短いcase文のまとめ方を指定する。

true

// caseラベルとその処理を1行にまとめる
switch (a) {
case 1: x = 1; break;
case 2: return;
}

false

// caseラベルとその処理を1行にまとめない
switch (a) {
case 1:
  x = 1;
  break;
case 2:
  return;

AllowShortEnumsOnASingleLine(Boolean) 11以降

短い列挙型のまとめ方を指定する。

true

// 列挙型を1行にまとめる
enum { A, B } myEnum;
}

false

// 列挙型を1行にまとめない
enum {
  A,
  B
} myEnum;

AllowShortFunctionsOnASingleLine(ShortFunctionStyle) 3.5以降

短い関数(処理が1行以下)の纏め方を指定する。

値	意味
None	関数を1行に纏めない。
InlineOnly	クラス内で定義した関数だけ1行に纏める。Inlineと同じ動作だが、空の関数についてのみ動作が異なる。
Empty	空の関数は1行に纏める。
Inline	クラス内で定義した関数だけ1行に纏める。
All	すべての関数を1行に纏める
true	Allと同じ動作となる。(レガシーオプション)
false	Noneと同じ動作となる。(レガシーオプション)

InlineOnly

// クラスメソッドは1行に纏められる。
class Foo {
  void f1() { foo(); }
};
void f2() {
  foo();
}
// Inlineと異なる箇所
void f3() {
}

Empty

class Foo {
  void f1() {
    foo();
  }
};
void f2() {
  foo();
}
// 空のメソッドだけ1行に纏める
void f3() {}

Inline

// クラスメソッドと空のメソッドが1行に纏められる。
class Foo {
  void f1() { foo(); }
};
void f2() {
  foo();
}
void f3() {}

All

// すべて1行に纏める。
class Foo {
  void f1() { foo(); }
};
void f2() { foo(); }
void f3() {}

AllowShortIfStatementsOnASingleLine(ShortIfStyle) 3.3以降

短いif及びelseの纏め方を指定する。

値	意味
Never	短いifを同じ行に並べない。
WithoutElse	else文がない場合のみ、短いifを同じ行に並べる。
OnlyFirstIf	短いifだけを並べる。else ifやelse文は並べない。
AllIfsAndElse	短いif、else if及びelse文を同じ行に並べる。
Always	OnlyFirstIfと同じ動作となる。(レガシーオプション)
true	WithoutElseと同じ動作となる。(レガシーオプション)
false	Neverと同じ動作となる。(レガシーオプション)

Never

if (a)
  return;

if (b)
  return;
else
  return;

if (c)
  return;
else {
  return;
}

WithoutElse

// ifだけの場合、1行に纏める。
if (a) return;

if (b)
  return;
else
  return;

if (c)
  return;
else {
  return;
}

AllIfsAndElse

// すべて1行に纏める。
if (a) return;

if (b) return;
else return;

if (c) return;
else {
  return;
}

AllowShortIfStatementsOnASingleLine(ShortLambdaStyle) 9以降

短いラムダ式の纏め方を指定する。

値	意味
None	短いラムダ式を同じ行に並べない。
Empty	空のラムダ式だけ1行に並べる。
Inline	関数の引数として指定したラムダ式だけ1行に並べる。
All	すべての短いラムダ式を1行に並べる。
true	Allと同じ動作となる。(レガシーオプション)
false	Noneと同じ動作となる。(レガシーオプション)

Empty

// 空のラムダ式だけ1行に並べる。
auto lambda = [](int a) {};
auto lambda2 = [](int a) {
  return a;
};
sort(vct.begin(), vct.end(), [](int x, int y) {
  return x < y;
});

Inline

auto lambda = [](int a) {
};
auto lambda2 = [](int a) {
  return a;
};
// 関数の引数として指定したラムダ式だけ1行に並べる。
sort(vct.begin(), vct.end(), [](int x, int y) { return x < y; });

All

// すべての短いラムダ式を1行に並べる。
auto lambda = [](int a) {};
auto lambda2 = [](int a) { return a; };
sort(vct.begin(), vct.end(), [](int x, int y) { return x < y; });

AllowShortLoopsOnASingleLine(Boolean) 3.7以降

短いwhile文( while (true) continue; )の並べ方を指定する。
※ステートメントを波括弧で囲んでいない場合の動作。波括弧を付与する場合、AllowShortBlocksOnASingleLine により指定を行う。

true

while (true) { continue; }

false

while (true) {
  continue;
}

AlwaysBreakAfterDefinitionReturnType(DefinitionReturnTypeBreakingStyle) 3.7以降

非推奨なオプション。

AlwaysBreakAfterReturnType(ReturnTypeBreakingStyle) 3.8以降

関数の戻り値の改行スタイルを指定する。

値	意味
None	戻り値を改行しない。
All	戻り値の後で必ず改行する。
TopLevel	トップレベルの関数だけ、戻り値の後で改行する。
AllDefinitions	関数の実体定義だけ、戻り値の後で改行する。
TopLevelDefinitions	トップレベルの関数の実体定義だけ、戻り値の後で改行する。
true	Allと同じ動作となる。(レガシーオプション)
false	Noneと同じ動作となる。(レガシーオプション)

None

class B {
  int f() { return 0; };
};
int f();
int f() { return 1; }

All

class B {
  int
  f() {
    return 0;
  };
};
int
f();
int
f() {
  return 1;
}

TopLevel

class B {
  int f() { return 0; };
};
// トップレベルのメソッド(クラススコープのメソッドではない？)は改行する。
int
f();
int
f() {
  return 1;
}

AllDefinitions

// 関数の実体定義がある場合は改行する。
class B {
  int
  f() {
    return 0;
  };
};
int f();
int
f() {
  return 1;
}

AlwaysBreakBeforeMultilineStrings(Boolean) 3.4以降

文字列リテラルの並べ方を指定する。
ContinuationIndentWidthが未指定の場合だけ、このフラグが有効となる。

true

const char *sz =
    "aaaa"
    "bbbb";

false

const char *sz = "aaaa"
                 "bbbb";

AlwaysBreakTemplateDeclarations(BreakTemplateDeclarationsStyle) 3.4以降

テンプレート宣言の改行スタイルを指定する。

値	意味
No	テンプレート宣言の後に改行を行わない。
MultiLine	テンプレート宣言の後が複数行になる場合だけ改行を行う
Yes	必ずテンプレート宣言の後に改行を行う。
false	MultiLineと同じ動作となる。(レガシーオプション)
true	Yesと同じ動作となる。(レガシーオプション)

No

template <typename T> T foo() {
}
template <typename T> T foo(int aaaaaaaaaaaaaaaaaaaaa,
                            int bbbbbbbbbbbbbbbbbbbbb) {
}

MultiLine

template <typename T> T foo() {
}
// テンプレート宣言の後ろに複数行ある場合だけ改行を行う
template <typename T>
T foo(int aaaaaaaaaaaaaaaaaaaaa,
      int bbbbbbbbbbbbbbbbbbbbb) {
}

Yes

// テンプレート宣言の後は必ず改行する
template <typename T>
T foo() {
}
template <typename T>
T foo(int aaaaaaaaaaaaaaaaaaaaa,
      int bbbbbbbbbbbbbbbbbbbbb) {

AttributeMacros(List of Strings) 12以降

識別子ではなく、属性/修飾子として解釈されるべき文字列のリストを指定する。
つまり、このリストで指定したキーワードは属性/修飾子としてフォーマットが行われる。

.clang-format 設定ファイルでは、次の様に設定することができる。

AttributeMacros: ['__capability', '__output', '__ununsed']

BinPackArguments(Boolean) 3.7以降

関数の引数の並べ方を指定する。

true

// 1行の最大文字数を基準に折り返しを行う
void f() {
  f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,
    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);
}

false

// 引数を各1行ずつに折り返す
void f() {
  f(aaaaaaaaaaaaaaaaaaaa,
    aaaaaaaaaaaaaaaaaaaa,
    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);
}

BinPackParameters(Boolean) 3.7以降

関数宣言や関数定義の引数の並べ方を指定する。

true

// 1行の最大文字数を基準に折り返しを行う
void f(int aaaaaaaaaaaaaaaaaaaa, int aaaaaaaaaaaaaaaaaaaa,
       int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}

false

// 引数を各1行ずつに折り返す
void f(int aaaaaaaaaaaaaaaaaaaa,
       int aaaaaaaaaaaaaaaaaaaa,
       int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}

BitFieldColonSpacing(BitFieldColonSpacingStyle) 12以降

テンプレート宣言の改行スタイルを指定する

値	意味
Both	コロンの前後にスペースを挿入する。
None	コロンの前後にスペースを挿入しない。
Before	コロンの前だけスペースを挿入する。
After	コロンの後ろだけスペースを挿入する。

Both

unsigned bf : 2;

None

unsigned bf:2;

Before

unsigned bf :2;

After

unsigned bf: 2;

BraceWrapping (BraceWrappingFlags) 3.8以降

括弧の個別制御を指定する。このフラグはBreakBeforeBracesがBS_Customに設定されている場合だけ有効で、それ以外の場合は無視される。

.clang-formatの書式例

BreakBeforeBraces: Custom
BraceWrapping:
  AfterEnum: true
  AfterStruct: false
  SplitEmptyFunction: false

各設定フラグについては以下のとおり。

AfterCaseLabel(Boolean)

caseラベルに対する括弧の制御方法を指定する。

true

  // caseラベルの後ろの括弧は改行する
  switch (foo) {
    case 1:
    {
      bar();
      break;
    }
    default:
    {
      plop();
    }
  }

false

  // caseラベルの後ろの括弧は改行しない
  switch (foo) {
    case 1: {
      bar();
      break;
    }
    default: {
      plop();
    }
  }

AfterClass(Boolean)

クラス定義に対する括弧の制御方法を指定する。

true

// 後ろの括弧は改行する
class foo
{};

false

// 後ろの括弧は改行しない
class foo {};

メモ書き
公式ドキュメントに誤記あり。
trueとfalseの動作が逆に記載されている。

AfterControlStatement(BraceWrappingAfterControlStatementStyle)

ステートメント(if、for、while、switch等)に対する括弧の制御方法を指定する。

値	意味
Never	制御文の後の波括弧を改行しない。
MultiLine	複数行の制御文の後の波括弧だけ改行する。
Always	制御文の後の波括弧を改行する。
false	Neverと同じ動作となる。(レガシーオプション)
true	Alwaysと同じ動作となる。(レガシーオプション)

Never

  // 制御文の後の波括弧を改行しない。
  if (foo()) {
  } else {
  }
  for (int i = 0; i < 10; ++i) {
  }

MultiLine

  // 複数行の制御文の後の波括弧だけ改行する。
  if (foo && bar &&
      baz)
  {
    quux();
  }
  while (foo || bar) {
  }

Always

  // 制御文の後の波括弧を改行する。
  if (foo())
  {
  } else
  {}
  for (int i = 0; i < 10; ++i)
  {}

AfterEnum(Boolean)

列挙型に対する括弧の制御方法を指定する。

true

// 後ろの括弧は改行する
enum X : int
{
  B
};

false

// 後ろの括弧は改行しない
enum X : int { B };

AfterFunction(Boolean)

関数に対する括弧の制御方法を指定する。

true

// 後ろの括弧は改行する
void foo()
{
  bar();
  bar2();
}

false

// 後ろの括弧は改行しない
void foo() {
  bar();
  bar2();
}

AfterNamespace(Boolean)

名前空間に対する括弧の制御方法を指定する。

true

// 後ろの括弧は改行する
namespace
{
int foo();
int bar();
}

false

// 後ろの括弧は改行しない
namespace {
int foo();
int bar();
}

AfterObjCDeclaration(Boolean)

Objective-Cの定義(@interface、@implementation等)、@autoreleasepool及び@synchronizedに対する括弧の制御方法を指定する。

true

// 後ろの括弧は改行する
@interface MyObject : NSObject
{
  int val;
}

false

// 後ろの括弧は改行しない
@interface MyObject : NSObject {
  int val;
}

AfterStruct(Boolean)

構造体に対する括弧の制御方法を指定する。

true

// 後ろの括弧は改行する
struct foo
{
  int x;
};

false

// 後ろの括弧は改行しない
struct foo {
  int x;
};

AfterUnion(Boolean)

共用体に対する括弧の制御方法を指定する。

true

// 後ろの括弧は改行する
union foo
{
  int x;
}

false

// 後ろの括弧は改行しない
union foo {
  int x;
}

AfterExternBlock(Boolean)

外部結合ブロック(extern)に対する括弧の制御方法を指定する。

true

// 後ろの括弧は改行する
extern "C"
{
  int foo();
}

false

// 後ろの括弧は改行しない
extern "C" {
int foo();
}

BeforeCatch(Boolean)

catch句の前方の括弧の制御方法を指定する。

true

// 前方の括弧は改行する
try {
  foo();
}
catch () {
}

false

// 前方の括弧は改行しない
try {
  foo();
} catch () {
}

BeforeElse(Boolean)

else句の前方の括弧の制御方法を指定する。

true

// 前方の括弧は改行する
if (foo()) {
}
else {
}

false

// 前方の括弧は改行しない
if (foo()) {
} else {
}

BeforeLambdaBody(Boolean)

ラムダ式の前方の括弧の制御方法を指定する。

true

// 前方の括弧は改行する(キャプチャとラムダ導入子も改行される？)
connect(
  []()
  {
    foo();
    bar();
  });

false

// 前方の括弧は改行しない
connect([]() {
  foo();
  bar();
});

BeforeWhile(Boolean)

do～whileの前方の括弧の制御方法を指定する。

true

// 前方の括弧は改行する
do {
  foo();
}
while (1);

false

// 前方の括弧は改行しない
do {
  foo();
} while (1);

IndentBraces(Boolean)

折り返した波括弧のインデントの可否を指定する。

true

// 折り返した波括弧をインデントする
if (a) {
    foo(a,b);
} else {
  }
for (int i = 0; i < 10; ++i) {
  }

false

// 折り返した波括弧をインデントしない
if (a) {
  foo(a, b);
} else {
}
for (int i = 0; i < 10; ++i) {
}

SplitEmptyFunction(Boolean)

空の関数本体を1行に纏めるかを指定する。このオプションはAllowShortFunctionsOnASingleLine にNone、AfterFunctionにtrueを指定している場合のみ適用されます。

true

// 空の関数の括弧を1行に並べない。
int f()
{
}

false

// 空の関数の括弧を1行に並べる。
int f()
{}

SplitEmptyRecord(Boolean)

空のクラス本体を1行に纏めるかを指定する。AfterClassにtrueを指定している場合のみ適用されます。

true

// 空のクラスの括弧を1行に並べない。
class Foo
{
}

false

// 空のクラスの括弧を1行に並べる。
class Foo
{}

SplitEmptyNamespace(Boolean)

空の名前空間本体を1行に纏めるかを指定する。AfterNamespaceにtrueを指定している場合のみ適用されます。

true

// 空のクラスの括弧を1行に並べない。
namespace Foo
{
}

false

// 空のクラスの括弧を1行に並べる。
namespace Foo
{}

BreakAfterJavaFieldAnnotations(Boolean) 3.8以降

Javaファイルのアノテーションの改行を指定する。

true

// アノテーションで改行する
@Partial
@Mock
DataLoad loader;

false

// アノテーションで改行しない
@Partial @Mock DataLoad loader;

BreakBeforeBinaryOperators(BinaryOperatorStyle) 3.6以降

二項演算子の並べ方を指定する。

値	意味
None	演算子の後で改行する。
NonAssignment	代入ではない演算子の前で改行する。
All	演算子の前で改行する。
true	Allと同じ動作。
false	Noneと同じ動作。

None

// 演算子の後で改行する。
LooooooooooongType loooooooooooooooooooooongVariable =
    someLooooooooooooooooongFunction();

bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +
                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==
                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&
             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >
                 ccccccccccccccccccccccccccccccccccccccccc;

NonAssignment

// 代入ではない演算子の後で改行する。
LooooooooooongType loooooooooooooooooooooongVariable =
    someLooooooooooooooooongFunction();

bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
                 == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
             && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
                    > ccccccccccccccccccccccccccccccccccccccccc;

All

// 演算子の前で改行する。
LooooooooooongType loooooooooooooooooooooongVariable
    = someLooooooooooooooooongFunction();

bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
                 == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
             && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
                    > ccccccccccccccccccccccccccccccccccccccccc;

メモ書き
NonAssignmentとAllの挙動が理解できない。改行位置はわかるがインデントはどうしてこの動作になるのか。(実動作を確認の結果、記載のインデントになる)

BreakBeforeBraces(BraceBreakingStyle) 3.7以降

括弧の制御を一括で指定する。

値	意味
Attach	文脈の後に括弧を並べる。
Linux	Attachと同様。ただし関数、名前空間、クラス定義(C#のレコード型を含む)の括弧は改行する。
Mozilla	Attachと同様。ただし列挙型、関数、名前空間、クラス定義(C#のレコード型を含む)の括弧は改行する。
Stroustrup	Attachと同様。ただし関数定義、catch、elseの前の括弧は改行する。
Allman	文脈の後の括弧を改行する。
Whitesmiths	Allmanと同様。ただし波括弧にインデントを付ける。
GNU	Allmanと同様。ただし制御文の波括弧にインデントを付ける。
WebKit	Attachと同様。ただし関数の括弧は改行する。
Custom	BraceWrappingフラグにより個々の改行ルールを決定する。(BraceWrappingの項を参照)

Attach

namespace N {
enum E {
  E1,
  E2,
};

class C {
public:
  C();
};

bool baz(int i) {
  try {
    do {
      switch (i) {
      case 1: {
        foobar();
        break;
      }
      default: {
        break;
      }
      }
    } while (--i);
    return true;
  } catch (...) {
    handleError();
    return false;
  }
}

void foo(bool b) {
  if (b) {
    baz(2);
  } else {
    baz(5);
  }
}

void bar() { foo(true); }
} // namespace N

Linux

namespace N
{
enum E {
  E1,
  E2,
};

class C
{
public:
  C();
};

bool baz(int i)
{
  try {
    do {
      switch (i) {
      case 1: {
        foobar();
        break;
      }
      default: {
        break;
      }
      }
    } while (--i);
    return true;
  } catch (...) {
    handleError();
    return false;
  }
}

void foo(bool b)
{
  if (b) {
    baz(2);
  } else {
    baz(5);
  }
}

void bar() { foo(true); }
} // namespace N

Mozilla

namespace N {
enum E
{
  E1,
  E2,
};

class C
{
public:
  C();
};

bool baz(int i)
{
  try {
    do {
      switch (i) {
      case 1: {
        foobar();
        break;
      }
      default: {
        break;
      }
      }
    } while (--i);
    return true;
  } catch (...) {
    handleError();
    return false;
  }
}

void foo(bool b)
{
  if (b) {
    baz(2);
  } else {
    baz(5);
  }
}

void bar() { foo(true); }
} // namespace N

Stroustrup

namespace N {
enum E {
  E1,
  E2,
};

class C {
public:
  C();
};

bool baz(int i)
{
  try {
    do {
      switch (i) {
      case 1: {
        foobar();
        break;
      }
      default: {
        break;
      }
      }
    } while (--i);
    return true;
  }
  catch (...) {
    handleError();
    return false;
  }
}

void foo(bool b)
{
  if (b) {
    baz(2);
  }
  else {
    baz(5);
  }
}

void bar() { foo(true); }
} // namespace N

Allman

namespace N
{
enum E
{
  E1,
  E2,
};

class C
{
public:
  C();
};

bool baz(int i)
{
  try
  {
    do
    {
      switch (i)
      {
      case 1:
      {
        foobar();
        break;
      }
      default:
      {
        break;
      }
      }
    } while (--i);
    return true;
  }
  catch (...)
  {
    handleError();
    return false;
  }
}

void foo(bool b)
{
  if (b)
  {
    baz(2);
  }
  else
  {
    baz(5);
  }
}

void bar() { foo(true); }
} // namespace N

Whitesmiths

namespace N
  {
enum E
  {
  E1,
  E2,
  };

class C
  {
public:
  C();
  };

bool baz(int i)
  {
  try
    {
    do
      {
      switch (i)
        {
        case 1:
        {
        foobar();
        break;
        }
        default:
        {
        break;
        }
        }
      } while (--i);
    return true;
    }
  catch (...)
    {
    handleError();
    return false;
    }
  }

void foo(bool b)
  {
  if (b)
    {
    baz(2);
    }
  else
    {
    baz(5);
    }
  }

void bar() { foo(true); }
  } // namespace N

GNU

namespace N
{
enum E
{
  E1,
  E2,
};

class C
{
public:
  C();
};

bool baz(int i)
{
  try
    {
      do
        {
          switch (i)
            {
            case 1:
              {
                foobar();
                break;
              }
            default:
              {
                break;
              }
            }
        }
      while (--i);
      return true;
    }
  catch (...)
    {
      handleError();
      return false;
    }
}

void foo(bool b)
{
  if (b)
    {
      baz(2);
    }
  else
    {
      baz(5);
    }
}

void bar() { foo(true); }
} // namespace N

WebKit

namespace N {
enum E {
  E1,
  E2,
};

class C {
public:
  C();
};

bool baz(int i)
{
  try {
    do {
      switch (i) {
      case 1: {
        foobar();
        break;
      }
      default: {
        break;
      }
      }
    } while (--i);
    return true;
  } catch (...) {
    handleError();
    return false;
  }
}

void foo(bool b)
{
  if (b) {
    baz(2);
  } else {
    baz(5);
  }
}

void bar() { foo(true); }
} // namespace N

BreakBeforeConceptDeclarations(BreakBeforeConceptDeclarationsStyle) 12以降

コンセプトに対する括弧の制御方法を指定する。

値	意味
Never	テンプレート宣言とコンセプトを並べる。
Allowed	他のフラグ指定に従い、テンプレート宣言の後に改行を行うことが可能。指定がない場合、テンプレート宣言とコンセプトを並べる。
Always	コンセプトの前で改行する。
true	Alwaysと同じ動作。(レガシーオプション)
false	Allowedと同じ動作。(レガシーオプション)

Never

template <class T> concept Foo = requires(T &x) {};

Always

template <class T>
concept Foo = requires(T &x) {};

BreakBeforeTernaryOperators(Boolean) 3.7以降

1行に収まらない三項演算子に対する括弧の制御方法を指定する。

true

// 演算子の前で改行を行う
veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription
    ? firstValue
    : SecondValueVeryVeryVeryVeryLong;

false

// 演算子の後で改行を行う
veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription ?
    firstValue :
    SecondValueVeryVeryVeryVeryLong;

BreakConstructorInitializers(BreakConstructorInitializersStyle) 5以降

コンストラクタの初期化リストに対する制御方法を指定する。

値	意味
BeforeColon	コロンの前とカンマの後で改行する。
BeforeComma	コロンとカンマの前で改行し、コロンとカンマの位置を合わせる。
AfterColon	コロンとカンマの後で改行する。

BeforeColon

Constructor()
    : initializer1(),
      initializer2()

BeforeComma

Constructor()
    : initializer1()
    , initializer2()

AfterColon

Constructor() :
    initializer1(),
    initializer2()

BreakInheritanceList(BreakInheritanceListStyle) 7以降

継承リストに対する制御方法を指定する。

値	意味
BeforeColon	コロンの前とカンマの後で改行する。
BeforeComma	コロンとカンマの前で改行し、コロンとカンマの位置を合わせる。
AfterColon	コロンとカンマの後で改行する。
AfterComma	カンマの後で改行する。

BeforeColon

class Foo
    : Base1,
      Base2
{};

BeforeComma

class Foo
    : Base1
    , Base2
{};

AfterColon

class Foo :
    Base1,
    Base2
{};

AfterComma

class Foo : Base1,
            Base2
{};

BreakStringLiterals(Boolean) 3.9以降

1行に収まらない文字列リテラルに対する制御方法を指定する。

true

// 1行の最大文字数で文字列リテラルを分割する
const char* x = "veryVeryVeryVeryVeryVe"
                "ryVeryVeryVeryVeryVery"
                "VeryLongString";

false

// 文字列リテラルを分割しない
const char* x =
  "veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongString";

メモ書き
一度、BreakStringLiteralsをtrueに指定し文字列リテラルを整形したのち、falseを指定してフォーマットしなおした場合、分割された文字列リテラルは自動で繋がらない。(元に戻らない)

ColumnLimit(Unsigned) 3.7以降

1行の最大文字数を指定する。
0を指定した場合、ステートメント内で他のルールと矛盾しない限り無制限となる。

CommentPragmas(String) 3.7以降

行分割してはいけないコメントを、正規表現で指定する。

例

// CommentPragmas: '^ FOOBAR pragma:'
// 上記の値を指定した場合、以下の行は改行されない。
#include <vector> // FOOBAR pragma: keep

CompactNamespaces(boolean) 5以降

連続した名前空間に対する制御方法を指定する。

true

// 連続した名前空間を改行しない。
namespace Foo { namespace Bar {
}}

// ただし、1行に収まらない場合、改行が行われる。
namespace Foo { namespace Bar {
namespace Extra {
}}}

false

// 連続した名前空間を改行する。
namespace Foo {
namespace Bar {
}
}

ConstructorInitializerAllOnOneLineOrOnePerLine(Boolean) 3.7以降

非推奨のオプション。CurrentLine又はPackConstructorInitializersを参照。

ConstructorInitializerIndentWidth(Unsigned) 3.7以降

コンストラクタの初期化リスト及び継承リストのインデントを指定する。

ContinuationIndentWidth(Unsigned) 3.7以降

連続する行のインデントを指定する。

例

// ContinuationIndentWidth: 2 を指定した場合、連続した記述についてインデントが2ずつ付与される。
int i =         //  VeryVeryVeryVeryVeryLongComment
  longFunction( // Again a long comment
    arg);

Cpp11BracedListStyle(Boolean) 3.4以降

C++11の初期化リストのフォーマットを指定する。
【重要な相違点】
trueを指定した場合、
・波括弧付きリストの内部に空白を入れない。
・閉じ波括弧の前に改行しない。
・ブロック・インデントではなく、継続インデントでインデントする。
となる。

基本的に、C++11 の初期化リストは、関数呼び出しと全く同じ書式で記述されます。初期化リストが名前（例えば型名や変数名）の後にある場合、clang-formatは{}をその名前を持つ関数呼び出しの括弧であるかのようにフォーマットします。もし名前がなければ、長さ0の名前と見なします。

true

// 初期化リストの開き括弧の後と閉じ括弧の前に空白を挿入しない。
vector<int> x{1, 2, 3, 4};
vector<T> x{{}, {}, {}, {}};
f(MyMap[{composite, key}]);
new int[3]{1, 2, 3};

false

// 初期化リストの開き括弧の後と閉じ括弧の前に空白を挿入する。
vector<int> x{ 1, 2, 3, 4 };
vector<T> x{ {}, {}, {}, {} };
f(MyMap[{ composite, key }]);
new int[3]{ 1, 2, 3 };

DeriveLineEnding(Boolean) 10以降

改行コードをCR+LF又はLFに統一する。
DeriveLineEndingにtrueを指定した場合、ファイル内で一番多い改行コードでファイルの改行を統一する。 DeriveLineEndingにfalseを指定した場合、UseCRLFがtrueであればファイルの改行コードをCR+LFで統一し、UseCRLFがfalseであればDeriveLineEndingにtrueを指定した場合と同じ動作となる。

DerivePointerAlignment(Boolean) 3.7以降

参照(&)及びポインタ(*)の位置を統一する。
trueを指定した場合、ファイル内で一番記述の参照及びポインタの書式に統一する。 falseを指定した場合、PointerAlignmentで指定した値に従い書式を変更する。PointerAlignmentの指定がない場合、trueと同じ動作となる。

例

int* p1 = NULL; // データ型に*が寄せられている
int &r1 = d;    // 変数名に&が寄せられている
int *p2 = NULL; // 変数名に*が寄せられている
↓ // DerivePointerAlignment: true を指定した場合
int *p1 = NULL; // 多数決(2対1)で変数名に寄せているパターンが多いので変数名側に統一される。
int &r1 = d;
int *p2 = NULL;

DisableFormat(Boolean) 3.7以降

フォーマットを無効にする。

EmptyLineAfterAccessModifier(EmptyLineAfterAccessModifierStyle) 13以降

アクセス修飾子の後に対する制御方法を指定する。

値	意味
Never	アクセス修飾子の後の空行をすべて削除する。
Leave	アクセス修飾子の後の空行を削除しない。代わりにMaxEmptyLinesToKeepによる制御が行われる。
Always	アクセス修飾子の後の空行を追加する。MaxEmptyLinesToKeepによる制御も同時に適用される。

Never

struct foo {
private:
  int i;
protected:
  int j;
  /* comment */
public:
  foo() {}
private:
protected:
};

Always

struct foo {
private:

  int i;
protected:

  int j;
  /* comment */
public:

  foo() {}
private:

protected:

};

EmptyLineBeforeAccessModifier(EmptyLineBeforeAccessModifierStyle) 12以降

アクセス修飾子の前に対する制御方法を指定する。

値	意味
Never	アクセス修飾子の前の空行をすべて削除する。
Leave	アクセス修飾子の前の空行を削除しない。
LogicalBlock	アクセス修飾子が新しい論理ブロックを開始する場合だけ、空行を追加する。論理ブロックとは1つ以上のフィールド又は関数からなるグループのことを指す。
Always	アクセス修飾子がクラスや構造体の先頭にある場合を除き、アクセス修飾子の前に空行を追加する。

Never

struct foo {
private:
  int i;
protected:
  int j;
  /* comment */
public:
  foo() {}
private:
protected:
};

LogicalBlock

struct foo {
private:
  int i;

protected:
  int j;
  /* comment */
public:
  foo() {}

private:
protected:
};

Always

struct foo {
private:
  int i;

protected:
  int j;
  /* comment */

public:
  foo() {}

private:

protected:
};

ExperimentalAutoDetectBinPacking(Boolean) 3.7以降

trueの場合、clang-formatは関数呼び出しと定義が1行に1つのパラメータでフォーマットされているかどうかを検出します。

各呼び出しはbin-packed、1行ごと、または決定的でないことができます。もし結論が出ない場合、例えば完全に一行で、しかし決定を下す必要がある場合、clang-formatは入力ファイルに他のbin-packedケースがあるかどうかを分析し、それに応じて行動します。

注意
これは実験的なフラグであり、削除されたり名前が変更されたりする可能性があります。設定ファイルなどでは使用しないでください。ご自身の責任で使用してください。

メモ書き
記述内容及び挙動が理解できなかった為、直訳のみ。

FixNamespaceComments(Boolean) 5以降

名前空間の終了に自動でコメントを挿入するかを指定する。

true

namespace a {
foo();
bar();
} // namespace a
// ↑上記のコメントが自動で挿入される。

false

namespace a {
foo();
bar();
}
// コメントの挿入が行われない。

メモ書き
falseを指定しても既存のコメントが削除となるわけではない。逆にtrueを指定した場合、既存で独自にコメントを記載していても自動挿入で上書きされてしまう。

ForEachMacros(List of Strings) 3.7以降

foreachとして解釈されるべきマクロ名のリストを指定する。

例

// FOREACHマクロがforeachとして動作する
FOREACH(<variable-declaration>, ...)
  <loop-body>

.clang-format 設定ファイルでは、次の様に設定することができる。

ForEachMacros: ['RANGES_FOR', 'FOREACH', 'BOOST_FOREACH']

IfMacros(List of Strings) 13以降

ifとして解釈されるべきマクロ名のリストを指定する。

例

IF(...)
  <conditional-body>
else IF(...)
  <conditional-body>

.clang-format 設定ファイルでは、次の様に設定することができる。

ForEachMacros: ['IF', 'KJ_IF_MAYBE']

IncludeBlocks(IncludeBlocksStyle) 6以降

#include定義の並び順を決定する。

値	意味
Preserve	ブロック単位でソートを行う。
Merge	ブロックを結合し、ソートを行う。
Regroup	ブロックを結合し、ソートを行う。その後、カテゴリの優先順位に基づいてグループを分割する。IncludeCategoriesを参照。

参考：ソート前

#include "b.h"

#include <lib/main.h>
#include "a.h" 

Preserve

#include "b.h"

#include "a.h" 
#include <lib/main.h>

Merge

#include "a.h" 
#include "b.h"
#include <lib/main.h>

Regroup

#include "a.h" 
#include "b.h"

#include <lib/main.h>

IncludeBlocks(List of IncludeCategories) 3.8以降

インクルードの順序付けに使用される、さまざまな #include カテゴリを示す正規表現です。
正規表現の表記はPOSIXに準拠する。
これらの正規表現は、インクルードのファイル名(<>または""を含む)の順に照合されます。最初にマッチした正規表現に属する優先順位が割り当てられ、#includeは、優先順位及びカテゴリ内でアルファベット順にソートされます。

どの正規表現にも一致しない場合、INT_MAXがカテゴリーとして割り当てられます。ソースファイルのメインヘッダは自動的にカテゴリ0になります。そのため、一般的には#includesの先頭に置かれます。しかし、常に最初に来る必要があるヘッダーがある場合は、負の優先順位を割り当てることもできます。

3番目のオプションフィールドにSortPriorityがあります。これは、IncludeBlocksにRegroupを指定した場合、有効となり、#includesを並べる優先順位を定義することができます。Priorityの値は、#includeブロックの順序を定義し、また、異なる優先順位の#includeをグループ化することができます。SortPriorityが指定されていない場合、Priorityの値がデフォルトとして設定されます。

各正規表現は、CaseSensitiveフィールドで大文字と小文字を区別するようにマークすることができますが、デフォルトではそうではありません。

.clang-format ファイルで設定するには、次のようにします。

IncludeCategories:
  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
    Priority:        2
    SortPriority:    2
    CaseSensitive:   true
  - Regex:           '^((<|")(gtest|gmock|isl|json)/)'
    Priority:        3
  - Regex:           '<[[:alnum:].]+>'
    Priority:        4
  - Regex:           '.*'
    Priority:        1
    SortPriority:    0

メモ書き
SortPriority及びCaseSensitiveについては、古いバージョンでは指定ができない。(少なくとも8.0.1では使用ができなかった。)。いつ段階から実装されたかについては未調査。

IncludeIsMainRegex(String) 3.9以降

file-to-main-include のマッピングで許可されるサフィックスの正規表現を指定します。
ある#includeが「メイン」includeであるかどうかを推測する場合（カテゴリ0を割り当てるため、上記を参照）、ヘッダーステムに許容される接尾辞のこの正規表現を使用します。部分マッチが行われ、次のようになります。- "" は "任意のサフィックス" を意味します - "$" は "サフィックスなし" を意味します。

例えば、"(_test)?$" と設定した場合、ヘッダ a.h は a.cc と a_test.cc の両方で "main" include とみなされるでしょう。

メモ書き
記述内容が明確に理解できなかった為、直訳。
以下、見解。
IncludeCategoriesの動作でソースファイルに対応するメインヘッダを判定するための正規表現を指定する。つまり、"(_test)?$"という正規表現を指定した場合、a.ccというソースファイルのヘッダファイルはa.hと判断し、インクルードの記述をソートする際に、(負の優先度を持つヘッダを除いて)一番先頭に配置される。

IncludeIsMainSourceRegex(String) 10以降

フォーマットされるファイルのうち、file-to-main-includeマッピングで "main "とみなすことが許されるファイルの正規表現を指定します。

デフォルトでは、clang-formatはファイルが以下のように終わるときだけ "main "と見なします。.c, .cc, .cpp, .c++, .cxx, .m, .mm の拡張子で終わる場合のみ、clang-format はファイルを "main" と見なします。これらのファイルでは、「main」インクルードの推測が行われます（カテゴリ0を割り当てるには、上記を参照してください）。このオプションは、"main "とみなされるファイルのサフィックスと拡張子を追加することができます。

例えば、このオプションを (Impl.hpp)$ に設定すると、ClassImpl.hpp が "main" と見なされ (Class.c, Class.cc, Class.cpp などに加えて)、"main include file" ロジックが実行されます (IncludeIsMainRegex 設定も後のフェーズで尊重される)。このオプションが設定されていないと、ClassImpl.hppは他のどのincludeよりも先にmain include fileをトップに置くことができません。

メモ書き
記述内容が明確に理解できなかった為、直訳。
以下、見解。
IncludeIsMainRegexのソースファイル版。ソースファイルをインクルードした場合にメインとなるソースを判定する為の正規表現を指定する。

IndentAccessModifiers(Boolean) 13以降

アクセス修飾子が独自のインデントレベルを持つかどうかを指定します。
trueの場合、アクセス修飾子は独自のインデント・レベルを取得します。その結果、アクセス修飾子の有無にかかわらず、レコードのメンバは常にレコードの下の2つのレベルにインデントされます。AccessModifierOffsetの値は無視されます。
false の場合、アクセス修飾子はAccessModifierOffsetに従ってレコード・メンバから相対的にインデント (またはアウトデント)されます。レコード・メンバーはレコードの1レベル下にインデントされます。

true

class C {
    class D {
        void bar();
      protected:
        D();
    };
  public:
    C();
};
void foo() {
  return 1;
}

false

class C {
  class D {
    void bar();
  protected:
    D();
  };
public:
  C();
};
void foo() {
  return 1;
}

IndentCaseBlocks(Boolean) 11以降

ケースラベルブロックをケースラベルから1レベルインデントします。
trueの場合、ブロックはスコープブロックとしてインデントされます。
false の場合、ケースラベルに続くブロックはケースラベルと同じインデントレベルを使用し、ケースラベルは if 文と同じように扱われます。

true

switch (fool) {
case 1:
  {
    bar();
  }
  break;
default:
  {
    plop();
  }
}

false

switch (fool) {
case 1: {
  bar();
} break;
default: {
  plop();
}
}

IndentCaseLabels(Boolean) 3.3以降

switch文のケースラベルのインデントを指定する。
trueの場合、ケースラベルはswitch文よりも一段インデントされます。
falseの場合、ケースラベルはswitch文と同じインデントレベルを使用します。
ステートメント本体は常にケースラベルよりも一段インデントされます。

true

switch (fool) {
  case 1:
    bar();
    break;
  default:
    plop();
}

false

switch (fool) {
case 1:
  bar();
  break;
default:
  plop();
}

IndentExternBlock(IndentExternBlockStyle) 11以降

外部結合ブロックのインデントの種類を指定する。

値	意味
AfterExternBlock	BraceWrapping.AfterExternBlockの動作に従う。(AfterExternBlockの項を参照)
NoIndent	外部結合ブロックのインデントを行わない。
Indent	外部結合ブロックのインデントを行う。
true	Indentと同じ動作となる。(レガシーオプション)
false	NoIndentと同じ動作となる。(レガシーオプション)

NoIndent

extern "C" {
void foo();
}

Indent

extern "C" {
  void foo();
}

IndentGotoLabels(Boolean) 10以降

gotoラベルのインデントを指定する。

true

// gotoラベルはステートメント内で左寄せになる
int f() {
  if (foo()) {
  label1:
    bar();
  }
label2:
  return 1;
}

false

// gotoラベルは左寄せになる
int f() {
  if (foo()) {
label1:
    bar();
  }
label2:
  return 1;
}

IndentPPDirectives(IndentExternBlockStyle) 6以降

プリプロセッサ・ディレクティブのインデントの種類を指定する。

値	意味
None	プリプロセッサ・ディレクティブのインデントを行わない。
AfterHash	ハッシュの後についてインデントを行う。
BeforeHash	ハッシュを含めてインデントを行う。

None

#if FOO
#if BAR
#include <foo>
#endif
#endif

AfterHash

#if FOO
#  if BAR
#    include <foo>
#  endif
#endif

BeforeHash

#if FOO
  #if BAR
    #include <foo>
  #endif
#endif

IndentRequiresClause(Boolean) 15以降

テンプレート定義のrequires節のインデントを指定する。
これは、RequiresClausePositionがOwnLine又はWithFollowingの場合にのみ適用されます。

備考
名前が変更されています。clang-format 12～14では、IndentRequiresという名前でした。

true

template <typename It>
  requires Iterator<It>
void sort(It begin, It end) {
  //....
}

false

template <typename It>
requires Iterator<It>
void sort(It begin, It end) {
  //....
}

IndentWidth(Unsigned) 3.7以降

インデントに使用する値を指定する

IndentWrappedFunctionNames(Boolean) 3.7以降

関数定義や宣言が1行に収まらない場合、次行をインデントするか指定する。

true

// 次の行をインデントする
LoooooooooooooooooooooooooooooooooooooooongReturnType
    LoooooooooooooooooooooooooooooooongFunctionDeclaration();

false

// 次の行をインデントしない
LoooooooooooooooooooooooooooooooooooooooongReturnType
    LoooooooooooooooooooooooooooooooongFunctionDeclaration();

InsertBraces(Boolean) 15以降

C++の制御文（if, else, for, do, while）の後に波括弧を入れる。ただし、制御文がマクロ定義の中にあるか、波括弧がプリプロセッサー指令を囲んでしまう場合は除く。

警告
このオプションを true に設定すると、clang-format の完全なセマンティック情報の欠如により、不正なコードフォーマットになる可能性があります。そのため、このオプションで変更されたコードをレビューする際には、特に注意が必要です。

true

// 波括弧を省略しているステートメントについて自動で波括弧を付与する
if (isa<FunctionDecl>(D)) {
  handleFunctionDecl(D);
} else if (isa<VarDecl>(D)) {
  handleVarDecl(D);
} else {
  return;
}

while (i--) {
  for (auto *A : D.attrs()) {
    handleAttr(A);
  }
}
do {
  --i;
} while (i);

false

// 波括弧を省略しているステートメントについて何もしない
if (isa<FunctionDecl>(D))
  handleFunctionDecl(D);
else if (isa<VarDecl>(D))
  handleVarDecl(D);
else
  return;

while (i--)
  for (auto *A : D.attrs())
    handleAttr(A);
do
  --i;
while (i);

メモ書き
既に波括弧を付与しているファイルに対してfalseを指定しても、波括弧の削除は行われない。

InsertTrailingCommas(TrailingCommaStyle) 11以降

複数行にまたがるコンテナリテラル(配列とオブジェクト)の末尾のカンマを付与を指定する。
Clang-Format15の段階ではJavaScriptのみ使用可能で、デフォルトはNoneで無効となっている。
また、BinPackArgumentsと同時に使用することは出来ません。

値	意味
None	末尾にカンマを挿入しない。
Wrapped	末尾にカンマを挿入する。

Wrapped

const someArray = [
aaaaaaaaaaaaaaaaaaaaaaaaaa,
aaaaaaaaaaaaaaaaaaaaaaaaaa,
aaaaaaaaaaaaaaaaaaaaaaaaaa,
//                        ^ inserted
]

InsertTrailingCommas(List of Strings) 8以降

Javaのimport宣言のグループ化の接頭辞を指定する。
一致する接頭辞が複数ある場合、最長の接頭辞を優先する。グループ内は辞書順にソートされる。静的なインポートは別でグループ化され、同じルールが適用となる。デフォルトでは静的なインポート宣言は非静的なインポート宣言の前に配置される。この動作はSortJavaStaticImportにより変更が可能である。

.clang-format ファイルで次の設定をした場合、Javaのインポート宣言は以下のように並びます。

JavaImportGroups: ['com.example', 'com', 'org']

Javaソースの例

import static com.example.function1;

import static com.test.function2;

import static org.example.function3;

import com.example.ClassA;
import com.example.Test;
import com.example.a.ClassB;

import com.test.ClassC;

import org.example.ClassD;

JavaScriptQuotes(JavaScriptQuoteStyle) 3.9以降

JavaScriptの文字列のクォートを指定する。

値	意味
Leave	文字列のクォートは変更しない。
Single	常にシングルクォートを使用する。
Double	常にダブルクォートを使用する。

Leave

string1 = "foo";
string2 = 'bar';

Single

string1 = 'foo';
string2 = 'bar';

Single

string1 = "foo";
string2 = "bar";

JavaScriptWrapImports(Boolean) 3.9以降

JavaScriptのimport/export文をラップ方法を指定する。

true

import {
    VeryLongImportsAreAnnoying,
    VeryLongImportsAreAnnoying,
    VeryLongImportsAreAnnoying,
} from 'some/module.js'

false

import {VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying,} from "some/module.js"

KeepEmptyLinesAtTheStartOfBlocks(Boolean) 3.7以降

ブロックの先頭の空白の扱いを指定する。

true

// ブロックの先頭の空白を維持する
if (foo) {

  bar();
}

false

// ブロックの先頭の空白を削除する
if (foo) {
  bar();
}

メモ書き
維持であり、挿入ではない。trueを指定しても空白行の挿入は行われない。

LambdaBodyIndentation(LambdaBodyIndentationKind) 13以降

ラムダ式の本体の改行ルールを指定する。
コールバックの多いコードではOuterScopeを使用してシグネチャを2段階インデントした方が可読性が高くなる場合がある。(KJ Style guideではOuterScopeを必須としています)

値	意味
Signature	ラムダ式の本体をシグネチャのインデントレベルに対して1段下げる。
OuterScope	ラムダ式の本体を親スコープのインデントレベルに対して1段下げる。

Signature

someMethod(
    [](SomeReallyLongLambdaSignatureArgument foo) {
      return;
    });

OuterScope

someMethod(
    [](SomeReallyLongLambdaSignatureArgument foo) {
  return;
});

Language(LanguageKind) 3.5以降

対象となる言語を指定する。

値	意味
Cpp	C言語及びC++に使用する。
CSharp	C♯に使用する。
Java	Javaに使用する。
JavaScript	JavaScriptに使用する。
Json	Jsonに使用する。
ObjC	Objective-C及びObjective-C++に使用する。
Proto	Protocol Buffersに使用する。(https://developers.google.com/protocol-buffers/)
TableGen	TableGenに使用する。
TextProto	テキスト形式のProtocol Buffersに使用する。(https://developers.google.com/protocol-buffers/)
Verilog	Verilog及びSystemVerilogに使用する。(https://standards.ieee.org/ieee/1800/6700/ https://sci-hub.st/10.1109/IEEESTD.2018.8299595)

メモ書き
公式にはNoneが使用不可で記載されている。プログラム上、LanguageKindにNoneの定義が無いので指定するとyamlの解析でエラーになる。(使用不可というかそもそも使えない、レガシー？)

例

---
# 各言語の共通設定を記述する
BasedOnStyle: LLVM
IndentWidth: 4
---
# C++固有の設定を書く
Language: Cpp
...
# ここまでC++固有の設定
---
# JavaScript固有の設定を書く
Language: JavaScript
...
# ここまでJavaScript固有の設定
---
# 以下同様に必要な言語の設定を記載していく
...

MacroBlockBegin(String) 3.7以降
MacroBlockEnd(String) 3.7以降

ブロックの先頭及び末尾となるマクロを正規表現で指定する。

記述例

MacroBlockBegin: "^NS_MAP_BEGIN|NS_TABLE_HEAD$"
MacroBlockEnd: "^NS_MAP_END|NS_TABLE_.*_END$"

実行例(MacroBlockBegin及びMacroBlockEndを指定しない場合)

// マクロで開始終了を内包するようなパターンの場合
#deinfe NS_MAP_BEGIN if( x ) {
#deinfe NS_MAP_END   }

// 開始/終了のマクロが判断できないため、本体部分の処理が前寄せになる。
NS_MAP_BEGIN
foo();
NS_MAP_END

実行例(MacroBlockBegin及びMacroBlockEndを指定した場合)

// 開始/終了のマクロが正規表現で判定出来たため、本体部分の処理にインデントが付与される。
NS_MAP_BEGIN
  foo();
NS_MAP_END

MaxEmptyLinesToKeep(String) 3.7以降

空行の最大保持数を指定する。

変更前

int f() {


  int i = 1;


  i = foo();


  return i;


}

MaxEmptyLinesToKeep : 0 を指定した場合

int f() {
  int i = 1;
  i = foo();
  return i;
}

MaxEmptyLinesToKeep : 1 を指定した場合

int f() {

  int i = 1;

  i = foo();

  return i;
}
// ↑ステートメントの終了前の空白は必ずすべて削除される。

メモ書き
MaxEmptyLinesToKeepにNを指定しても最大N行の空白行が残るだけで、N行の空白が挿入となるわけではない。

NamespaceIndentation(NamespaceIndentationKind) 3.7以降

名前空間のインデントを指定する。
コールバックの多いコードではOuterScopeを使用してシグネチャを2段階インデントした方が可読性が高くなる場合がある。(KJ Style guideではOuterScopeを必須としています)

値	意味
None	名前空間にインデントを行わない。
Inner	ネストした名前空間だけインデントを行う。
All	すべての名前空間をインデントする。

None

namespace out {
int i;
namespace in {
int i;
}
}

Inner

namespace out {
int i;
namespace in {
  int i;
}
}

All

namespace out {
  int i;
  namespace in {
    int i;
  }
}

NamespaceMacros(List of Strings) 9以降

名前空間の開始となるマクロのリストを指定する。

記述例

NamespaceMacros: ['NAMESPACE', 'TESTSUITE']

実行例

NAMESPACE(<namespace-name>, ...) {
  <namespace-content>
}

ObjCBinPackProtocolList(BinPackStyle) 9以降

Objective-Cプロトコル準拠のリスト項目がColumnLimitを超えた場合の改行の制御を指定する。

値	意味
Auto	BinPackParametersの指定に従う。BinPackParametersがtrueの場合、Alwaysと同じ動作となる。falseの場合、Neverと同じ動作となる。
Always	ColumnLimitに収まる最小の行に纏める。
Never	個々の行に纏める。

Always(又はAutoかつBinPackParametersがtrue)

@interface ccccccccccccc () <
    ccccccccccccc, ccccccccccccc,
    ccccccccccccc, ccccccccccccc> {
}

Never(又はAutoかつBinPackParametersがfalse)

@interface ddddddddddddd () <
    ddddddddddddd,
    ddddddddddddd,
    ddddddddddddd,
    ddddddddddddd> {
}

ObjCBlockIndentWidth(Unsigned) 3.7以降

Objective-Cブロックのインデントの値を指定する。

ObjCBreakBeforeNestedBlockParam(Boolean) 11以降

Objective-Cの関数呼び出し時にブロックパラメータがネストしている場合の、パラメータリストの記載方法について指定する。

true

- (void)_aMethod
{
  [self.test1 t:self
              w:self
       callback:^(typeof(self) self, NSNumber *u, NSNumber *v) {
           u = c;
       }]
}

false

- (void)_aMethod
{
  [self.test1 t:self w:self
       callback:^(typeof(self) self, NSNumber *u, NSNumber *v) {
           u = c;
       }]
}

ObjCSpaceAfterProperty(Boolean) 3.7以降

Objective-Cの@propertyの後にスペースを入れるかを指定する。

true

@property (readonly) NSString* foo; 

false

@property(readonly) NSString* foo; 

ObjCSpaceBeforeProtocolList(Boolean) 3.7以降

Objective-Cのプロトコルリストの前にスペースを入れるかを指定する。

true

@protocol Foo <NSObject>

false

@protocol Foo<NSObject>

PPIndentWidth(Integer) 13以降

プリプロセッサのインデントの値を指定する。
-1を指定した場合、IndentWidthの値が使用される。

PPIndentWidth: 1 の場合

#ifdef __linux__
# define FOO
#else
# define BAR
#endif

PackConstructorInitializers(PackConstructorInitializersStyle) 14以降

コンストラクタの初期化リストの並べ方について指定する。

値	意味
Never	初期化リストは1行ずつ改行する。
BinPack	ColumnLimitに収まる最小の行に纏める。
CurrentLine	すべての初期化リストが1行に収まる場合、1行に纏める。1行に収まらない場合、Neverと同じ動作となる。
NextLine	CurrentLineと同じ動作。ただし、コンストラクタの開始行にすべての要素が収まらない場合、次の行に収まるようにする。

Never

Constructor()
    : a(),
      b()

BinPack

Constructor()
    : aaaaaaaaaaaaaaaaaaaa(), bbbbbbbbbbbbbbbbbbbb(),
      cccccccccccccccccccc()

CurrentLine

Constructor() : a(), b()

// すべての要素が1行で収まらない場合、Neverと同じ動作をする
Constructor()
    : aaaaaaaaaaaaaaaaaaaa(),
      bbbbbbbbbbbbbbbbbbbb(),
      ddddddddddddd()

NextLine

// コンストラクタと同じ行に収まる場合、その行にすべての要素を出力する。
Constructor() : a(), b()

// コンストラクタと同じ行に収まらない場合、次の行に収まるように整形する。
Constructor()
    : aaaaaaaaaaaaaaaaaaaa(), bbbbbbbbbbbbbbbbbbbb(), ddddddddddddd()

// 次の行にも収まらない長さの場合、Neverと同じ動作をする。
Constructor()
    : aaaaaaaaaaaaaaaaaaaa(),
      bbbbbbbbbbbbbbbbbbbb(),
      cccccccccccccccccccc()

PenaltyBreakAssignment(Unsigned) 5以降

代入演算子関連の改行に対するペナルティ

メモ書き
以降Penalty～について、用途が理解できなかった為、直訳のみ。
ただし、BasedOnStyleの各定義を見ると値を設定しているため、必要な数値である模様。

PenaltyBreakBeforeFirstCallParameter(Unsigned) 3.7以降

関数呼び出し後の改行に対するペナルティ

PenaltyBreakComment(Unsigned) 3.7以降

コメント内での改行に対するペナルティ

PenaltyBreakFirstLessLess(Unsigned) 3.7以降

最初の左シフトの前の改行に対するペナルティ

PenaltyBreakOpenParenthesis(Unsigned) 14以降

’(’の後の改行に対するペナルティ

PenaltyBreakString(Unsigned) 3.7以降

文字列リテラル内の改行に対するペナルティ

PenaltyBreakTemplateDeclaration(Unsigned) 7以降

テンプレート宣言の後の改行に対するペナルティ

PenaltyExcessCharacter(Unsigned) 3.7以降

行の最大文字数を超過した場合の文字の改行に対するペナルティ

PenaltyIndentedWhitespace(Unsigned) 12以降

空白文字のインデント1文字あたりのペナルティ(非ホワイトスペースの先頭列からの相対値でカウントされる)。

PenaltyReturnTypeOnItsOwnLine(Unsigned) 3.7以降

関数の戻り値の型を関数と同一行とした場合のペナルティ。

PointerAlignment(PointerAlignmentStyle) 3.7以降

ポインタ及び参照のアライメントについて指定する。

値	意味
Left	左に寄せる。
Right	右に寄せる。
Middle	中央に寄せる。
true	Leftと同じ動作。(レガシーオプション)
false	Rightと同じ動作。(レガシーオプション)

Left

int* a;

Right

int *a;

Middle

int * a;

QualifierAlignment(QualifierAlignmentStyle) 14以降

指定子や修飾子の並べ方を指定する(例：const/volatile)。

警告
QualifierAlignmentをLeave以外に設定すると、clang-formatsが完全な意味情報を持っていないため、間違った判断を下してしまい、コードが正しくフォーマットされない可能性があります。そのため、このオプションを使って変更されたコードをレビューする際には、特別な注意を払う必要があります。

値	意味
Leave	変更しない。
Left	指定子及び修飾子を左に寄せる。
Right	指定子及び修飾子を右に寄せる。
Custom	QualifierOrderで指定した値に従う。

Leave

int const a;
const int *a;

Left

const int a;
const int *a;

Right

int const a;
int const *a;

QualifierOrderの指定(Custom用)

QualifierOrder: ['inline', 'static' , 'type', 'const']

Custom

// 修飾子及び型がQualifierOrderで指定した順序('type', 'const')の順に並ぶ
int const a;
int const *a;

QualifierOrder(List of Strings) 14以降

型、指定子及び修飾子の並び順を文字列リストで指定する。
この値はQualifierAlignmentにCustomを指定した場合、使用される。
指定する文字列リストは必ず'type'を含む必要がある。 指定可能なキーワードは以下のとおり。
・const
・inline
・static
・constexpr
・volatile
・restrict
・type
※typeはデータ型を意味する(例えばint)

例

QualifierOrder: ['inline', 'static' , 'type', 'const']

RawStringFormats(List of RawStringFormats) 6以降

変換対象のファイルの内容がどの言語のコードブロックであるか判断するための定義を指定する。
デリミタが一致するか、関数名が一致する文字列を検出した場合、.clang-formatでその言語用に指定した定義によりフォーマットを行う。特定言語に対しての定義が見つからない場合、BasedOnStyleで指定したフォーマットに従い再変換を行う。BasedOnStyleが見つからない場合、llvmのフォーマットに基づき変換を行う。
マッチする言語は区切り文字にマッチするものが関数にマッチするものよりも優先されます。

例

RawStringFormats:
  - Language: TextProto  # Language参照
      Delimiters: # 拡張子
        - 'pb'
        - 'proto'
      EnclosingFunctions: # 一致する関数等
        - 'PARSE_TEXT_PROTO'
      BasedOnStyle: google # 一致した場合のフォーマット
  - Language: Cpp
      Delimiters:
        - 'cc'
        - 'cpp'
      BasedOnStyle: llvm
      CanonicalDelimiter: 'cc'

ReferenceAlignment(ReferenceAlignmentStyle) 13以降

参照のアライメントについて指定する。(参照についてPointerAlignmentの指定を上書きする)

値	意味
Pointer	PointerAlignmentの指定に従う。
Left	左に寄せる。
Right	右に寄せる。
Middle	中央に寄せる。

Left

int& a;

Right

int &a;

Middle

int & a;

ReflowComments(ReferenceAlignmentStyle) 4以降

1行の最大文字数を超えたコメントの折り返しについて指定する。

true

// ColumnLimitを超えるコメントを自動で改行する
// veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
// information
/* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
 * information */

false

// ColumnLimitを超えるコメントの改行を行わない
// veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information
/* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information */

RemoveBracesLLVM(Boolean) 14以降

LLVMコーディングスタイルに従って、C++の制御文（if, else, for, while）のオプションの波括弧を削除する。

警告
このオプションは名称を変更し、他のスタイルにも対応できるように拡張する予定です。

警告
このオプションを true に設定すると、clang-format の完全なセマンティック情報の欠如により、不正なコードフォーマットになる可能性があります。そのため、このオプションで変更されたコードをレビューする際には、特に注意が必要です。

true

// 省略が可能な波括弧について削除する
if (isa<FunctionDecl>(D))
  handleFunctionDecl(D);
else if (isa<VarDecl>(D))
  handleVarDecl(D);

if (isa<VarDecl>(D)) {
  for (auto *A : D.attrs())
    if (shouldProcessAttr(A))
      handleAttr(A);
}

if (isa<FunctionDecl>(D))
  for (auto *A : D.attrs())
    handleAttr(A);

if (auto *D = (T)(D)) {
  if (shouldProcess(D))
    handleVarDecl(D);
  else
    markAsIgnored(D);
}

if (a)
  b();
else if (c)
  d();
else
  e();

false

// 波括弧を特に変更しない
if (isa<FunctionDecl>(D)) {
  handleFunctionDecl(D);
} else if (isa<VarDecl>(D)) {
  handleVarDecl(D);
}

if (isa<VarDecl>(D)) {
  for (auto *A : D.attrs()) {
    if (shouldProcessAttr(A)) {
      handleAttr(A);
    }
  }
}

if (isa<FunctionDecl>(D)) {
  for (auto *A : D.attrs()) {
    handleAttr(A);
  }
}

if (auto *D = (T)(D)) {
  if (shouldProcess(D)) {
    handleVarDecl(D);
  } else {
    markAsIgnored(D);
  }
}

if (a) {
  b();
} else {
  if (c) {
    d();
  } else {
    e();
  }
}

RequiresClausePosition(RequiresClausePositionStyle) 15以降

requires句の改行について指定する。

値	意味
OwnLine	必ず改行する。
WithPreceding	宣言と同じ行となるようにする。クラス又は関数のテンプレート宣言の場合、テンプレート宣言に従う。関数宣言の場合、引数リストに従う。
WithFollowing	クラスや関数の宣言と同じにする。
SingleLine	可能な限り1行に記載する。1行で記載できない場合、改行する。

OwnLine

template <typename T>
requires C<T>
struct Foo {...

template <typename T>
requires C<T>
void bar(T t) {...

template <typename T>
void baz(T t)
requires C<T>
{...

WithPreceding

template <typename T> requires C<T>
struct Foo {...

template <typename T> requires C<T>
void bar(T t) {...

template <typename T>
void baz(T t) requires C<T>
{...

WithFollowing

template <typename T>
requires C<T> struct Foo {...

template <typename T>
requires C<T> void bar(T t) {...

template <typename T>
void baz(T t)
requires C<T> {...

SingleLine

// 1行で収まる場合
template <typename T> requires C<T> struct Foo {...

template <typename T> requires C<T> void bar(T t) {...

template <typename T> void bar(T t) requires C<T> {...

// 1行で収まらない場合
template <typename LongName>
requires C<LongName>
struct Foo {...

template <typename LongName>
requires C<LongName>
void bar(LongName ln) {

template <typename LongName>
void bar(LongName ln)
    requires C<LongName> {

SeparateDefinitionBlocks(SeparateDefinitionStyle) 14以降

クラス、構造体、列挙型、関数などの定義ブロックの区切りに、空行を挿入するかを指定する。

値	意味
Leave	変更しない。
Always	定義ブロックの区切りに改行を挿入する。
Never	定義ブロックの区切りの改行を削除する。

Always

#include <cstring>

struct Foo {
  int a, b, c;
};

namespace Ns {
class Bar {
public:
  struct Foobar {
    int a;
    int b;
  };

private:
  int t;

  int method1() {
    // ...
  }

  enum List {
    ITEM1,
    ITEM2
  };

  template <typename T> int method2(T x) {
    // ...
  }

  int i, j, k;

  int method3(int par) {
    // ...
  }
};

class C {};
}

Never

#include <cstring>
struct Foo {
  int a, b, c;
};
namespace Ns {
class Bar {
public:
  struct Foobar {
    int a;
    int b;
  };
private:
  int t;
  int method1() {
    // ...
  }
  enum List {
    ITEM1,
    ITEM2
  };
  template <typename T> int method2(T x) {
    // ...
  }
  int i, j, k;
  int method3(int par) {
    // ...
  }
};
class C {};
}

ShortNamespaceLines(Unsigned) 13以降

短い名前空間は何行以下であるかについて、行数を指定する。デフォルトは1。
この値はFixNamespaceCommentsがtrueの場合、終了コメントを追加するために使用する。

ShortNamespaceLines: 0 を指定した場合

// どちらの名前空間も0行より大きいので、FixNamespaceCommentsの動作により名前空間の末尾にコメントを挿入する。
namespace a {
  int foo;
} // namespace a

namespace b {
  int foo;
  int bar;
} // namespace b

ShortNamespaceLines: 1 を指定した場合

// 名前空間aは1行以下なのでコメントの挿入を行わない。bは1行より大きいのでコメントの挿入を行う。
namespace a {
  int foo;
}

namespace b {
  int foo;
  int bar;
} // namespace b

SortIncludes(SortIncludesOptions) 4以降

インクルート文のソート条件について指定する。

値	意味
Never	ソートしない。
CaseSensitive	大文字と小文字を区別してアスキーコード順にソートを行う。
CaseInsensitive	大文字と小文字を区別せずアルファベット順にソートを行う。
true	CaseSensitiveと同じ動作。(レガシーオプション)
false	Neverと同じ動作。(レガシーオプション)

Never

#include "B/A.h"
#include "A/B.h"
#include "a/b.h"
#include "A/b.h"
#include "B/a.h"

CaseSensitive

#include "A/B.h"
#include "A/b.h"
#include "B/A.h"
#include "B/a.h"
#include "a/b.h"

CaseInsensitive

#include "A/B.h"
#include "A/b.h"
#include "a/b.h"
#include "B/A.h"
#include "B/a.h"

SortJavaStaticImport(SortJavaStaticImportOptions) 12以降

Javaのインポート文の並び順について指定する。

値	意味
Before	静的なインポートを非静的なインポートの前に置く。
After	静的なインポートを非静的なインポートの後に置く。

Before

import static org.example.function1;

import org.example.ClassA;

After

import org.example.ClassA;

import static org.example.function1;

メモ書き
公式ドキュメントに不備あり。JavaStaticImportAfterImportについてはSortJavaStaticImportの誤記の理解。

SortUsingDeclarations(Boolean) 5以降

using宣言のソート方法を指定する。
ソートは名前空間の単位で行う。また、ソートは大文字小文字を区別せず、アルファベット順で行う。

true

using foo::bar;
using std::cin;
using std::cout;

using ABC::DEF::GHI;
using ABC::XYZ::GHI;

false

using std::cout;
using std::cin;
using foo::bar;

using ABC::XYZ::GHI;
using ABC::DEF::GHI;

SpaceAfterCStyleCast(Boolean) 3.5以降

C言語キャストの後のスペースを指定する。

true

// C言語キャストの後にスペースを挿入する
(int) i; 

false

// C言語キャストの後にスペースを挿入しない
(int) i; 

SpaceAfterLogicalNot(Boolean) 9以降

論理否定の後のスペースを指定する。

true

// 論理否定の後にスペースを挿入する
! someExpression();

false

// 論理否定の後にスペースを挿入しない
!someExpression();

SpaceAfterTemplateKeyword(Boolean) 4以降

テンプレートキーワードの後のスペースを指定する。

true

// テンプレートキーワードの後にスペースを挿入する
template <int> void foo();

false

// テンプレートキーワードの後にスペースを挿入しない
template<int> void foo();

SpaceAroundPointerQualifiers(SpaceAroundPointerQualifiersStyle) 12以降

ポインタ修飾子(const/volatile)の前後の空白を指定する。
また、PointerAlignmentの動作とは別で空白の挿入が行われる。

値	意味
Default	PointerAlignmentで指定した動作とする。
Before	ポインタ修飾子の前に空白を挿入する。
After	ポインタ修飾子の後に空白を挿入する。
Both	ポインタ修飾子の前後に空白を挿入する。

Default(PointerAlignment: Leftの場合)

void* const* x = NULL;

Default(PointerAlignment: Rightの場合)

void *const *x = NULL;

Before(PointerAlignment: Leftの場合)

void* const* x = NULL;

Before(PointerAlignment: Rightの場合)

void * const * x = NULL;

After(PointerAlignment: Leftの場合)

void* const * x = NULL;

After(PointerAlignment: Rightの場合)

void *const *x = NULL;

Both(PointerAlignment: Leftの場合)

void* const * x = NULL;

Both(PointerAlignment: Rightの場合)

void * const *x = NULL;

SpaceBeforeAssignmentOperators(Boolean) 3.7以降

代入演算子の前のスペースを指定する。

true

// 代入演算子の前にスペースを挿入する。
int a = 5;
a += 42;

false

// 代入演算子の前のスペースを削除する。
int a= 5;
a+= 42;

SpaceBeforeCaseColon(Boolean) 12以降

caseラベルのコロンの前のスペースを指定する。

true

// caseラベルのコロンの前にスペースを挿入する。
switch (x) {
  case 1 : break;
}

false

// caseラベルのコロンの前のスペースを削除する。
switch (x) {
  case 1: break;
}

SpaceBeforeCpp11BracedList(Boolean) 7以降

C++11の初期化リストの前のスペースを指定する。

true

// 初期化リストの前にスペースを挿入する。
Foo foo { bar };
Foo {};
vector<int> { 1, 2, 3 };
new int[3] { 1, 2, 3 };

false

// 初期化リストの前のスペースを削除する。
Foo foo{ bar };
Foo{};
vector<int>{ 1, 2, 3 };
new int[3]{ 1, 2, 3 };

SpaceBeforeCtorInitializerColon(Boolean) 7以降

コンストラクタの初期化リストのコロンの前のスペースを指定する。

true

// コロンの前にスペースを挿入する。
Foo::Foo() : a(a) {} 

false

// コロンの前のスペースを削除する。
Foo::Foo(): a(a) {}

SpaceBeforeInheritanceColon(Boolean) 7以降

クラス宣言の継承リストのコロンの前のスペースを指定する。

true

// コロンの前にスペースを挿入する。
class Foo : Bar {}

false

// コロンの前のスペースを削除する。
class Foo: Bar {} 

SpaceBeforeParens(SpaceBeforeParensStyle) 3.5以降

丸括弧の前にスペースを挿入する条件を指定する。

値	意味
Never	丸括弧の前の空白を削除する。
ControlStatements	制御文のキーワード(for/if/while等)の後のみ、丸括弧の前に空白を挿入する。
ControlStatementsExceptControlMacros	ControlStatementsと同じ動作。ただし、ForEachMacros及びIfMacrosにて指定したマクロ名には適用されない。
NonEmptyParentheses	括弧内が空ではない場合、丸括弧の前に空白を挿入する。
Always	構文規約で禁止されている(関数マクロの定義等)又は他のスタイル規則で決められている場合を除き、丸括弧の前に空白を挿入する。
Custom	SpaceBeforeParensOptionsにより、個別に指定を行う。
false	Neverと同じ動作。(レガシーオプション)
true	ControlStatementsと同じ動作。(レガシーオプション)
ControlStatementsExceptForEachMacros	ControlStatementsExceptControlMacrosと同じ動作。(レガシーオプション)

Never

void f() {
  if(true) {
    f();
  }
}

ControlStatements

void f() {
  if (true) {
    f();
  }
}

ControlStatementsExceptControlMacros

void f() {
  Q_FOREACH(...) {
    f();
  }
}

NonEmptyParentheses

void() {
  if (true) {
    f();
    g (x, y, z);
  }
}

Always

void f () {
  if (true) {
    f ();
  }
}

SpaceBeforeParensOptions(SpaceBeforeParensCustom) 14以降

丸括弧の前にスペース制御を個別に指定する。
SpaceBeforeParensがCustomに指定されている場合、SpaceBeforeParensOptionsで指定した値に従い、スペースの制御を行います。SpaceBeforeParensがCustom以外の場合、この値は無視されます。

記述例

SpaceBeforeParens: Custom
SpaceBeforeParensOptions:
  AfterControlStatements: true
  AfterFunctionDefinitionName: true

AfterControlStatements(Boolean)

制御文のキーワード(for/if/while等)と開始括弧の間のスペースを指定する。

true

// スペースを挿入する
if (...) {}

false

// スペースを削除する
if(...) {}

AfterForeachMacros(Boolean)

ForEachMacrosで指定したマクロと開始括弧の間のスペースを指定する。

true

// スペースを挿入する
FOREACH (...)
  <loop-body>

false

// スペースを削除する
FOREACH(...)
  <loop-body>

AfterFunctionDeclarationName(Boolean)

関数宣言と開始括弧の間のスペースを指定する。

true

// スペースを挿入する
void f ();

false

// スペースを削除する
void f();

AfterFunctionDefinitionName(Boolean)

関数定義と開始括弧の間のスペースを指定する。

true

// スペースを挿入する
void f () {};

false

// スペースを削除する
void f() {};

AfterIfMacros(Boolean)

IfMacrosで指定したマクロと開始括弧の間のスペースを指定する。

true

// スペースを挿入する
IF (...)
  <conditional-body>

false

// スペースを削除する
IF(...)
  <conditional-body>

AfterIfMacros(Boolean)

演算子のオーバーロードと開始括弧の間のスペースを指定する。

true

// スペースを挿入する
void operator++ (int a);
object.operator++ (10); 

false

// スペースを削除する
void operator++(int a);
object.operator++(10); 

AfterRequiresInClause(Boolean)

requires句と開始括弧の間のスペースを指定する。

true

// スペースを挿入する
template<typename T>
requires (A<T> && B<T>)
...

false

// スペースを削除する
template<typename T>
requires(A<T> && B<T>)
...

AfterRequiresInExpression(Boolean)

requires式と開始括弧の間のスペースを指定する。

true

// スペースを挿入する
template<typename T>
concept C = requires (T t) {
              ...
            }

false

// スペースを削除する
template<typename T>
concept C = requires(T t) {
              ...
            }

BeforeNonEmptyParentheses(Boolean)

括弧内が空ではない場合の、開始括弧の間のスペースを指定する。

true

// 括弧内が空白ではない場合、スペースを挿入する
void f (int a);
f (a);

false

// スペースを削除する
void f();
f();

SpaceBeforeRangeBasedForLoopColon(Boolean) 7以降

範囲指定でのfor文のコロンの前のスペースを指定する。

true

// コロンの前にスペースを挿入する。
for (auto v : values) {}

false

// コロンの前のスペースを削除する。
for (auto v: values) {}

メモ書き
公式の例ではforの前のスペースについても変更されているが、誤記の理解。(clang-format8.0.1及び15で確認の結果、変更されない)

SpaceBeforeSquareBrackets(Boolean) 10以降

角括弧の前のスペースを指定する。ただし、ラムダ式についてはこの指定の影響を受けない。

true

// 角括弧の前にスペースを挿入する。
int a [5];
int a [5][5];

false

// 角括弧の前のスペースを削除する。
int a[5];
int a[5][5];

SpaceInEmptyBlock(Boolean) 10以降

空白の波括弧の間のスペースを指定する。

true

// 空白の波括弧の間にスペースを挿入する。
void f() { }
while (true) { }

false

// 空白の波括弧の間のスペースを削除する。
void f() {}
while (true) {}

SpaceInEmptyParentheses(Boolean) 3.7以降

空白の丸括弧の間のスペースを指定する。

true

// 空白の丸括弧の間にスペースを挿入する。
void f( ) {
  int x[] = {foo( ), bar( )};
  if (true) {
    f( );
  }
}

false

// 空白の丸括弧の間のスペースを削除する。
void f() {
  int x[] = {foo(), bar()};
  if (true) {
    f();
  }
}

SpacesBeforeTrailingComments(Unsigned) 3.7以降

行コメント(//)の前のスペースの数を指定する。

SpacesBeforeTrailingComments: 3 の場合

// 空白の丸括弧の間にスペースを挿入する。
void f() {
  if (true) {   // スペース3個分空白が開く
    f();        // 上に合わせる
  }             // foo
}

SpacesInAngles(SpacesInAnglesStyle) 3.4以降

テンプレートの引数リストの前後の空白を指定する。

値	意味
Never	< の後と > の前のスペースを削除する。
Always	< の後と > の前にスペースを挿入する。
Leave	< の後と > の前にスペースがあった場合、スペースを1つずつ残す。StandardにCpp03を指定している場合、そちらを優先する。
true	Alwaysと同じ動作。(レガシーオプション)
false	Neverと同じ動作。(レガシーオプション)

Never

// 引数リストの前後のスペースを削除する。
static_cast<int>(arg);
std::function<void(int)> fct;

Always

// 引数リストの前後にスペースを挿入する。
static_cast< int >(arg);
std::function< void(int) > fct;

SpacesInCStyleCastParentheses(Boolean) 3.7以降

C言語キャストの丸括弧内のスペースを指定する。

true

// 開き丸括弧の後及び閉じ丸括弧の前にスペースを挿入する。
x = ( int32 )y;

false

// 開き丸括弧の後及び閉じ丸括弧の前のスペースを削除する。
x = (int32)y;

SpacesInConditionalStatement(Boolean) 10以降

制御文(if, for, switch, while)の丸括弧内のスペースを指定する。

true

// 開き丸括弧の後及び閉じ丸括弧の前にスペースを挿入する。
if ( a )  { ... }
while ( i < 5 )  { ... }

false

// 開き丸括弧の後及び閉じ丸括弧の前のスペースを削除する。
if (a)  { ... }
while (i < 5)  { ... }

SpacesInContainerLiterals(Boolean) 3.7以降

コンテナ・リテラル(Objective-CやJavascriptの配列やdictリテラルなど)内のスペースを指定する。

true

// コンテナ・リテラル内にスペースを挿入する。
var arr = [ 1, 2, 3 ];
f({a : 1, b : 2, c : 3});

false

// コンテナ・リテラル内のスペースを削除する。
var arr = [1, 2, 3];
f({a: 1, b: 2, c: 3});

SpacesInLineCommentPrefix(SpacesInLineComment) 13以降

行頭のコメントで許容されるスペースの数の最大値及び最小値を指定する。
最大値に―1を指定した場合、最大値は無効となる。それ以外の場合、最大値が最小値より優先される。

書式例

SpacesInLineCommentPrefix:
  Minimum: 1
  Maximum: -1

Minimum: 2、Maximum: -1の場合

//  //の後に2文字スペースが挿入される
//  if (b) {
//    return true;
//  }         

Minimum: 2、Maximum: 1の場合

// //の後に1文字スペースが挿入される(最小は2だが最大が1の為、最大数を設定となる)
// if (b) {
//   return true;
// }         

SpacesInParentheses(Boolean) 3.7以降

丸括弧内の前後のスペースを指定する。

true

// 開き丸括弧の後及び閉じ丸括弧の前にスペースを挿入する。
t f( Deleted & ) & = delete;

false

// 開き丸括弧の後及び閉じ丸括弧の前のスペースを削除する。
t f(Deleted &) & = delete;

SpacesInSquareBrackets(Boolean) 3.7以降

角括弧内の前後のスペースを指定する。ただしラムダ式と値の無い角括弧のブロックについては対象外とする。

true

// 開き角括弧の後及び閉じ角括弧の前にスペースを挿入する。
int a[ 5 ];
std::unique_ptr<int[]> foo() {} // 値の無い角括弧は対象外

false

// 開き角括弧の後及び閉じ角括弧の前のスペースを削除する。
int a[5];

Standard(LanguageStandard) 3.7以降

対象とするC++の規格を指定する。

値	意味
c++03 C++03 Cpp03	C++03を指定する。
c++11 Cpp11	C++11を指定する。
c++14	C++17を指定する。
c++17	C++14を指定する。
c++20	C++20を指定する。
Latest	Latestを指定する。動作としてはC++11と同じになる。
Auto	自動で判別を行う。

StatementAttributeLikeMacros(List of Strings) 12以降

識別子として解釈させず、属性と同じように無視されるキーワードを指定する。
Qtのemitなどを識別子として処理させないための定義である。

書式例

StatementAttributeLikeMacros: ['emit', 'Q_EMIT']

StatementAttributeLikeMacros: [] を指定した場合

unsigned char data = 'x';
emit          signal(data); // emitを識別子と勘違いしてしまい、おかしな並び方になる

StatementAttributeLikeMacros: ['emit'] を指定した場合

unsigned char data = 'x';
emit signal(data); // emitを識別子と認識させない

StatementMacros(List of Strings) 8以降

完全な式として解釈されるべきマクロを指定する。

書式例

StatementMacros: ['Q_UNUSED', 'QT_REQUIRE_VERSION']

TabWidth(Unsigned) 3.7以降

タブ文字の数を指定する。

TypenameMacros(List of Strings) 9以降

関数呼び出しとしてではなく、型宣言として解釈されるべきマクロを指定する。

書式例

TypenameMacros: ['STACK_OF', 'LIST']

UseCRLF(Unsigned) 10以降

ファイル内の改行コードを指定する。
trueを指定した場合、ファイルの改行コードをCR+LFで統一する。DeriveLineEndingにtrueの場合、このフラグは無効となる。

UseTab(UseTabStyle) 3.7以降

変換結果のファイルでのタブの使用について指定する。

値	意味
Never	タブを使用しない。
ForIndentation	インデントについてのみタブを使用する。
ForContinuationAndIndentation	先頭の空白はすべてタブで埋め、行内に現れるアライメント(連続した代入や宣言など)にはスペースを使用する。
AlignWithSpaces	行の継続とインデントにはタブを使用し、整列にはスペースを使用します。
Always	少なくとも1つのタブストップから次のタブストップまでの空白を埋める必要がある場合は、タブを使用します。
true	Alwaysと同じ動作を行う。(レガシーオプション)
false	Neverと同じ動作を行う。(レガシーオプション)

WhitespaceSensitiveMacros(List of Strings) 11以降

ホワイトスペースが影響する変更をかけてはいけないマクロを指定する。

書式例

WhitespaceSensitiveMacros: ['STRINGIZE', 'PP_STRINGIZE']

３. 書式例

Clang-Format15でのLLVMの既定値を以下に示す。

---
Language:        Cpp
# BasedOnStyle:  LLVM
AccessModifierOffset: -2
AlignAfterOpenBracket: Align
AlignArrayOfStructures: None
AlignConsecutiveMacros: None
AlignConsecutiveAssignments: None
AlignConsecutiveBitFields: None
AlignConsecutiveDeclarations: None
AlignEscapedNewlines: Right
AlignOperands:   Align
AlignTrailingComments: true
AllowAllArgumentsOnNextLine: true
AllowAllConstructorInitializersOnNextLine: true
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortEnumsOnASingleLine: true
AllowShortBlocksOnASingleLine: Never
AllowShortCaseLabelsOnASingleLine: false
AllowShortFunctionsOnASingleLine: All
AllowShortLambdasOnASingleLine: All
AllowShortIfStatementsOnASingleLine: Never
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: false
AlwaysBreakTemplateDeclarations: MultiLine
AttributeMacros:
  - __capability
BinPackArguments: true
BinPackParameters: true
BraceWrapping:
  AfterCaseLabel:  false
  AfterClass:      false
  AfterControlStatement: 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
BreakBeforeBinaryOperators: None
BreakBeforeConceptDeclarations: true
BreakBeforeBraces: Attach
BreakBeforeInheritanceComma: false
BreakInheritanceList: BeforeColon
BreakBeforeTernaryOperators: true
BreakConstructorInitializersBeforeComma: false
BreakConstructorInitializers: BeforeColon
BreakAfterJavaFieldAnnotations: false
BreakStringLiterals: true
ColumnLimit:     80
CommentPragmas:  '^ IWYU pragma:'
CompactNamespaces: false
ConstructorInitializerAllOnOneLineOrOnePerLine: false
ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4
Cpp11BracedListStyle: true
DeriveLineEnding: true
DerivePointerAlignment: false
DisableFormat:   false
EmptyLineAfterAccessModifier: Never
EmptyLineBeforeAccessModifier: LogicalBlock
ExperimentalAutoDetectBinPacking: false
FixNamespaceComments: true
ForEachMacros:
  - foreach
  - Q_FOREACH
  - BOOST_FOREACH
IfMacros:
  - KJ_IF_MAYBE
IncludeBlocks:   Preserve
IncludeCategories:
  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
    Priority:        2
    SortPriority:    0
    CaseSensitive:   false
  - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
    Priority:        3
    SortPriority:    0
    CaseSensitive:   false
  - Regex:           '.*'
    Priority:        1
    SortPriority:    0
    CaseSensitive:   false
IncludeIsMainRegex: '(Test)?$'
IncludeIsMainSourceRegex: ''
IndentAccessModifiers: false
IndentCaseLabels: false
IndentCaseBlocks: false
IndentGotoLabels: true
IndentPPDirectives: None
IndentExternBlock: AfterExternBlock
IndentRequires:  false
IndentWidth:     2
IndentWrappedFunctionNames: false
InsertTrailingCommas: None
JavaScriptQuotes: Leave
JavaScriptWrapImports: true
KeepEmptyLinesAtTheStartOfBlocks: true
LambdaBodyIndentation: Signature
MacroBlockBegin: ''
MacroBlockEnd:   ''
MaxEmptyLinesToKeep: 1
NamespaceIndentation: None
ObjCBinPackProtocolList: Auto
ObjCBlockIndentWidth: 2
ObjCBreakBeforeNestedBlockParam: true
ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: true
PenaltyBreakAssignment: 2
PenaltyBreakBeforeFirstCallParameter: 19
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120
PenaltyBreakString: 1000
PenaltyBreakTemplateDeclaration: 10
PenaltyExcessCharacter: 1000000
PenaltyReturnTypeOnItsOwnLine: 60
PenaltyIndentedWhitespace: 0
PointerAlignment: Right
PPIndentWidth:   -1
ReferenceAlignment: Pointer
ReflowComments:  true
ShortNamespaceLines: 1
SortIncludes:    CaseSensitive
SortJavaStaticImport: Before
SortUsingDeclarations: true
SpaceAfterCStyleCast: false
SpaceAfterLogicalNot: false
SpaceAfterTemplateKeyword: true
SpaceBeforeAssignmentOperators: true
SpaceBeforeCaseColon: false
SpaceBeforeCpp11BracedList: false
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements
SpaceAroundPointerQualifiers: Default
SpaceBeforeRangeBasedForLoopColon: true
SpaceInEmptyBlock: false
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 1
SpacesInAngles:  Never
SpacesInConditionalStatement: false
SpacesInContainerLiterals: true
SpacesInCStyleCastParentheses: false
SpacesInLineCommentPrefix:
  Minimum:         1
  Maximum:         -1
SpacesInParentheses: false
SpacesInSquareBrackets: false
SpaceBeforeSquareBrackets: false
BitFieldColonSpacing: Both
Standard:        Latest
StatementAttributeLikeMacros:
  - Q_EMIT
StatementMacros:
  - Q_UNUSED
  - QT_REQUIRE_VERSION
TabWidth:        8
UseCRLF:         false
UseTab:          Never
WhitespaceSensitiveMacros:
  - STRINGIZE
  - PP_STRINGIZE
  - BOOST_PP_STRINGIZE
  - NS_SWIFT_NAME
  - CF_SWIFT_NAME
...